Ticket #2329: 2329-ccitro-pari-indexing-fixes-1.patch

File 2329-ccitro-pari-indexing-fixes-1.patch, 5.3 KB (added by ncalexan, 14 years ago)
  • sage/libs/pari/gen.pxd

    # HG changeset patch
    # User Nick Alexander <ncalexander@gmail.com>
    # Date 1208240134 25200
    # Node ID 496856ad9935fce180613d297d83d2dbe70148ff
    # Parent  062d04999bed5786356053b68004d1756aaae11e
    imported patch 2329-pari-indexing-fixes
    
    diff -r 062d04999bed -r 496856ad9935 sage/libs/pari/gen.pxd
    a b cdef class gen(sage.structure.element.Ri 
    1212    cdef gen new_gen_noclear(self, GEN x)
    1313    cdef gen pari(self, object x)
    1414    cdef GEN _deepcopy_to_python_heap(self, GEN x, pari_sp* address)
    15     cdef int get_var(self, v)   
     15    cdef int get_var(self, v)
     16    cpdef gen getattr(self, attr)
    1617
    1718cimport sage.structure.parent_base
    1819
  • sage/libs/pari/gen.pyx

    diff -r 062d04999bed -r 496856ad9935 sage/libs/pari/gen.pyx
    a b cdef class gen(sage.structure.element.Ri 
    330330    ###########################################
    331331    # ACCESS
    332332    ###########################################
    333     #def __getattr__(self, attr):
    334     def getattr(self, attr):
     333   
     334    cpdef gen getattr(self, attr):
     335        """
     336        Return attribute attr of self. This is equivalent to
     337        self.attr in Pari.
     338
     339        EXAMPLES:
     340            sage: K.<t> = NumberField(x**3-2) ; K_pari = K.pari_nf()
     341            sage: K_pari.getattr('zk')
     342            [1, x, x^2]
     343            sage: pari('K = nfinit(x^3-2); K.zk')
     344            [1, x, x^2]
     345            sage: Integers(7)(3)._pari_()
     346            Mod(3, 7)
     347            sage: Integers(7)(3)._pari_().getattr('mod')
     348            7
     349        """
    335350        t0GEN(str(self) + '.' + str(attr))
    336351        return self.new_gen(t0)
    337352
    338     def __getitem__(gen self, n):
     353    def __getitem__(self, n):
    339354        """
    340355        Return the nth entry of self. The indexing is 0-based, like
    341356        in Python. Note that this is *different* than the default
    cdef class gen(sage.structure.element.Ri 
    402417            TypeError: unindexable object
    403418            sage: m = pari("[[1,2;3,4],5]") ; m[0][1,0]
    404419            3
     420            sage: m = pari("Mod(238,92387)") ; m[0]
     421            238
     422            sage: m[1]
     423            92387
     424            sage: pari("Mod(x,x^2-3)")[1].type()
     425            't_POL'
     426            sage: pari("Mod(1,x^2-3)")[0].type()
     427            't_INT'
    405428        """
    406429        cdef int pari_type
    407430
    cdef class gen(sage.structure.element.Ri 
    452475        elif n < 0 or n >= glength(self.g):
    453476            raise IndexError, "index out of bounds"
    454477       
    455         elif typ(self.g) == t_VEC or typ(self.g) == t_MAT:
     478        elif pari_type == t_VEC or pari_type == t_MAT:
    456479            if PyDict_Contains(self._refers_to, n):
    457480                return self._refers_to[n]
    458481            else:
    cdef class gen(sage.structure.element.Ri 
    464487                self._refers_to[n] = val
    465488                return val
    466489
    467         elif typ(self.g) == t_VECSMALL:
     490        elif pari_type == t_VECSMALL:
    468491            return self.g[n+1]
    469492
    470         elif typ(self.g) == t_STR:
     493        elif pari_type == t_STR:
    471494            return chr( (<char *>(self.g+1))[n] )
    472495       
    473         elif typ(self.g) == t_LIST:
     496        elif pari_type == t_LIST:
    474497            return P.new_ref(gel(self.g,n+2), self)
    475498
    476499        elif pari_type in (t_INTMOD, t_POLMOD):
    477             # if we keep going we would get:
    478             #   [0] = modulus
    479             #   [1] = lift to t_INT or t_POL
    480             # do we want this? maybe the other way around?
    481             raise TypeError, "unindexable object"
    482 
    483         #elif typ(self.g) in (t_FRAC, t_RFRAC):
     500            ## we return components based on the
     501            ## order elements are printed, so
     502            ##    Mod(3,7)[0]  is 3,
     503            ##    Mod(3,7)[1]  is 7.
     504            if n == 0:
     505                return P.new_ref(gel(self.g, 2), self)
     506            elif n == 1:
     507                return P.new_ref(gel(self.g, 1), self)
     508            else:
     509                raise IndexError, "index out of bounds"
     510           
     511
     512        #elif pari_type in (t_FRAC, t_RFRAC):
    484513            # generic code gives us:
    485514            #   [0] = numerator
    486515            #   [1] = denominator
    487516
    488         #elif typ(self.g) == t_COMPLEX:
     517        #elif pari_type == t_COMPLEX:
    489518            # generic code gives us
    490519            #   [0] = real part
    491520            #   [1] = imag part
    492521
    493         #elif type(self.g) in (t_QFR, t_QFI):
     522        #elif pari_type in (t_QFR, t_QFI):
    494523            # generic code works ok
    495524
    496525        else:
    cdef class gen(sage.structure.element.Ri 
    47614790        _sig_on
    47624791        return self.new_gen(bnfisintnorm(self.g, t0))
    47634792
     4793    def bnfisnorm(self, gen x, long flag=0):
     4794        t0GEN(x)
     4795        _sig_on
     4796        return self.new_gen(bnfisnorm(t0, self.g, flag, prec))
     4797
    47644798    def bnfisprincipal(self, x, long flag=1):
    47654799        t0GEN(x)
    47664800        _sig_on
    cdef class gen(sage.structure.element.Ri 
    50745108        _sig_on
    50755109        return rnfisfree(self.g, t0)
    50765110
    5077 
     5111    def rnfisnorminit(self, polrel, flag=2):
     5112        _sig_on
     5113        return self.new_gen(rnfisnorminit(self.g, (<gen>polrel).g, flag))
     5114
     5115    def rnfisnorm(self, T, flag=0):
     5116        _sig_on
     5117        return self.new_gen(rnfisnorm((<gen>T).g, self.g, flag))
    50785118   
    50795119
    50805120