source: git/libpolys/polys/prCopy.cc @ 75e126

spielwiese
Last change on this file since 75e126 was f83dbf5, checked in by Hans Schoenemann <hannes@…>, 9 years ago
fix tr. #736
  • Property mode set to 100644
File size: 6.6 KB
Line 
1/****************************************
2*  Computer Algebra System SINGULAR     *
3****************************************/
4/*
5* ABSTRACT - implementation of functions for Copy/Move/Delete for Polys
6*/
7
8
9#include <misc/auxiliary.h>
10
11#include <omalloc/omalloc.h>
12#include <polys/monomials/ring.h>
13#include <polys/monomials/p_polys.h>
14#include <coeffs/numbers.h>
15#include <polys/monomials/ring.h>
16#include <polys/simpleideals.h>
17// #include <polys/sbuckets.h>
18
19static inline void
20prCopyEvector(poly dest, ring dest_r, poly src, ring src_r,int max)
21{
22  //memset(dest->exp,0,dest_r->ExpL_Size*sizeof(long));
23  int i;
24  for (i=max; i>0; i--)
25  {
26    p_SetExp(dest, i, p_GetExp( src, i,src_r), dest_r);
27  }
28  if (rRing_has_Comp(dest_r) && rRing_has_Comp(src_r))
29    p_SetComp(dest, p_GetComp( src,src_r), dest_r);
30  p_Setm(dest, dest_r);
31}
32
33#include <polys/prCopy.inc>
34
35/////////////////////////////////////////////////////////////////////////
36poly prCopyR(poly p, ring src_r, ring dest_r)
37{
38  poly res;
39  if (rField_has_simple_Alloc(dest_r))
40    res =  pr_Copy_NoREqual_NSimple_Sort(p, src_r, dest_r);
41  else
42    res =  pr_Copy_NoREqual_NoNSimple_Sort(p, src_r, dest_r);
43  p_Test(res, dest_r);
44  return res;
45}
46
47poly prMapR(poly src, nMapFunc nMap, ring src_r, ring dest_r)
48{
49  if (src==NULL) return NULL;
50  int _min = si_min(dest_r->N, src_r->N);
51
52  spolyrec dest_s;
53
54  poly dest = &dest_s;
55
56  poly prev;
57  while (src != NULL)
58  {
59    pNext(dest) = (poly) p_Init(dest_r);
60    prev = dest;
61    pIter(dest);
62
63    pSetCoeff0(dest, nMap(pGetCoeff(src),src_r->cf,dest_r->cf));
64    prCopyEvector(dest, dest_r, src, src_r, _min);
65    if (n_IsZero(pGetCoeff(dest),dest_r->cf))
66    {
67      p_LmDelete(&pNext(prev),dest_r);
68    }
69    pIter(src);
70  }
71  pNext(dest) = NULL;
72  dest = pNext(&dest_s);
73  dest=p_SortAdd(dest, dest_r);
74  p_Test(dest, dest_r);
75  return dest;
76}
77
78poly prCopyR_NoSort(poly p, ring src_r, ring dest_r)
79{
80  poly res;
81  if (rField_has_simple_Alloc(dest_r))
82    res =  pr_Copy_NoREqual_NSimple_NoSort(p, src_r, dest_r);
83  else
84    res =  pr_Copy_NoREqual_NoNSimple_NoSort(p, src_r, dest_r);
85  p_Test(res, dest_r);
86  return res;
87}
88
89/////////////////////////////////////////////////////////////////////////
90// prMove
91poly prMoveR(poly &p, ring src_r, ring dest_r)
92{
93  poly res;
94  if (rField_has_simple_Alloc(dest_r))
95    res =  pr_Move_NoREqual_NSimple_Sort(p, src_r, dest_r);
96  else
97    res =  pr_Move_NoREqual_NoNSimple_Sort(p, src_r, dest_r);
98  p_Test(res, dest_r);
99  return res;
100}
101
102poly prMoveR_NoSort(poly &p, ring src_r, ring dest_r)
103{
104  poly res;
105  if (rField_has_simple_Alloc(dest_r))
106    res =  pr_Move_NoREqual_NSimple_NoSort(p, src_r, dest_r);
107  else
108    res =  pr_Move_NoREqual_NoNSimple_NoSort(p, src_r, dest_r);
109  p_Test(res, dest_r);
110  return res;
111}
112
113poly prShallowCopyR_NoSort(poly p, ring r, ring dest_r)
114{
115  return pr_Copy_NoREqual_NSimple_NoSort(p, r, dest_r);
116}
117
118poly prShallowCopyR(poly p, ring r, ring dest_r)
119{
120  return pr_Copy_NoREqual_NSimple_Sort(p, r, dest_r);
121}
122
123/////////////////////////////////////////////////////////////////////////
124// prHead
125typedef poly (*prCopyProc_t)(poly &src_p, ring src_r, ring dest_r);
126
127poly prHeadR(poly p, ring src_r, ring dest_r, prCopyProc_t prproc)
128{
129  if (p == NULL) return NULL;
130  poly tail, head, q = p;
131  tail = pNext(p);
132  pNext(p) = NULL;
133  head = prproc(q, src_r, dest_r);
134  pNext(p) = tail;
135
136  p_Test(p, src_r);
137  p_Test(head, dest_r);
138
139  return head;
140}
141
142poly prHeadR(poly p, ring src_r, ring dest_r)
143{
144  prCopyProc_t prproc;
145  if (rField_has_simple_Alloc(dest_r))
146    prproc = pr_Copy_NoREqual_NSimple_NoSort;
147  else
148    prproc = pr_Copy_NoREqual_NoNSimple_NoSort;
149
150  const poly res = prHeadR(p, src_r, dest_r, prproc);
151  p_Test(res, dest_r);
152  return res;
153}
154
155/////////////////////////////////////////////////////////////////////////
156/// Copy leading terms of id[i] via prHeeadR into dest_r
157ideal idrHeadR(ideal id, ring r, ring dest_r)
158{
159  if (id == NULL) return NULL;
160
161  prCopyProc_t prproc = pr_Copy_NoREqual_NoNSimple_NoSort;
162  if (rField_has_simple_Alloc(dest_r))
163    prproc = pr_Copy_NoREqual_NSimple_NoSort;
164
165  const int N = IDELEMS(id);
166  ideal res = idInit(N, id->rank);
167
168  for (int i = N - 1; i >= 0; i--)
169    res->m[i] = prHeadR(id->m[i], r, dest_r, prproc); // !!!
170
171  return res;
172}
173
174
175static inline ideal
176idrCopy(ideal id, ring src_r, ring dest_r, prCopyProc_t prproc)
177{
178  if (id == NULL) return NULL;
179  assume(src_r->cf==dest_r->cf);
180  poly p;
181  ideal res = idInit(IDELEMS(id), id->rank);
182  int i;
183
184  for (i=IDELEMS(id)-1; i>=0; i--)
185  {
186    p = id->m[i];
187    res->m[i] = prproc(p, src_r, dest_r);
188    p_Test(res->m[i], dest_r);
189  }
190  return res;
191}
192
193ideal idrCopyR(ideal id, ring src_r, ring dest_r)
194{
195  assume(src_r->cf==dest_r->cf);
196  ideal res;
197  prCopyProc_t prproc;
198  if (rField_has_simple_Alloc(dest_r))
199    prproc = pr_Copy_NoREqual_NSimple_Sort;
200  else
201    prproc = pr_Copy_NoREqual_NoNSimple_Sort;
202  res =  idrCopy(id, src_r, dest_r, prproc);
203  return res;
204}
205
206ideal idrCopyR_NoSort(ideal id, ring src_r, ring dest_r)
207{
208  assume(src_r->cf==dest_r->cf);
209  ideal res;
210  prCopyProc_t prproc;
211  if (rField_has_simple_Alloc(dest_r))
212    prproc = pr_Copy_NoREqual_NSimple_NoSort;
213  else
214    prproc = pr_Copy_NoREqual_NoNSimple_NoSort;
215  res =  idrCopy(id, src_r, dest_r, prproc);
216  return res;
217}
218
219/////////////////////////////////////////////////////////////////////////
220// idrShallowCopy
221ideal idrShallowCopyR(ideal id, ring src_r, ring dest_r)
222{
223  return idrCopy(id, src_r, dest_r, pr_Copy_NoREqual_NSimple_Sort);
224}
225
226ideal idrShallowCopyR_NoSort(ideal id, ring src_r, ring dest_r)
227{
228  return idrCopy(id, src_r, dest_r, pr_Copy_NoREqual_NSimple_NoSort);
229}
230
231/////////////////////////////////////////////////////////////////////////
232// idrMove
233static inline ideal
234idrMove(ideal &id, ring src_r, ring dest_r, prCopyProc_t prproc)
235{
236  assume(src_r->cf==dest_r->cf);
237  assume( prproc != NULL );
238
239  if (id == NULL) return NULL;
240
241  ideal res = id; id = NULL;
242
243  for (int i = IDELEMS(res) - 1; i >= 0; i--)
244    res->m[i] = prproc(res->m[i], src_r, dest_r);
245
246  return res;
247}
248
249ideal idrMoveR(ideal &id, ring src_r, ring dest_r)
250{
251  assume(src_r->cf==dest_r->cf);
252  prCopyProc_t prproc;
253  ideal res;
254  if (rField_has_simple_Alloc(dest_r))
255    prproc = pr_Move_NoREqual_NSimple_Sort;
256  else
257    prproc = pr_Move_NoREqual_NoNSimple_Sort;
258  res =  idrMove(id, src_r, dest_r, prproc);
259  return res;
260}
261
262ideal idrMoveR_NoSort(ideal &id, ring src_r, ring dest_r)
263{
264  assume(src_r->cf==dest_r->cf);
265  prCopyProc_t prproc;
266  ideal res;
267  if (rField_has_simple_Alloc(dest_r))
268    prproc = pr_Move_NoREqual_NSimple_NoSort;
269  else
270    prproc = pr_Move_NoREqual_NoNSimple_NoSort;
271  res =  idrMove(id, src_r, dest_r, prproc);
272  return res;
273}
274
275
Note: See TracBrowser for help on using the repository browser.