source: git/libpolys/polys/prCopy.cc @ f7286a

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