source: git/libpolys/polys/nc/ncSAFormula.cc @ f9b0bd

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