Changeset 9a3a7f in git


Ignore:
Timestamp:
Jan 19, 2002, 2:06:03 PM (22 years ago)
Author:
Olaf Bachmann <obachman@…>
Branches:
(u'spielwiese', 'a719bcf0b8dbc648b128303a49777a094b57592c')
Children:
324dc0f86c4a2ce32bd7c2c408cb2e8db043c2c3
Parents:
4f4eb5c00670f6ea7f8545bf784c9187045b4f97
Message:
independent of currRing


git-svn-id: file:///usr/local/Singular/svn/trunk@5737 2c84dea3-7e68-4137-9b89-c4e89433aadc
Location:
Singular
Files:
2 edited

Legend:

Unmodified
Added
Removed

  • Singular/prCopy.cc

    r4f4eb5 r9a3a7f  
    22*  Computer Algebra System SINGULAR     *
    33****************************************/
    4 /* $Id: prCopy.cc,v 1.12 2001-10-09 16:36:19 Singular Exp $ */
     4/* $Id: prCopy.cc,v 1.13 2002-01-19 13:06:03 obachman Exp $ */
    55/*
    66* ABSTRACT - implementation of functions for Copy/Move/Delete for Polys
    … …  
    99#include "mod2.h"
    1010#include "omalloc.h"
    11 #include "polys.h"
     11#include "p_polys.h"
    1212#include "numbers.h"
    1313#include "tok.h"
    … …  
    1919prCopyEvector(poly dest, ring dest_r, poly src, ring src_r,int max)
    2020{
    21   assume((dest_r == currRing)||(dest_r== currRing->algring));
    2221  number n = pGetCoeff(dest);
    2322  int i;
    … …  
    3837/////////////////////////////////////////////////////////////////////////
    3938// prCopy
    40 poly prCopy(poly p)
    41 {
    42   poly res;
    43 
    44   if (rField_has_simple_Alloc(currRing))
    45     res = pr_Copy_REqual_NSimple_NoSort(p, currRing, currRing);
    46   else
    47     res = pr_Copy_REqual_NoNSimple_NoSort(p, currRing, currRing);
    48   pTest(res);
    49   return res;
    50 }
    51 
    52 poly prCopyR(poly p, ring src_r)
    53 {
    54   poly res;
    55   if (rField_has_simple_Alloc(currRing))
    56     res =  pr_Copy_NoREqual_NSimple_Sort(p, src_r, currRing);
    57   else
    58     res =  pr_Copy_NoREqual_NoNSimple_Sort(p, src_r, currRing);
    59   pTest(res);
    60   return res;
    61 }
    62 
    63 poly prCopyR_NoSort(poly p, ring src_r)
    64 {
    65   poly res;
    66   if (rField_has_simple_Alloc(currRing))
    67     res =  pr_Copy_NoREqual_NSimple_NoSort(p, src_r, currRing);
    68   else
    69     res =  pr_Copy_NoREqual_NoNSimple_NoSort(p, src_r, currRing);
    70   pTest(res);
     39poly prCopy(poly p, ring dest_r)
     40{
     41  poly res;
     42  if (rField_has_simple_Alloc(dest_r))
     43    res = pr_Copy_REqual_NSimple_NoSort(p, dest_r, dest_r);
     44  else
     45    res = pr_Copy_REqual_NoNSimple_NoSort(p, dest_r, dest_r);
     46  p_Test(res, dest_r);
     47  return res;
     48}
     49
     50poly prCopyR(poly p, ring src_r, ring dest_r)
     51{
     52  poly res;
     53  if (rField_has_simple_Alloc(dest_r))
     54    res =  pr_Copy_NoREqual_NSimple_Sort(p, src_r, dest_r);
     55  else
     56    res =  pr_Copy_NoREqual_NoNSimple_Sort(p, src_r, dest_r);
     57  p_Test(res, dest_r);
     58  return res;
     59}
     60
     61poly prCopyR_NoSort(poly p, ring src_r, ring dest_r)
     62{
     63  poly res;
     64  if (rField_has_simple_Alloc(dest_r))
     65    res =  pr_Copy_NoREqual_NSimple_NoSort(p, src_r, dest_r);
     66  else
     67    res =  pr_Copy_NoREqual_NoNSimple_NoSort(p, src_r, dest_r);
     68  p_Test(res, dest_r);
    7169  return res;
    7270}
    … …  
    7472/////////////////////////////////////////////////////////////////////////
    7573// prMove
    76 poly prMoveR(poly &p, ring src_r)
    77 {
    78   poly res;
    79   if (rField_has_simple_Alloc(currRing))
    80     res =  pr_Move_NoREqual_NSimple_Sort(p, src_r, currRing);
    81   else
    82     res =  pr_Move_NoREqual_NoNSimple_Sort(p, src_r, currRing);
    83   pTest(res);
    84   return res;
    85 }
    86 
    87 poly prMoveR_NoSort(poly &p, ring src_r)
    88 {
    89   poly res;
    90   if (rField_has_simple_Alloc(currRing))
    91     res =  pr_Move_NoREqual_NSimple_NoSort(p, src_r, currRing);
    92   else
    93     res =  pr_Move_NoREqual_NoNSimple_NoSort(p, src_r, currRing);
    94   pTest(res);
    95   return res;
     74poly prMoveR(poly &p, ring src_r, ring dest_r)
     75{
     76  poly res;
     77  if (rField_has_simple_Alloc(dest_r))
     78    res =  pr_Move_NoREqual_NSimple_Sort(p, src_r, dest_r);
     79  else
     80    res =  pr_Move_NoREqual_NoNSimple_Sort(p, src_r, dest_r);
     81  p_Test(res, dest_r);
     82  return res;
     83}
     84
     85poly prMoveR_NoSort(poly &p, ring src_r, ring dest_r)
     86{
     87  poly res;
     88  if (rField_has_simple_Alloc(dest_r))
     89    res =  pr_Move_NoREqual_NSimple_NoSort(p, src_r, dest_r);
     90  else
     91    res =  pr_Move_NoREqual_NoNSimple_NoSort(p, src_r, dest_r);
     92  p_Test(res, dest_r); 
     93  return res;
     94}
     95
     96poly prShallowCopyR_NoSort(poly p, ring r, ring dest_r)
     97{
     98  return pr_Copy_NoREqual_NSimple_NoSort(p, r, dest_r);
     99}
     100
     101poly prShallowCopyR(poly p, ring r, ring dest_r = currRing)
     102{
     103  return pr_Copy_NoREqual_NSimple_Sort(p, r, dest_r);
    96104}
    97105
    … …  
    100108typedef poly (*prCopyProc_t)(poly &src_p, ring src_r, ring dest_r);
    101109
    102 poly prHeadR(poly p, ring src_r, prCopyProc_t prproc)
     110poly prHeadR(poly p, ring src_r, ring dest_r, prCopyProc_t prproc)
    103111{
    104112  if (p == NULL) return NULL;
    … …  
    106114  tail = pNext(p);
    107115  pNext(p) = NULL;
    108   head = prproc(q, src_r, currRing);
     116  head = prproc(q, src_r, dest_r);
    109117  pNext(p) = tail;
    110118  return head;
    111119}
    112120
    113 poly prHeadR(poly p, ring src_r)
    114 {
    115   prCopyProc_t prproc;
    116   if (rField_has_simple_Alloc(currRing))
     121poly prHeadR(poly p, ring src_r, ring dest_r)
     122{
     123  prCopyProc_t prproc;
     124  if (rField_has_simple_Alloc(dest_r))
    117125    prproc = pr_Copy_NoREqual_NSimple_NoSort;
    118126  else
    119     prproc = pr_Copy_NoREqual_NoNSimple_NoSort;
    120 
    121   return prHeadR(p, src_r, prproc);
     127    prproc = pr_Copy_NoREqual_NoNSimple_NoSort; 
     128 
     129  return prHeadR(p, src_r, dest_r, prproc);
    122130}
    123131
    … …  
    136144    p = id->m[i];
    137145    res->m[i] = prproc(p, src_r, dest_r);
    138     pTest(res->m[i]);
     146    p_Test(res->m[i], dest_r);
    139147  }
    140148  return res;
    141149}
    142150
    143 ideal idrCopy(ideal id)
    144 {
    145   ideal res;
    146   prCopyProc_t prproc;
    147   if (rField_has_simple_Alloc(currRing))
     151ideal idrCopy(ideal id, ring dest_r)
     152{
     153  ideal res;
     154  prCopyProc_t prproc;
     155  if (rField_has_simple_Alloc(dest_r))
    148156    prproc = pr_Copy_REqual_NSimple_NoSort;
    149157  else
    150158    prproc = pr_Copy_REqual_NoNSimple_NoSort;
    151   res =  idrCopy(id, currRing, currRing, prproc);
    152   return res;
    153 }
    154 
    155 ideal idrCopyR(ideal id, ring src_r)
    156 {
    157   ideal res;
    158   prCopyProc_t prproc;
    159   if (rField_has_simple_Alloc(currRing))
     159  res =  idrCopy(id, dest_r, dest_r, prproc);
     160  return res;
     161}
     162
     163ideal idrCopyR(ideal id, ring src_r, ring dest_r)
     164{
     165  ideal res;
     166  prCopyProc_t prproc;
     167  if (rField_has_simple_Alloc(dest_r))
    160168    prproc = pr_Copy_NoREqual_NSimple_Sort;
    161169  else
    162170    prproc = pr_Copy_NoREqual_NoNSimple_Sort;
    163   res =  idrCopy(id, src_r, currRing, prproc);
    164   return res;
    165 }
    166 
    167 ideal idrCopyR_NoSort(ideal id, ring src_r)
    168 {
    169   ideal res;
    170   prCopyProc_t prproc;
    171   if (rField_has_simple_Alloc(currRing))
     171  res =  idrCopy(id, src_r, dest_r, prproc);
     172  return res;
     173}
     174 
     175ideal idrCopyR_NoSort(ideal id, ring src_r, ring dest_r)
     176{
     177  ideal res;
     178  prCopyProc_t prproc;
     179  if (rField_has_simple_Alloc(dest_r))
    172180    prproc = pr_Copy_NoREqual_NSimple_NoSort;
    173181  else
    174182    prproc = pr_Copy_NoREqual_NoNSimple_NoSort;
    175   res =  idrCopy(id, src_r, currRing, prproc);
    176   return res;
    177 }
    178 
     183  res =  idrCopy(id, src_r, dest_r, prproc);
     184  return res;
     185}
     186
     187/////////////////////////////////////////////////////////////////////////
     188// idrShallowCopy
     189ideal idrShallowCopyR(ideal id, ring src_r, ring dest_r)
     190{
     191  return idrCopy(id, src_r, dest_r, pr_Copy_NoREqual_NSimple_Sort);
     192}
     193 
     194ideal idrShallowCopyR_NoSort(ideal id, ring src_r, ring dest_r)
     195{
     196  return idrCopy(id, src_r, dest_r, pr_Copy_NoREqual_NSimple_NoSort);
     197}
     198 
    179199/////////////////////////////////////////////////////////////////////////
    180200// idrMove
    … …  
    192212}
    193213
    194 ideal idrMoveR(ideal &id, ring src_r)
    195 {
    196   prCopyProc_t prproc;
    197   ideal res;
    198 
    199   if (rField_has_simple_Alloc(currRing))
     214ideal idrMoveR(ideal &id, ring src_r, ring dest_r)
     215{
     216  prCopyProc_t prproc;
     217  ideal res;
     218  if (rField_has_simple_Alloc(dest_r))
    200219    prproc = pr_Move_NoREqual_NSimple_Sort;
    201220  else
    202221    prproc = pr_Move_NoREqual_NoNSimple_Sort;
    203   res =  idrMove(id, src_r, currRing, prproc);
    204   return res;
    205 }
    206 
    207 ideal idrMoveR_NoSort(ideal &id, ring src_r)
    208 {
    209   prCopyProc_t prproc;
    210   ideal res;
    211 
    212   if (rField_has_simple_Alloc(currRing))
     222  res =  idrMove(id, src_r, dest_r, prproc);
     223  return res;
     224}
     225 
     226ideal idrMoveR_NoSort(ideal &id, ring src_r, ring dest_r)
     227{
     228  prCopyProc_t prproc;
     229  ideal res;
     230  if (rField_has_simple_Alloc(dest_r))
    213231    prproc = pr_Move_NoREqual_NSimple_NoSort;
    214232  else
    215233    prproc = pr_Move_NoREqual_NoNSimple_NoSort;
    216   res =  idrMove(id, src_r, currRing, prproc);
    217   return res;
    218 }
    219 
     234  res =  idrMove(id, src_r, dest_r, prproc);
     235  return res;
     236}
     237

  • Singular/prCopy.h

    r4f4eb5 r9a3a7f  
    22*  Computer Algebra System SINGULAR     *
    33****************************************/
    4 /* $Id: prCopy.h,v 1.2 2000-12-31 15:14:43 obachman Exp $ */
     4/* $Id: prCopy.h,v 1.3 2002-01-19 13:06:03 obachman Exp $ */
    55/*
    66* ABSTRACT - declarations of functions for Copy/Move/Delete for Polys
    … …  
    1010/*************************************************************************
    1111 *
    12  * MoveR, CopyR, DeleteR, HeadR, SortR
    13  * Assume: ideal/poly from ring r
    14  *         Coeff(r) == Coeff(currRing)
    15  * Move, Delete: input object is destroyed and set to NULL
    16  *
     12 * MoveR, CopyR, ShallowCopyR: operations to get ideals/polys
     13 *                             from source_r to dest_r where
     14 *  - Coeff(source_r) == Coeff(dest_r)
     15 *  - dest_r->N <= source_r->N
     16 * Move:        input is destroyed
     17 * ShallowCopy: monomials are copied, coeffs are set
     18 * Copy:        monomials and coeffs are copied
    1719 *
    1820 ************************************************************************/
    19 poly prMoveR_NoSort(poly &p, ring r);
    20 poly prMoveR(poly &p, ring r);
    21 poly prCopyR_NoSort(poly p, ring r);
    22 poly prCopyR(poly p, ring r);
    23 poly prHeadR(poly p, ring r);
     21poly prMoveR_NoSort(poly &p, ring r, ring dest_r = currRing);
     22poly prMoveR(poly &p, ring r, ring dest_r = currRing);
     23poly prCopyR_NoSort(poly p, ring r, ring dest_r = currRing);
     24poly prCopyR(poly p, ring r, ring dest_r = currRing);
     25poly prShallowCopyR_NoSort(poly p, ring r, ring dest_t = currRing);
     26poly prShallowCopyR(poly p, ring r, ring dest_t = currRing);
     27poly prHeadR(poly p, ring r, ring dest_r = currRing);
    2428
    25 ideal idrMoveR_NoSort(ideal &id, ring r);
    26 ideal idrMoveR(ideal &id, ring r);
    27 ideal idrCopyR_NoSort(ideal id, ring r);
    28 ideal idrCopyR(ideal id, ring r);
    29 ideal idrHeadR(ideal id, ring r);
     29ideal idrMoveR_NoSort(ideal &id, ring r, ring dest_r = currRing);
     30ideal idrMoveR(ideal &id, ring r, ring dest_r = currRing);
     31ideal idrCopyR_NoSort(ideal id, ring r, ring dest_r = currRing);
     32ideal idrCopyR(ideal id, ring r, ring dest_r = currRing);
     33ideal idrShallowCopyR_NoSort(ideal id, ring r, ring dest_r = currRing);
     34ideal idrShallowCopyR(ideal id, ring r, ring dest_r = currRing);
     35ideal idrHeadR(ideal id, ring r, ring dest_r = currRing);
    3036
    3137
Note: See TracChangeset for help on using the changeset viewer.