source: git/kernel/clapconv.cc @ a89a115

spielwiese
Last change on this file since a89a115 was a89a115, checked in by Hans Schönemann <hannes@…>, 19 years ago
*hannes: convSingTrPClapP: check for denominator !=1 git-svn-id: file:///usr/local/Singular/svn/trunk@7692 2c84dea3-7e68-4137-9b89-c4e89433aadc
  • Property mode set to 100644
File size: 16.7 KB
Line 
1// emacs edit mode for this file is -*- C++ -*-
2/****************************************
3*  Computer Algebra System SINGULAR     *
4****************************************/
5// $Id: clapconv.cc,v 1.2 2005-01-27 16:35:30 Singular Exp $
6/*
7* ABSTRACT: convert data between Singular and factory
8*/
9
10
11#include "mod2.h"
12#ifdef HAVE_FACTORY
13#include "omalloc.h"
14#include "structs.h"
15#define SI_DONT_HAVE_GLOBAL_VARS
16#include "clapconv.h"
17#include "numbers.h"
18#include "modulop.h"
19#include "longalg.h"
20#include "polys.h"
21#include "febase.h"
22#include "ring.h"
23
24static void convRec( const CanonicalForm & f, int * exp, poly & result );
25
26static void convRecAlg( const CanonicalForm & f, int * exp, napoly & result );
27
28static void convRecPP ( const CanonicalForm & f, int * exp, poly & result );
29static void conv_RecPP ( const CanonicalForm & f, int * exp, poly & result, ring r );
30
31static void convRecPTr ( const CanonicalForm & f, int * exp, napoly & result );
32
33static void convRecAP ( const CanonicalForm & f, int * exp, poly & result );
34
35static void convRecTrP ( const CanonicalForm & f, int * exp, poly & result, int offs );
36
37static void convRecGFGF ( const CanonicalForm & f, int * exp, poly & result );
38
39static number convClapNSingAN( const CanonicalForm &f);
40
41CanonicalForm
42convSingNClapN( number n )
43{
44  CanonicalForm term;
45  /* does only work for Zp, Q */
46  if ( getCharacteristic() != 0 )
47  {
48    Off(SW_USE_EZGCD);
49    term = npInt( n );
50  }
51  else
52  {
53    if ( ((int)n) & 1 )
54    {
55      term = ((int)n) >>2;
56    }
57    else
58    {
59      if ( n->s == 3 )
60      {
61        MP_INT dummy;
62        mpz_init_set( &dummy, &(n->z) );
63        term = make_cf( dummy );
64      }
65      else  if ( n->s == 1 )
66      {
67        MP_INT num, den;
68        On(SW_RATIONAL);
69        mpz_init_set( &num, &(n->z) );
70        mpz_init_set( &den, &(n->n) );
71        term = make_cf( num, den, false );
72      }
73      else
74      { // assume s == 0
75        MP_INT num, den;
76        mpz_init_set( &num, &(n->z) );
77        mpz_init_set( &den, &(n->n) );
78        term = make_cf( num, den, true );
79      }
80    }
81  }
82  return term;
83}
84
85number
86convClapNSingN( const CanonicalForm & n)
87{
88  if (n.isImm())
89    return nInit(n.intval());
90  else
91  {
92    number z=(number)omAllocBin(rnumber_bin);
93#if defined(LDEBUG)
94    z->debug=123456;
95#endif
96    z->z = gmp_numerator( n );
97    if ( n.den() == 1 )
98      z->s = 3;
99    else
100    {
101      z->n = gmp_denominator( n );
102      z->s = 0;
103    }
104    return z;
105  }
106}
107
108CanonicalForm conv_SingPClapP( poly p, ring r )
109{
110  CanonicalForm result = 0;
111  int e, n = r->N;
112  assume( rPar(r)==0);
113
114  while ( p != NULL )
115  {
116    CanonicalForm term;
117    /* does only work for finite fields */
118    if ( getCharacteristic() != 0 )
119    {
120      Off(SW_USE_EZGCD);
121      term = npInt( pGetCoeff( p ) );
122    }
123    else
124    {
125      if ( (int)(pGetCoeff( p )) & 1 )
126      {
127        term = ((int)( pGetCoeff( p ) )>>2);
128      }
129      else
130      {
131        if ( pGetCoeff( p )->s == 3 )
132        {
133          MP_INT dummy;
134          mpz_init_set( &dummy, &(pGetCoeff( p )->z) );
135          term = make_cf( dummy );
136        }
137        else  if ( pGetCoeff( p )->s == 1 )
138        {
139          MP_INT num, den;
140          On(SW_RATIONAL);
141          mpz_init_set( &num, &(pGetCoeff( p )->z) );
142          mpz_init_set( &den, &(pGetCoeff( p )->n) );
143          term = make_cf( num, den, false );
144        }
145        else
146        { // assume s == 0
147          MP_INT num, den;
148          mpz_init_set( &num, &(pGetCoeff( p )->z) );
149          mpz_init_set( &den, &(pGetCoeff( p )->n) );
150          term = make_cf( num, den, true );
151        }
152      }
153    }
154    for ( int i = 1; i <= n; i++ )
155    {
156      if ( (e = p_GetExp( p, i, r )) != 0 )
157         term *= power( Variable( i ), e );
158    }
159    result += term;
160    p = pNext( p );
161  }
162  return result;
163}
164
165poly convClapPSingP ( const CanonicalForm & f )
166{
167//    cerr << " f = " << f << endl;
168  int n = pVariables+1;
169  /* ASSERT( level( f ) <= pVariables, "illegal number of variables" ); */
170  int * exp = new int[n];
171  //for ( int i = 0; i < n; i++ ) exp[i] = 0;
172  memset(exp,0,n*sizeof(int));
173  poly result = NULL;
174  convRecPP( f, exp, result );
175  delete [] exp;
176  return result;
177}
178
179static void convRecPP ( const CanonicalForm & f, int * exp, poly & result )
180{
181  if (f == 0)
182    return;
183  if ( ! f.inCoeffDomain() )
184  {
185    int l = f.level();
186    for ( CFIterator i = f; i.hasTerms(); i++ )
187    {
188      exp[l] = i.exp();
189      convRecPP( i.coeff(), exp, result );
190    }
191    exp[l] = 0;
192  }
193  else
194  {
195    poly term = pInit();
196    pNext( term ) = NULL;
197    for ( int i = 1; i <= pVariables; i++ )
198      pSetExp( term, i, exp[i]);
199    pSetComp(term, 0);
200    if ( getCharacteristic() != 0 )
201    {
202      pGetCoeff( term ) = nInit( f.intval() );
203    }
204    else
205    {
206      if ( f.isImm() )
207        pGetCoeff( term ) = nInit( f.intval() );
208      else
209      {
210        number z=(number)omAllocBin(rnumber_bin);
211#if defined(LDEBUG)
212        z->debug=123456;
213#endif
214        z->z = gmp_numerator( f );
215        if ( f.den() == 1 )
216          z->s = 3;
217        else
218        {
219          z->n = gmp_denominator( f );
220          z->s = 0;
221        }
222        pGetCoeff( term ) = z;
223      }
224    }
225    pSetm( term );
226    if ( nIsZero(pGetCoeff(term)) )
227    {
228      pDelete(&term);
229    }
230    else
231    {
232      result = pAdd( result, term );
233    }
234  }
235}
236
237poly conv_ClapPSingP ( const CanonicalForm & f, ring r )
238{
239//    cerr << " f = " << f << endl;
240  int n = r->N+1;
241  /* ASSERT( level( f ) <= pVariables, "illegal number of variables" ); */
242  int * exp = new int[n];
243  //for ( int i = 0; i < n; i++ ) exp[i] = 0;
244  memset(exp,0,n*sizeof(int));
245  poly result = NULL;
246  conv_RecPP( f, exp, result, r );
247  delete [] exp;
248  return result;
249}
250
251static void
252conv_RecPP ( const CanonicalForm & f, int * exp, poly & result, ring r )
253{
254  if (f == 0)
255    return;
256  if ( ! f.inCoeffDomain() )
257  {
258    int l = f.level();
259    for ( CFIterator i = f; i.hasTerms(); i++ )
260    {
261      exp[l] = i.exp();
262      conv_RecPP( i.coeff(), exp, result, r );
263    }
264    exp[l] = 0;
265  }
266  else
267  {
268    poly term = p_Init(r);
269    pNext( term ) = NULL;
270    for ( int i = 1; i <= r->N; i++ )
271      p_SetExp( term, i, exp[i], r);
272    if (rRing_has_Comp(r)) p_SetComp(term, 0, r);
273    if ( getCharacteristic() != 0 )
274    {
275      pGetCoeff( term ) = n_Init( f.intval(), r );
276    }
277    else
278    {
279      if ( f.isImm() )
280        pGetCoeff( term ) = n_Init( f.intval(), r );
281      else
282      {
283        number z=(number)omAllocBin(rnumber_bin);
284#if defined(LDEBUG)
285        z->debug=123456;
286#endif
287        z->z = gmp_numerator( f );
288        if ( f.den() == 1 )
289          z->s = 3;
290        else
291        {
292          z->n = gmp_denominator( f );
293          z->s = 0;
294        }
295        pGetCoeff( term ) = z;
296      }
297    }
298    p_Setm( term, r );
299    if ( n_IsZero(pGetCoeff(term), r) )
300    {
301      p_Delete(&term,r);
302    }
303    else
304    {
305      result = p_Add_q( result, term, r );
306    }
307  }
308}
309
310
311CanonicalForm
312convSingTrClapP( napoly p )
313{
314  CanonicalForm result = 0;
315  int e, n = napVariables;
316
317  while ( p!=NULL)
318  {
319    CanonicalForm term;
320    /* does only work for finite fields */
321    if ( getCharacteristic() != 0 )
322    {
323      Off(SW_USE_EZGCD);
324      term = npInt( napGetCoeff( p ) );
325    }
326    else
327    {
328      On(SW_USE_EZGCD);
329      //if ( (!(int)(napGetCoeff( p )) & 1 )
330      //&&  ( napGetCoeff( p )->s == 0))
331      //  naNormalize( naGetCoeff( p ) );
332      if ( (int)(napGetCoeff( p )) & 1 )
333        term = nlInt( napGetCoeff( p ) );
334      else
335      {
336        if ( napGetCoeff( p )->s == 3 )
337        {
338          MP_INT dummy;
339          mpz_init_set( &dummy, &(napGetCoeff( p )->z) );
340          term = make_cf( dummy );
341        }
342        else  if ( napGetCoeff( p )->s == 1 )
343        {
344          MP_INT num, den;
345          On(SW_RATIONAL);
346          mpz_init_set( &num, &(napGetCoeff( p )->z) );
347          mpz_init_set( &den, &(napGetCoeff( p )->n) );
348          term = make_cf( num, den, false );
349        }
350        else
351        { // assume s == 0
352          MP_INT num, den;
353          On(SW_RATIONAL);
354          mpz_init_set( &num, &(napGetCoeff( p )->z) );
355          mpz_init_set( &den, &(napGetCoeff( p )->n) );
356          term = make_cf( num, den, true );
357        }
358      }
359    }
360    for ( int i = 1; i <= n; i++ )
361    {
362      if ( (e = napGetExp( p, i )) != 0 )
363        term *= power( Variable( i ), e );
364    }
365    result += term;
366    p = napNext( p );
367  }
368  return result;
369}
370
371napoly
372convClapPSingTr ( const CanonicalForm & f )
373{
374//    cerr << " f = " << f << endl;
375  int n = napVariables+1;
376  /* ASSERT( level( f ) <= napVariables, "illegal number of variables" ); */
377  int * exp = new int[n];
378  // for ( int i = 0; i < n; i++ ) exp[i] = 0;
379  memset(exp,0,n*sizeof(int));
380  napoly result = NULL;
381  convRecPTr( f, exp, result );
382  delete [] exp;
383  return result;
384}
385
386static void
387convRecPTr ( const CanonicalForm & f, int * exp, napoly & result )
388{
389  if (f == 0)
390    return;
391  if ( ! f.inCoeffDomain() )
392  {
393    int l = f.level();
394    for ( CFIterator i = f; i.hasTerms(); i++ )
395    {
396        exp[l] = i.exp();
397        convRecPTr( i.coeff(), exp, result );
398    }
399    exp[l] = 0;
400  }
401  else
402  {
403    napoly term = napNew();
404    // napNext( term ) = NULL; //already done by napNew
405    for ( int i = 1; i <= napVariables; i++ )
406      napSetExp( term, i , exp[i]);
407    if ( getCharacteristic() != 0 )
408    {
409      napGetCoeff( term ) = npInit( f.intval() );
410    }
411    else
412    {
413      if ( f.isImm() )
414        napGetCoeff( term ) = nlInit( f.intval() );
415      else
416      {
417        number z=(number)omAllocBin(rnumber_bin);
418#if defined(LDEBUG)
419        z->debug=123456;
420#endif
421        z->z = gmp_numerator( f );
422        if ( f.den() == 1 )
423        {
424          z->s = 3;
425        }
426        else
427        {
428          z->n = gmp_denominator( f );
429          if (mpz_cmp_si(&z->n,(long)1)==0)
430          {
431            mpz_clear(&z->n);
432            z->s=3;
433          }
434          else
435          {
436            z->s = 0;
437          }
438          nacNormalize(z);
439        }
440        napGetCoeff( term ) = z;
441      }
442    }
443    result = napAdd( result, term );
444  }
445}
446
447CanonicalForm convSingAPClapAP ( poly p , const Variable & a)
448{
449  CanonicalForm result = 0;
450  int e, n = pVariables;
451  int off=rPar(currRing);
452
453  On(SW_RATIONAL);
454  while ( p!=NULL)
455  {
456    CanonicalForm term=convSingAClapA(((lnumber)pGetCoeff(p))->z,a);
457    for ( int i = 1; i <= n; i++ )
458    {
459      if ( (e = pGetExp( p, i )) != 0 )
460        term *= power( Variable( i + off), e );
461    }
462    result += term;
463    p = pNext( p );
464  }
465  return result;
466}
467
468poly convClapAPSingAP ( const CanonicalForm & f )
469{
470  int n = pVariables+1+1/*rPar(currRing)*/;
471  int * exp = new int[n];
472  // for ( int i = 0; i < n; i++ ) exp[i] = 0;
473  memset(exp,0,n*sizeof(int));
474  poly result = NULL;
475  convRecAP( f, exp, result );
476  delete [] exp;
477  return result;
478}
479
480static void
481convRecAP ( const CanonicalForm & f, int * exp, poly & result )
482{
483  if (f == 0)
484    return;
485  int off=rPar(currRing);
486  if ( ! f.inCoeffDomain() )
487  {
488    int l = f.level();
489    for ( CFIterator i = f; i.hasTerms(); i++ )
490    {
491      exp[l] = i.exp();
492      convRecAP( i.coeff(), exp, result );
493    }
494    exp[l] = 0;
495  }
496  else
497  {
498    napoly z=(napoly)convClapASingA( f );
499    if (z!=NULL)
500    {
501      poly term = pInit();
502      pNext( term ) = NULL;
503      int i;
504      for ( i = 1; i <= pVariables; i++ )
505        pSetExp( term, i , exp[i+off]);
506      pSetComp(term, 0);
507      for ( i = 1; i <= off; i++ )
508        //z->e[i-1]+=exp[i];
509        napAddExp(z,i,exp[i]);
510      pGetCoeff(term)=(number)omAlloc0Bin(rnumber_bin);
511      ((lnumber)pGetCoeff(term))->z=z;
512      pSetm( term );
513      result = pAdd( result, term );
514    }
515  }
516}
517
518CanonicalForm convSingAClapA ( napoly p , const Variable & a )
519{
520  CanonicalForm result = 0;
521  int e;
522
523  while ( p!=NULL )
524  {
525    CanonicalForm term;
526    /* does only work for finite fields:Z/p */
527    if ( rField_is_Zp_a() )
528    {
529      Off(SW_USE_EZGCD);
530      term = npInt( napGetCoeff( p ) );
531    }
532    else
533    {
534      On(SW_USE_EZGCD);
535      //if ( (!(int)(napGetCoeff( p )) & 1 )
536      //&&  ( napGetCoeff( p )->s == 0))
537      //  naNormalize( naGetCoeff( p ) );
538      if ( (int)(napGetCoeff( p )) & SR_INT )
539        term = nlInt( napGetCoeff( p ) );
540        //term = SR_TO_INT(napGetCoeff( p )) ;
541      else
542      {
543        if ( napGetCoeff( p )->s == 3 )
544        {
545          MP_INT dummy;
546          mpz_init_set( &dummy, &(napGetCoeff( p )->z) );
547          term = make_cf( dummy );
548        }
549        else  if ( napGetCoeff( p )->s == 1 )
550        {
551          MP_INT num, den;
552          On(SW_RATIONAL);
553          mpz_init_set( &num, &(napGetCoeff( p )->z) );
554          mpz_init_set( &den, &(napGetCoeff( p )->n) );
555          term = make_cf( num, den, false );
556        }
557        else
558        { // assume s == 0
559          MP_INT num, den;
560          On(SW_RATIONAL);
561          mpz_init_set( &num, &(napGetCoeff( p )->z) );
562          mpz_init_set( &den, &(napGetCoeff( p )->n) );
563          term = make_cf( num, den, true );
564        }
565      }
566    }
567    if ( (e = napGetExp( p, 1 )) != 0 )
568      term *= power( a , e );
569    result += term;
570    p = napNext( p );
571  }
572  return result;
573}
574
575static number convClapNSingAN( const CanonicalForm &f)
576{
577  if ((getCharacteristic() != 0) || ( f.isImm() ))
578    return nacInit( f.intval() );
579  else
580  {
581    number z=(number)omAllocBin(rnumber_bin);
582#if defined(LDEBUG)
583    z->debug=123456;
584#endif
585    z->z = gmp_numerator( f );
586    if ( f.den() == 1 )
587    {
588      z->s = 3;
589    }
590    else
591    {
592      z->n = gmp_denominator( f );
593      z->s = 0;
594    }
595    #ifdef LDEBUG
596    nlDBTest(z,__FILE__,__LINE__);
597    #endif
598    return z;
599  }
600}
601
602napoly convClapASingA ( const CanonicalForm & f )
603{
604  napoly a=NULL;
605  napoly t;
606  for( CFIterator i=f; i.hasTerms(); i++)
607  {
608    t=napNew();
609    // napNext( t ) = NULL; //already done by napNew
610    napGetCoeff(t)=convClapNSingAN( i.coeff() );
611    if (nacIsZero(napGetCoeff(t)))
612    {
613      napDelete(&t);
614    }
615    else
616    {
617      napSetExp(t,1,i.exp());
618      a=napAdd(a,t);
619    }
620  }
621  return a;
622}
623
624CanonicalForm convSingTrPClapP ( poly p )
625{
626  CanonicalForm result = 0;
627  int e, n = pVariables;
628  int offs = rPar(currRing);
629
630  while ( p!=NULL )
631  {
632    nNormalize(pGetCoeff(p));
633    CanonicalForm term=convSingTrClapP(((lnumber)pGetCoeff(p))->z);
634
635    if ((((lnumber)pGetCoeff(p))->n!=NULL)
636    && (!errorreported))
637    {
638      WerrorS("conversion error: denominator!= 1");
639    }
640
641    for ( int i = 1; i <= n; i++ )
642    {
643      if ( (e = pGetExp( p, i )) != 0 )
644        term = term * power( Variable( i + offs ), e );
645    }
646    result += term;
647    p = pNext( p );
648  }
649  return result;
650}
651
652poly convClapPSingTrP ( const CanonicalForm & f )
653{
654  int n = pVariables+1;
655  int * exp = new int[n];
656  // for ( int i = 0; i < n; i++ ) exp[i] = 0;
657  memset(exp,0,n*sizeof(int));
658  poly result = NULL;
659  convRecTrP( f, exp, result , rPar(currRing) );
660  delete [] exp;
661  return result;
662}
663
664static void
665convRecTrP ( const CanonicalForm & f, int * exp, poly & result , int offs)
666{
667  if (f == 0)
668    return;
669  if ( f.level() > offs )
670  {
671    int l = f.level();
672    for ( CFIterator i = f; i.hasTerms(); i++ )
673    {
674      exp[l-offs] = i.exp();
675      convRecTrP( i.coeff(), exp, result, offs );
676    }
677    exp[l-offs] = 0;
678  }
679  else
680  {
681    poly term = pInit();
682    pNext( term ) = NULL;
683    for ( int i = 1; i <= pVariables; i++ )
684      pSetExp( term, i ,exp[i]);
685    pSetComp(term, 0);
686    pGetCoeff(term)=(number)omAlloc0Bin(rnumber_bin);
687    ((lnumber)pGetCoeff(term))->z=convClapPSingTr( f );
688    pSetm( term );
689    result = pAdd( result, term );
690  }
691}
692
693#if 0
694CanonicalForm
695convSingGFClapGF( poly p )
696{
697  CanonicalForm result = 0;
698  int e, n = pVariables;
699
700  while ( p != NULL )
701  {
702    CanonicalForm term;
703    term = make_cf_from_gf( pGetCoeff( p ) );
704    for ( int i = 1; i <= n; i++ )
705    {
706      if ( (e = pGetExp( p, i )) != 0 )
707         term *= power( Variable( i ), e );
708    }
709    result += term;
710    p = pNext( p );
711  }
712  return result;
713}
714
715poly
716convClapGFSingGF ( const CanonicalForm & f )
717{
718//    cerr << " f = " << f << endl;
719  int n = pVariables+1;
720  /* ASSERT( level( f ) <= pVariables, "illegal number of variables" ); */
721  int * exp = new int[n];
722  //for ( int i = 0; i < n; i++ ) exp[i] = 0;
723  memset(exp,0,n*sizeof(int));
724  poly result = NULL;
725  convRecGFGF( f, exp, result );
726  delete [] exp;
727  return result;
728}
729
730static void
731convRecGFGF ( const CanonicalForm & f, int * exp, poly & result )
732{
733  if (f == 0)
734    return;
735  if ( ! f.inCoeffDomain() )
736  {
737    int l = f.level();
738    for ( CFIterator i = f; i.hasTerms(); i++ )
739    {
740      exp[l] = i.exp();
741      convRecGFGF( i.coeff(), exp, result );
742    }
743    exp[l] = 0;
744  }
745  else
746  {
747    poly term = pInit();
748    pNext( term ) = NULL;
749    for ( int i = 1; i <= pVariables; i++ )
750      pSetExp( term, i, exp[i]);
751    pSetComp(term, 0);
752    pGetCoeff( term ) = (number) gf_value (f);
753    pSetm( term );
754    result = pAdd( result, term );
755  }
756}
757#endif
758
759int convClapISingI( const CanonicalForm & f)
760{
761  if (!f.isImm()) WerrorS("int overflow in det");
762  return f.intval();
763}
764#endif
Note: See TracBrowser for help on using the repository browser.