source: git/libpolys/polys/nc/ncSAFormula.cc @ 975db18

spielwiese
Last change on this file since 975db18 was 1f5565d, checked in by Oleksandr Motsak <motsak@…>, 12 years ago
added HWeyl add: experimental handling of homogenized Weyl algebras (formulas/detection and related)
  • Property mode set to 100644
File size: 17.3 KB
Line 
1/****************************************
2*  Computer Algebra System SINGULAR     *
3****************************************/
4/***************************************************************
5 *  File:    ncSAFormula.cc
6 *  Purpose: implementation of multiplication by formulas in simple NC subalgebras
7 *  Author:  motsak
8 *  Created:
9 *  Version: $Id$
10 *******************************************************************/
11
12#define MYTEST 0
13
14#if MYTEST
15#define OM_CHECK 4
16#define OM_TRACK 5
17// these settings must be before "mod2.h" in order to work!!!
18#endif
19
20
21#include "config.h"
22#include <misc/auxiliary.h>
23
24#ifdef HAVE_PLURAL
25
26#define PLURAL_INTERNAL_DECLARATIONS
27
28#ifndef NDEBUG
29#define OUTPUT MYTEST
30#else
31#define OUTPUT 0
32#endif
33
34#include <reporter/reporter.h>
35
36#include <coeffs/numbers.h>
37#include "coeffrings.h"
38
39#include "nc/ncSAFormula.h"
40// for CFormulaPowerMultiplier
41
42#include "monomials/ring.h"
43#include "monomials/p_polys.h"
44
45#include "nc/sca.h"
46
47
48
49
50bool ncInitSpecialPowersMultiplication(ring r)
51{
52#if OUTPUT 
53  Print("ncInitSpecialPowersMultiplication(ring), ring: \n");
54  rWrite(r, TRUE);
55  PrintLn();
56#endif
57
58  assume(rIsPluralRing(r));
59  assume(!rIsSCA(r));
60
61
62  if( r->GetNC()->GetFormulaPowerMultiplier() != NULL )
63  {
64    WarnS("Already defined!");
65    return false;
66  }
67
68 
69  r->GetNC()->GetFormulaPowerMultiplier() = new CFormulaPowerMultiplier(r);
70
71  return true;
72 
73}
74
75
76
77
78
79
80
81// TODO: return q-coeff?
82static inline BOOLEAN AreCommutingVariables(const ring r, int i, int j/*, number *qq*/)
83{
84#if OUTPUT 
85  Print("AreCommutingVariables(ring, k: %d, i: %d)!", j, i);
86  PrintLn();
87#endif
88
89  assume(i != j);
90
91  assume(i > 0);
92  assume(i <= r->N);
93
94
95  assume(j > 0);
96  assume(j <= r->N);
97
98  const BOOLEAN reverse = (i > j);
99
100  if (reverse) { int k = j; j = i; i = k; }
101
102  assume(i < j);
103
104  {
105    const poly d = GetD(r, i, j);
106
107#if OUTPUT 
108    Print("D_{%d, %d} = ", i, j); p_Write(d, r);
109#endif
110
111    if( d != NULL)
112      return FALSE;
113  }
114
115
116  {
117    const number q = p_GetCoeff(GetC(r, i, j), r);
118
119    if( !n_IsOne(q, r) ) 
120      return FALSE;
121  }
122
123  return TRUE; // [VAR(I), VAR(J)] = 0!!
124
125/*
126  if (reverse)
127    *qq = n_Invers(q, r);
128  else
129    *qq = n_Copy(q, r);
130  return TRUE;
131*/
132}
133
134static inline Enum_ncSAType AnalyzePairType(const ring r, int i, int j)
135{
136#if OUTPUT 
137  Print("AnalyzePair(ring, i: %d, j: %d):", i, j);
138  PrintLn();
139#endif
140
141  const int N = r->N;
142
143  assume(i < j);
144  assume(i > 0);
145  assume(j <= N);
146
147
148  const poly c = GetC(r, i, j);
149  const number q = p_GetCoeff(c, r);
150  const poly d = GetD(r, i, j);
151
152#if 0 && OUTPUT 
153  Print("C_{%d, %d} = ", i, j); p_Write(c, r); PrintLn();
154  Print("D_{%d, %d} = ", i, j); p_Write(d, r);
155#endif
156
157//  const number q = p_GetCoeff(c, r);
158
159  if( d == NULL)
160  {
161
162    if( n_IsOne(q, r) ) // commutative
163      return _ncSA_1xy0x0y0;
164
165    if( n_IsMOne(q, r) ) // anti-commutative
166      return _ncSA_Mxy0x0y0;
167
168    return _ncSA_Qxy0x0y0; // quasi-commutative
169  } else
170  {
171    if( n_IsOne(q, r) ) // "Lie" case
172    {
173      if( pNext(d) == NULL ) // Our Main Special Case: d is only a term!
174      {
175//         const number g = p_GetCoeff(d, r); // not used for now
176        if( p_LmIsConstantComp(d, r) ) // Weyl
177          return _ncSA_1xy0x0yG;
178
179        const int k = p_IsPurePower(d, r); // k if not pure power
180
181        if( k > 0 ) // d = var(k)^??
182        {
183          const int exp = p_GetExp(d, k, r);
184         
185          if (exp == 1)
186          {
187            if(k == i) // 2 -ubalgebra in var(i) & var(j), with linear relation...?
188              return _ncSA_1xyAx0y0;
189
190            if(k == j)
191              return _ncSA_1xy0xBy0;             
192          } else if ( exp == 2 && k!= i && k != j)  // Homogenized Weyl algebra [x, Dx] = t^2?
193          {
194//            number qi, qj;
195            if (AreCommutingVariables(r, k, i/*, &qi*/) && AreCommutingVariables(r, k, j/*, &qj*/) ) // [x, t] = [Dx, t] = 0?
196            {
197              const number g = p_GetCoeff(d, r);
198
199              if (n_IsOne(g, r)) 
200                return _ncSA_1xy0x0yT2; // save k!?, G = LC(d) == qi == qj == 1!!!
201            }
202          }
203        }
204      }
205    }
206    // Hmm, what about a more general case of q != 1???
207  }
208#if OUTPUT 
209  Print("C_{%d, %d} = ", i, j); p_Write(c, r);
210  Print("D_{%d, %d} = ", i, j); p_Write(d, r);
211  PrintS("====>>>>_ncSA_notImplemented\n");
212#endif
213
214  return _ncSA_notImplemented;
215}
216
217
218CFormulaPowerMultiplier::CFormulaPowerMultiplier(ring r): m_BaseRing(r), m_NVars(r->N)
219{
220#if OUTPUT 
221  Print("CFormulaPowerMultiplier::CFormulaPowerMultiplier(ring)!");
222  PrintLn();
223#endif
224
225  m_SAPairTypes = (Enum_ncSAType*)omAlloc0( ((NVars() * (NVars()-1)) / 2) * sizeof(Enum_ncSAType) );
226
227  for( int i = 1; i < NVars(); i++ )
228    for( int j = i + 1; j <= NVars(); j++ )
229      GetPair(i, j) = AnalyzePairType(GetBasering(), i, j);
230}
231
232
233
234
235CFormulaPowerMultiplier::~CFormulaPowerMultiplier()
236{
237#if OUTPUT 
238  Print("CFormulaPowerMultiplier::~CFormulaPowerMultiplier()!");
239  PrintLn();
240#endif
241
242  omFreeSize((ADDRESS)m_SAPairTypes, ((NVars() * (NVars()-1)) / 2) * sizeof(Enum_ncSAType) );
243}
244
245
246
247
248///////////////////////////////////////////////////////////////////////////////////////////
249static inline void CorrectPolyWRTOrdering(poly &pResult, const ring r)
250{
251  if( pNext(pResult) != NULL )
252  {
253    const int cmp = p_LmCmp(pResult, pNext(pResult), r);
254    assume( cmp != 0 ); // must not be equal!!!
255    if( cmp != 1 ) // Wrong order!!!
256      pResult = pReverse(pResult); // Reverse!!!
257  }
258  p_Test(pResult, r);
259}
260///////////////////////////////////////////////////////////////////////////////////////////
261static inline poly ncSA_1xy0x0y0(const int i, const int j, const int n, const int m, const ring r)
262{
263#if OUTPUT 
264  Print("ncSA_1xy0x0y0(var(%d)^{%d}, var(%d)^{%d}, r)!", j, m, i, n); 
265  PrintLn();
266#endif
267
268  poly p = p_One( r);
269  p_SetExp(p, j, m, r);
270  p_SetExp(p, i, n, r);
271  p_Setm(p, r);
272
273  p_Test(p, r);
274
275  return p;
276
277} //    return ncSA_1xy0x0y0(GetI(), GetJ(), expRight, expLeft, r);
278///////////////////////////////////////////////////////////////////////////////////////////
279static inline poly ncSA_Mxy0x0y0(const int i, const int j, const int n, const int m, const ring r)
280{
281#if OUTPUT 
282  Print("ncSA_{M = -1}xy0x0y0(var(%d)^{%d}, var(%d)^{%d}, r)!", j, m, i, n); 
283  PrintLn();
284#endif
285
286  const int  sign = 1 - ((n & (m & 1)) << 1);
287  poly p = p_ISet(sign, r);
288  p_SetExp(p, j, m, r);
289  p_SetExp(p, i, n, r);
290  p_Setm(p, r);
291
292
293  p_Test(p, r);
294
295  return p;
296
297} //    return ncSA_Mxy0x0y0(GetI(), GetJ(), expRight, expLeft, r);
298///////////////////////////////////////////////////////////////////////////////////////////
299static inline poly ncSA_Qxy0x0y0(const int i, const int j, const int n, const int m, const number m_q, const ring r)
300{
301#if OUTPUT 
302  Print("ncSA_Qxy0x0y0(var(%d)^{%d}, var(%d)^{%d}, Q, r)!", j, m, i, n); 
303  PrintLn();
304#endif
305
306  int min, max;
307
308  if( n < m )
309  {
310    min = n;
311    max = m;
312  } else
313  {
314    min = m;
315    max = n;
316  }
317
318  number qN;
319
320  if( max == 1 )
321    qN = n_Copy(m_q, r);
322  else
323  {
324    number t;
325    n_Power(m_q, max, &t, r);
326
327    if( min > 1 )
328    {
329      n_Power(t, min, &qN, r);
330      n_Delete(&t, r);     
331    }
332    else
333      qN = t;
334  }
335
336  poly p = p_NSet(qN, r);
337  p_SetExp(p, j, m, r);
338  p_SetExp(p, i, n, r);
339  p_Setm(p, r);
340
341
342  p_Test(p, r);
343
344  return p;
345
346} //    return ncSA_Qxy0x0y0(GetI(), GetJ(), expRight, expLeft, m_q, r);
347///////////////////////////////////////////////////////////////////////////////////////////
348static inline poly ncSA_1xy0x0yG(const int i, const int j, const int n, const int m, const number m_g, const ring r)
349{
350#if OUTPUT 
351  Print("ncSA_1xy0x0yG(var(%d)^{%d}, var(%d)^{%d}, G, r)!", j, m, i, n); 
352  PrintLn();
353  number t = n_Copy(m_g, r);
354  PrintS("Parameter G: "); n_Write(t, r);
355  n_Delete(&t, r);
356#endif
357
358  int kn = n;
359  int km = m;
360
361  number c = n_Init(1, r);
362
363  poly p = p_One( r);
364
365  p_SetExp(p, j, km--, r); // y ^ (m-k)
366  p_SetExp(p, i, kn--, r); // x ^ (n-k)
367
368  p_Setm(p, r); // pResult = x^n * y^m
369
370
371  poly pResult = p;
372  poly pLast = p;
373
374  int min = si_min(m, n);
375
376  int k = 1;
377
378  for(; k < min; k++ )
379  {
380    number t = n_Init(km + 1, r);
381    n_InpMult(t, m_g, r); // t = ((m - k) + 1) * gamma
382    n_InpMult(c, t, r);   // c = c'* ((m - k) + 1) * gamma
383    n_Delete(&t, r);
384
385    t = n_Init(kn + 1, r);
386    n_InpMult(c, t, r);   // c = (c'* ((m - k) + 1) * gamma) * ((n - k) + 1)
387    n_Delete(&t, r);
388
389    t = n_Init(k, r);
390    c = n_Div(c, t, r);
391    n_Delete(&t, r);
392
393//    n_Normalize(c, r);
394
395    t = n_Copy(c, r); // not the last!
396
397    p = p_NSet(t, r);
398
399    p_SetExp(p, j, km--, r); // y ^ (m-k)
400    p_SetExp(p, i, kn--, r); // x ^ (n-k)
401
402    p_Setm(p, r); // pResult = x^n * y^m
403
404    pNext(pLast) = p;
405    pLast = p;
406  }
407
408  assume(k == min);
409  assume((km == 0) || (kn == 0) );
410
411  {
412    n_InpMult(c, m_g, r);   // c = c'* gamma
413
414    if( km > 0 )
415    {
416      number t = n_Init(km + 1, r);
417      n_InpMult(c, t, r);   // c = (c'* gamma) * (m - k + 1)
418      n_Delete(&t, r);
419    }
420
421    if( kn > 0 )
422    {
423      number t = n_Init(kn + 1, r);
424      n_InpMult(c, t, r);   // c = (c'* gamma) * (n - k + 1)
425      n_Delete(&t, r);
426    }
427
428    number t = n_Init(k, r); // c = ((c'* gamma) * ((n - k + 1) * (m - k + 1))) / k;
429    c = n_Div(c, t, r);
430    n_Delete(&t, r);
431  }
432
433  p = p_NSet(c, r);
434
435  p_SetExp(p, j, km, r); // y ^ (m-k)
436  p_SetExp(p, i, kn, r); // x ^ (n-k)
437
438  p_Setm(p, r); //
439
440  pNext(pLast) = p;
441
442  CorrectPolyWRTOrdering(pResult, r);
443
444  return pResult;
445}
446///////////////////////////////////////////////////////////////////////////////////////////
447///////////////////////////////////////////////////////////////////////////////////////////
448static inline poly ncSA_1xy0x0yT2(const int i, const int j, const int n, const int m, const int m_k, const ring r)
449{
450#if OUTPUT 
451  Print("ncSA_1xy0x0yT2(var(%d)^{%d}, var(%d)^{%d}, t: var(%d), r)!", j, m, i, n, m_k); 
452  PrintLn();
453#endif
454
455  int kn = n;
456  int km = m;
457
458  // k == 0!
459  number c = n_Init(1, r);
460
461  poly p = p_One( r );
462
463  p_SetExp(p, j, km--, r); // y ^ (m)
464  p_SetExp(p, i, kn--, r); // x ^ (n)
465//  p_SetExp(p, m_k, k << 1, r); // homogenization with var(m_k) ^ (2*k)
466
467  p_Setm(p, r); // pResult = x^n * y^m
468
469
470  poly pResult = p;
471  poly pLast = p;
472
473  int min = si_min(m, n);
474
475  int k = 1;
476
477  for(; k < min; k++ )
478  {
479    number t = n_Init(km + 1, r);
480//    n_InpMult(t, m_g, r); // t = ((m - k) + 1) * gamma
481    n_InpMult(c, t, r);   // c = c'* ((m - k) + 1) * gamma
482    n_Delete(&t, r);
483
484    t = n_Init(kn + 1, r);
485    n_InpMult(c, t, r);   // c = (c'* ((m - k) + 1) * gamma) * ((n - k) + 1)
486    n_Delete(&t, r);
487
488    t = n_Init(k, r);
489    c = n_Div(c, t, r);
490    n_Delete(&t, r);
491
492// //    n_Normalize(c, r);
493
494    t = n_Copy(c, r); // not the last!
495
496    p = p_NSet(t, r);
497
498    p_SetExp(p, j, km--, r); // y ^ (m-k)
499    p_SetExp(p, i, kn--, r); // x ^ (n-k)
500
501    p_SetExp(p, m_k, k << 1, r); // homogenization with var(m_k) ^ (2*k)
502   
503    p_Setm(p, r); // pResult = x^(n-k) * y^(m-k)
504
505    pNext(pLast) = p;
506    pLast = p;
507  }
508
509  assume(k == min);
510  assume((km == 0) || (kn == 0) );
511
512  {
513//    n_InpMult(c, m_g, r);   // c = c'* gamma
514
515    if( km > 0 )
516    {
517      number t = n_Init(km + 1, r);
518      n_InpMult(c, t, r);   // c = (c'* gamma) * (m - k + 1)
519      n_Delete(&t, r);
520    }
521
522    if( kn > 0 )
523    {
524      number t = n_Init(kn + 1, r);
525      n_InpMult(c, t, r);   // c = (c'* gamma) * (n - k + 1)
526      n_Delete(&t, r);
527    }
528
529    number t = n_Init(k, r); // c = ((c'* gamma) * ((n - k + 1) * (m - k + 1))) / k;
530    c = n_Div(c, t, r);
531    n_Delete(&t, r);
532  }
533
534  p = p_NSet(c, r);
535
536  p_SetExp(p, j, km, r); // y ^ (m-k)
537  p_SetExp(p, i, kn, r); // x ^ (n-k)
538
539  p_SetExp(p, m_k, k << 1, r); // homogenization with var(m_k) ^ (2*k)
540
541  p_Setm(p, r); //
542
543  pNext(pLast) = p;
544
545  CorrectPolyWRTOrdering(pResult, r);
546
547  return pResult;
548}
549///////////////////////////////////////////////////////////////////////////////////////////
550
551
552
553///////////////////////////////////////////////////////////////////////////////////////////
554static inline poly ncSA_ShiftAx(int i, int j, int n, int m, const number m_shiftCoef, const ring r)
555{
556  // Char == 0, otherwise - problem!
557
558  int k = m; // to 0
559
560  number c = n_Init(1, r); // k = m, C_k = 1
561  poly p = p_One( r);
562
563  p_SetExp(p, j, k, r); // Y^{k}
564  p_SetExp(p, i, n, r); 
565
566  p_Setm(p, r); // pResult = C_k * x^n * y^k, k == m
567
568
569  poly pResult = p;
570  poly pLast = p;
571
572  number nn =  n_Init(n, r); // number(n)!
573  n_InpMult(nn, m_shiftCoef, r); // nn = (alpha*n)
574
575  --k;
576
577  int mk = 1; // mk = (m - k)
578
579  for(; k > 0; k-- )
580  {
581    number t = n_Init(k + 1, r);  // t = k+1
582    n_InpMult(c, t, r);           // c = c' * (k+1)
583    n_InpMult(c, nn, r);          // c = (c' * (k+1)) * (alpha * n)
584
585    n_Delete(&t, r);
586    t = n_Init(mk++, r);         
587    c = n_Div(c, t, r);           // c = ((c' * (k+1))  * (alpha * n)) / (m-k);
588    n_Delete(&t, r);
589
590//    n_Normalize(c, r);
591
592    t = n_Copy(c, r); // not the last!
593
594    p = p_NSet(t, r);
595
596    p_SetExp(p, j, k, r); // y^k
597    p_SetExp(p, i, n, r); // x^n
598
599    p_Setm(p, r); // pResult = x^n * y^m
600
601    pNext(pLast) = p;
602    pLast = p;
603  }
604
605  assume(k == 0);
606
607  {
608    n_InpMult(c, nn, r);          // c = (c' * (0+1)) * (alpha * n)
609
610    number t = n_Init(m, r);         
611    c = n_Div(c, t, r);           // c = ((c' * (0+1))  * (alpha * n)) / (m-0);
612    n_Delete(&t, r);
613  }
614
615  n_Delete(&nn, r);
616
617  p = p_NSet(c, r);
618
619  p_SetExp(p, j, k, r); // y^k
620  p_SetExp(p, i, n, r); // x^n
621
622  p_Setm(p, r); //
623
624  pNext(pLast) = p;
625
626  CorrectPolyWRTOrdering(pResult, r);
627
628  return pResult;
629}
630///////////////////////////////////////////////////////////////////////////////////////////
631static inline poly ncSA_1xyAx0y0(const int i, const int j, const int n, const int m, const number m_shiftCoef, const ring r)
632{
633#if OUTPUT 
634  Print("ncSA_1xyAx0y0(var(%d)^{%d}, var(%d)^{%d}, A, r)!", j, m, i, n); 
635  PrintLn();
636  number t = n_Copy(m_shiftCoef, r);
637  PrintS("Parameter A: "); n_Write(t, r);
638  n_Delete(&t, r); 
639#endif
640
641  return ncSA_ShiftAx(i, j, n, m, m_shiftCoef, r);
642}
643///////////////////////////////////////////////////////////////////////////////////////////
644static inline poly ncSA_1xy0xBy0(const int i, const int j, const int n, const int m, const number m_shiftCoef, const ring r)
645{
646#if OUTPUT 
647  Print("ncSA_1xy0xBy0(var(%d)^{%d}, var(%d)^{%d}, B, r)!", j, m, i, n); 
648  PrintLn();
649  number t = n_Copy(m_shiftCoef, r);
650  PrintS("Parameter B: "); n_Write(t, r);
651  n_Delete(&t, r); 
652#endif
653
654  return ncSA_ShiftAx(j, i, m, n, m_shiftCoef, r);
655}
656///////////////////////////////////////////////////////////////////////////////////////////
657///////////////////////////////////////////////////////////////////////////////////////////
658///////////////////////////////////////////////////////////////////////////////////////////
659///////////////////////////////////////////////////////////////////////////////////////////
660
661
662static inline poly ncSA_Multiply( Enum_ncSAType type, const int i, const int j, const int n, const int m, const ring r)
663{
664#if OUTPUT 
665  Print("ncSA_Multiply(type: %d, ring, (var(%d)^{%d} * var(%d)^{%d}, r)!", (int)type, j, m, i, n); 
666  PrintLn();
667#endif
668
669  assume( type != _ncSA_notImplemented );
670  assume( (n > 0) && (m > 0) );
671
672  if( type == _ncSA_1xy0x0y0 )
673    return ::ncSA_1xy0x0y0(i, j, n, m, r);
674
675  if( type == _ncSA_Mxy0x0y0 )
676    return ::ncSA_Mxy0x0y0(i, j, n, m, r);
677
678  if( type == _ncSA_Qxy0x0y0 )
679  {
680    const number q = p_GetCoeff(GetC(r, i, j), r);
681    return ::ncSA_Qxy0x0y0(i, j, n, m, q, r);
682  }
683
684  const poly d = GetD(r, i, j);
685  const number g = p_GetCoeff(d, r);
686
687  if( type == _ncSA_1xy0x0yG ) // Weyl
688    return ::ncSA_1xy0x0yG(i, j, n, m, g, r);
689
690  if( type == _ncSA_1xy0x0yT2 ) // Homogenous Weyl...
691    return ::ncSA_1xy0x0yT2(i, j, n, m, p_IsPurePower(d, r), r);
692 
693  if( type == _ncSA_1xyAx0y0 ) // Shift 1
694    return ::ncSA_1xyAx0y0(i, j, n, m, g, r);
695
696  if( type == _ncSA_1xy0xBy0 ) // Shift 2
697    return ::ncSA_1xy0xBy0(i, j, n, m, g, r);
698
699  assume( type == _ncSA_notImplemented );
700
701  return NULL;
702}
703
704
705poly CFormulaPowerMultiplier::Multiply( Enum_ncSAType type, const int i, const int j, const int n, const int m, const ring r)
706{
707  return ncSA_Multiply( type, i, j, n, m, r);
708}
709
710
711Enum_ncSAType CFormulaPowerMultiplier::AnalyzePair(const ring r, int i, int j)
712{
713  return ::AnalyzePairType( r, i, j);
714}
715
716poly CFormulaPowerMultiplier::Multiply( int i, int j, const int n, const int m)
717{
718  return ncSA_Multiply( GetPair(i, j), i, j, n, m, GetBasering());
719}
720
721
722
723
724poly CFormulaPowerMultiplier::ncSA_1xy0x0y0(const int i, const int j, const int n, const int m, const ring r)
725{
726  return ::ncSA_1xy0x0y0(i, j, n, m, r);
727}
728
729poly CFormulaPowerMultiplier::ncSA_Mxy0x0y0(const int i, const int j, const int n, const int m, const ring r)
730{
731  return ::ncSA_Mxy0x0y0(i, j, n, m, r);
732}
733
734poly CFormulaPowerMultiplier::ncSA_Qxy0x0y0(const int i, const int j, const int n, const int m, const number m_q, const ring r)
735{
736  return ::ncSA_Qxy0x0y0(i, j, n, m, m_q, r);
737}
738
739poly CFormulaPowerMultiplier::ncSA_1xy0x0yG(const int i, const int j, const int n, const int m, const number m_g, const ring r)
740{
741  return ::ncSA_1xy0x0yG(i, j, n, m, m_g, r);
742}
743
744poly CFormulaPowerMultiplier::ncSA_1xy0x0yT2(const int i, const int j, const int n, const int m, const int k, const ring r)
745{
746  return ::ncSA_1xy0x0yT2(i, j, n, m, k, r);
747}
748
749poly CFormulaPowerMultiplier::ncSA_1xyAx0y0(const int i, const int j, const int n, const int m, const number m_shiftCoef, const ring r)
750{
751  return ::ncSA_1xyAx0y0(i, j, n, m, m_shiftCoef, r);
752}
753
754poly CFormulaPowerMultiplier::ncSA_1xy0xBy0(const int i, const int j, const int n, const int m, const number m_shiftCoef, const ring r)
755{
756  return ::ncSA_1xy0xBy0(i, j, n, m, m_shiftCoef, r);
757}
758#endif
Note: See TracBrowser for help on using the repository browser.