Changeset 3667:4de1aa0af3cb


Ignore:
Timestamp:
03/13/07 00:36:43 (6 years ago)
Author:
David Roe <roed@…>
Branch:
default
Message:

Massive changes to the extension inheritance structures, some bug fixes.

Location:
sage
Files:
39 added
6 deleted
25 edited

Legend:

Unmodified
Added
Removed

  • sage/rings/padics/README/README.tex

    r3409 r3667  
    114114There are four different representations of $\Zp$ in Sage and two representations of $\Qp$: 
    115115the fixed modulus ring, the capped absolute precision ring, the capped relative precision 
    116 ring, the capped relative precision field, the lazy ring and the lazy field. 
     116ring, the capped relative precision field, the lazy ring and the lazy field.  In addition, 
     117unramified extensions are also currently supported. 
     118 
     119One uses the function \verb/Zp/ to construct $p$-adic rings and \verb/Qp/ to construct $p$-adic 
     120fields.  The only required parameter is the prime: the default type is capped relative. 
    117121 
    118122\subsection{Fixed Modulus Rings} 
    … …  
    278282 
    279283There are two parameters that are set at the creation of a lazy ring or field.  The first is \verb/prec/, which 
    280 controls the precision to which elements are initially computed.  When computing with lazy rings, sometimes situations 
     284controls the precision to which elements are initially computed.  The second is \verb/halt/: when computing with lazy rings, sometimes situations 
    281285arise where the insolvability of the halting problem gives us problems.  For example, 
    282286\begin{verbatim} 
    … …  
    287291sage: b.valuation() 
    288292... 
    289 <class 'sage.rings.padics.precision_error.HaltingError'>: Stopped computing sum: set halting paramter higher if you want computation to continue 
    290  
    291 The second is \verb/halt/ 
    292  
    293 \begin{verbatim} 
    294  
    295  
     293<class 'sage.rings.padics.precision_error.HaltingError'>: 
     294 Stopped computing sum: set halting paramter higher if you want computation to continue 
     295\end{verbatim} 
     296 
     297Setting the halting parameter controls to what absolute precision one computes in such a situation. 
     298 
     299The interesting feature of lazy elements is that one can perform computations with them, discover that the answer does not have the desired precision, and then ask for more precision.  For example, 
     300\begin{verbatim} 
     301sage: a = R(6).log() * 15 
     302sage: b = a.exp() 
     303sage: c = b / R(15).exp() 
     304sage: c 
     3051 + 2*5 + 4*5^2 + 3*5^3 + 2*5^4 + 3*5^5 + 5^6 + 5^10 + O(5^11) 
     306sage: c.set_precision_absolute(15) 
     307sage: c 
     3081 + 2*5 + 4*5^2 + 3*5^3 + 2*5^4 + 3*5^5 + 5^6 + 5^10 +  
     309               4*5^11 + 2*5^12 + 4*5^13 + 3*5^14 + O(5^15) 
     310\end{verbatim} 
     311 
     312There can be a performance penalty to using lazy $p$-adics in this way.  When one does computations with them, the computer construct an expression tree.  As you compute, values of these elements are cached, and the overhead is reasonably low (though obviously higher than for a fixed modulus element for example).  But when you set the precision, the computer has to reset precision throughout the expression tree for that element, and thus setting precision can take the same order of magnitude of time as doing the initial computation.  However, lazy $p$-adics can be quite useful when experimenting. 
     313 
     314\subsection{Unramified Extensions} 
     315One can create unramified extensions of $\Zp$ and $\Qp$ using the functions \verb/Zq/ and \verb/Qq/. 
     316These extensions are still in a relatively primitive state, 
     317so I would suggest the following options when creating such extensions (more are available but may 
     318not currently work as well). 
     319 
     320In addition to requiring a prime power as the first argument, \verb/Zq/ also requires a name for the generator of the residue field.  One can specify this name as follows: 
     321\begin{verbatim} 
     322sage: R.<c> = Zq(125, prec = 20) 
     323sage: R  
     324Unramified Extension of 5-adic Ring with capped absolute precision 20 in x 
     325 defined by (1 + O(5^20))*c^3 + O(5^20)*c^2 + (3 + O(5^20))*c + 3 + O(5^20) 
     326\end{verbatim} 
     327 
     328\section{New Versions of the $p$-adics} 
     329The code for $p$-adics is fairly rapidly changing.  If there's a bug you want fixed, let me know and I'll try to fix it.  Once I do, you'll need to get the latest version of $p$-adics with the bug fixed.  If you don't want to wait for the next version of SAGE to come out, you can do the following to get the most recent version: 
     330\begin{verbatim} 
     331sage: hg_sage.pull() 
     332sage: hg_sage.apply( 
     333 'http://sage.math.washington.edu/home/padicgroup/development-version.hg') 
     334sage: quit 
     335localhost:~$ sage 
     336sage: run code that generated bug. 
     337\end{verbatim} 
     338 
     339If you want a slightly more stable but older version, use \verb/semistable-version.hg/ instead. 
    296340\end{document} 

  • sage/rings/padics/local_generic.py

    r3326 r3667  
    1717 
    1818class LocalGeneric(sage.rings.ring.CommutativeRing): 
    19     def __init__(self, prec): 
     19    def __init__(self, prec, names): 
    2020        self._prec = prec 
    21         sage.structure.parent_gens.ParentWithGens.__init__(self, self, ('x',), normalize=False) 
     21        sage.structure.parent_gens.ParentWithGens.__init__(self, self, (names,), normalize=False) 
    2222 
    2323    def __call__(self, x): 
    … …  
    6161        return self._prec 
    6262 
    63     def get_print_mode(self): 
     63    def print_mode(self): 
    6464        raise NotImplementedError 
    6565 

  • sage/rings/padics/padic_field_capped_relative.py

    r3405 r3667  
    102102Rational = sage.rings.rational.Rational 
    103103Mod = sage.rings.integer_mod.Mod 
     104infinity = sage.rings.infinity.infinity 
    104105pAdicFieldBaseGeneric = sage.rings.padics.padic_field_generic.pAdicFieldBaseGeneric 
    105106pAdicLazyElement = sage.rings.padics.padic_lazy_element.pAdicLazyElement 
    … …  
    113114    """ 
    114115 
    115     def __call__(self, x, absprec = None, relprec = None): 
     116    def __call__(self, x, absprec = infinity, relprec = infinity): 
    116117        r""" 
    117118            Casts x into self.  Uses the constructor from pAdicFieldCappedRelativeElement. 
    … …  
    193194        """ 
    194195        from sage.rings.padics.zp import Zp 
    195         return Zp(self.prime(), self.precision_cap(), 'capped-rel', self.get_print_mode()) 
     196        return Zp(self.prime(), self.precision_cap(), 'capped-rel', self.print_mode()) 
    196197 
    197198    def fraction_field(self): 

  • sage/rings/padics/padic_field_capped_relative_element.py

    r3408 r3667  
    4747 
    4848class pAdicFieldCappedRelativeElement(sage.rings.padics.padic_field_generic_element.pAdicFieldGenericElement): 
    49     def __init__(self, parent, x, absprec=None, relprec=None, construct=False): 
     49    def __init__(self, parent, x, absprec=infinity, relprec=infinity, construct=False): 
    5050        sage.rings.commutative_ring_element.CommutativeRingElement.__init__(self, parent) 
    5151        if construct: 
    … …  
    5353            return 
    5454 
    55         if not absprec is None and not relprec is None: 
     55        if not absprec is infinity and not relprec is infinity: 
    5656            raise ValueError, "can only specify one of absprec and relprec" 
    57         if absprec is None: 
    58             if relprec is None or relprec > parent.precision_cap(): 
     57        if absprec is infinity: 
     58            if relprec > parent.precision_cap(): 
    5959                relprec = parent.precision_cap() 
    6060 
    6161        if isinstance(x, pAdicLazyElement): 
    62             if relprec is None: 
     62            if relprec is infinity: 
    6363                try: 
    6464                    x.set_precision_absolute(absprec) 
    … …  
    8080                raise ValueError, "Cannot coerce between p-adic rings with different primes." 
    8181            self._ordp = x.valuation() 
    82             if relprec is None: 
     82            if relprec is infinity: 
    8383                if self._ordp is infinity: 
    84                     relprec = 0 
     84                    relprec = Integer(0) 
    8585                else: 
    8686                    relprec = absprec - self._ordp 
    … …  
    9191        if isinstance(x, pari_gen): 
    9292            if x.type() == "t_PADIC": 
    93                 if not absprec is None: 
    94                     absprec = min(x.padicprec(parent.prime()), absprec) 
    95                 else: 
    96                     absprec = x.padicprec(parent.prime()) 
     93                absprec = min(x.padicprec(parent.prime()), absprec) 
    9794                x = x.lift() 
    9895            if x.type() == "t_INT": 
    … …  
    115112                raise TypeError, "cannot change primes in creating p-adic elements" 
    116113            x = x.lift() 
    117             if absprec is None: 
    118                 absprec = k 
    119             else: 
    120                 absprec = min(k, absprec) 
     114            absprec = min(k, absprec) 
    121115 
    122116            # We now use the code, below, so don't make the next line elif 
    … …  
    127121        else: 
    128122            raise TypeError, "cannot create a p-adic out of %s"%(type(x)) 
    129         if self._ordp == infinity: 
     123        if self._ordp is infinity: 
    130124            self._unit = Mod(0, 1) 
    131             self._relprec = 0 
     125            self._relprec = Integer(0) 
    132126            return 
    133127        x = x / self.parent().prime_pow(self._ordp) 
    134         if relprec is None: 
    135             if self._ordp is infinity: 
    136                 self._relprec = 0 
    137             else: 
    138                 self._relprec = min(absprec - self._ordp, parent.precision_cap()) 
    139         elif absprec is None: 
    140             self._relprec = relprec 
     128        if self._ordp is infinity: 
     129            self._relprec = Integer(0) 
    141130        else: 
    142131            self._relprec = min(relprec, absprec - self._ordp, parent.precision_cap()) 
    143132        self._unit = Mod(x, self.parent().prime_pow(self._relprec)) 
    144133        return                               
    145  
    146     def _repr_(self, mode = None, do_latex = False): 
    147         return sage.rings.padics.padic_generic_element.pAdicGenericElement._repr_(self, mode, do_latex, True) 
    148134 
    149135    def __invert__(self, prec=infinity): 
    … …  
    269255        return pAdicFieldCappedRelativeElement(self.parent(), (self.valuation(), self._unit, self._relprec), construct = True) 
    270256 
     257    def _is_exact_zero(self): 
     258        return self.valuation() is infinity 
     259 
    271260    def is_zero(self, prec): 
    272261        r""" 
    … …  
    363352         
    364353        """ 
    365         return self.list()[:(n - self.valuation())] + [0 for w in range(self.precision_relative(), (n - self.valuation()))] 
     354        if absprec is infinity and relprec is infinity: 
     355            raise ValueError, "must specify at least one of absprec and relprec" 
     356        if self.valuation() is infinity: 
     357            if relprec < infinity: 
     358                return [self.parent().residue_class_field()(0)]*relprec 
     359            else: 
     360                return [] 
     361        relprec = min(relprec, absprec - self.valuation()) 
     362        return self.list()[:relprec] + [self.parent().residue_class_field()(0)]*(self.precision_relative() - relprec) 
    366363 
    367364    def precision_absolute(self): 

  • sage/rings/padics/padic_field_generic.py

    r3350 r3667  
    113113 
    114114class pAdicFieldGeneric(sage.rings.padics.padic_generic.pAdicGeneric): 
    115  
    116     def __init__(self, p, prec, print_mode): 
    117         sage.rings.padics.padic_generic.pAdicGeneric.__init__(self, p, prec) 
    118         self.set_print_mode(print_mode) 
    119  
    120115    def _repr_(self, do_latex = False): 
    121116        return "Generic %s-adic Field"%(self.prime()) 
    122  
    123     def get_print_mode(self): 
    124         r""" 
    125         Returns the current print mode as a string. 
    126          
    127         INPUT: 
    128             self -- a p-adic field 
    129  
    130         OUTPUT: 
    131             string -- self's print mode 
    132          
    133         EXAMPLES: 
    134             sage: R = Qp(7,5, 'capped-rel') 
    135             sage: R.get_print_mode() 
    136             'series' 
    137         """ 
    138         return self._print_mode 
    139  
    140     def set_print_mode(self, print_mode): 
    141         """ 
    142         Sets the print mode. 
    143  
    144         INPUT: 
    145             self -- a p-adic field 
    146             print_mode -- string (see NOTES) 
    147  
    148         EXAMPLES: 
    149             sage: R = Qp(3,5,'capped-rel','val-unit') 
    150             sage: a = R(117); a 
    151                 3^2 * 13 + O(3^7) 
    152             sage: R.set_print_mode('series'); a 
    153                 3^2 + 3^3 + 3^4 + O(3^7) 
    154             sage: R.set_print_mode('val-unit-p'); a 
    155                 p^2 * 13 + O(p^7) 
    156             sage: R.set_print_mode('series-p'); a 
    157                 p^2 + p^3 + p^4 + O(p^7) 
    158  
    159         NOTES: 
    160             The options are: 
    161             'val-unit' -- elements are displayed as p^k*u 
    162             'integer' -- elements are displayed as an integer 
    163             'series' -- elements are displayed as series in p 
    164             'val-unit-p' -- same as val-unit, except that p is written as "p" 
    165             'integer-p' -- same as integer, except that p is written as "p" 
    166             'series-p' -- same as series, except that p is written as "p"     
    167         """ 
    168         if (print_mode in ['val-unit', 'series', 'val-unit-p', 'series-p']): 
    169             self._print_mode = print_mode 
    170         else: 
    171             raise ValueError, "print_mode must be either val-unit, integer, series, val-unit-p, integer-p, or series-p" 
    172117 
    173118    def krull_dimension(self): 

  • sage/rings/padics/padic_field_lazy.py

    r3405 r3667  
    116116    An implementation of p-adic fields using lazy evaluation. 
    117117    """ 
    118     def __init__(self, p, prec, print_mode, halt): 
    119         pAdicFieldBaseGeneric.__init__(self, p, prec, print_mode) 
     118    def __init__(self, p, prec, print_mode, halt, names): 
     119        pAdicFieldBaseGeneric.__init__(self, p, prec, print_mode, names) 
    120120        self._halt = halt 
    121121 
    … …  
    234234        """ 
    235235        from sage.rings.padics.zp import Zp 
    236         return Zp(self.prime(), self.precision_cap(), 'lazy', self.get_print_mode(), self.halting_parameter()) 
     236        return Zp(self.prime(), self.precision_cap(), 'lazy', self.print_mode(), self.halting_parameter()) 
    237237 
    238238    def fraction_field(self): 

  • sage/rings/padics/padic_generic.py

    r3411 r3667  
    6161class pAdicGeneric(sage.rings.padics.local_generic.LocalGeneric): 
    6262 
    63     def __init__(self, p, prec): 
    64         sage.rings.padics.local_generic.LocalGeneric.__init__(self, prec) 
     63    def __init__(self, p, prec, print_mode, names): 
     64        sage.rings.padics.local_generic.LocalGeneric.__init__(self, prec, names) 
    6565        self._p = p 
     66        if (print_mode in ['val-unit', 'terse', 'series']): 
     67            self._print_mode = print_mode 
     68        else: 
     69            raise ValueError, "print_mode must be either val-unit, terse, series" 
    6670 
    6771    def _repr_(self, do_latex = False): 
    6872        return "Generic %s-adic Parent."%(self.prime()) 
     73 
     74    def print_mode(self): 
     75        r""" 
     76        Returns the current print mode as a string. 
     77         
     78        INPUT: 
     79            self -- a p-adic field 
     80 
     81        OUTPUT: 
     82            string -- self's print mode 
     83         
     84        EXAMPLES: 
     85            sage: R = Qp(7,5, 'capped-rel') 
     86            sage: R.print_mode() 
     87            'series' 
     88        """ 
     89        return self._print_mode 
     90 
     91    #def set_print_mode(self, print_mode): 
     92    #    """ 
     93    #    Sets the print mode. 
     94    # 
     95    #    INPUT: 
     96    #        self -- a p-adic ring 
     97    #        print_mode -- string (see NOTES) 
     98    # 
     99    #    EXAMPLES: 
     100    #        sage: R = Zp(3,5,'fixed-mod'); R.set_print_mode('val-unit') 
     101    #        sage: a = R(117); a 
     102    #        3^2 * 13 + O(3^5) 
     103    #        sage: R.set_print_mode('terse'); a 
     104    #        117 + O(3^5) 
     105    #        sage: R.set_print_mode('series'); a 
     106    #        3^2 + 3^3 + 3^4 + O(3^5) 
     107    # 
     108    #    NOTES: 
     109    #        The options for print_mode are: 
     110    #        'val-unit' -- elements are displayed as p^k*u 
     111    #        'terse' -- elements are displayed as an integer if positive valuation, as u/ppow or u/p^k if negative valuation 
     112    #        'series' -- elements are displayed as series in p, where p is self.variable_name() (default, e.g., "5") 
     113    #    """ 
     114         
    69115 
    70116    def characteristic(self): 
    … …  
    136182                3 
    137183        """ 
    138         return self.prime() 
     184 
    139185 
    140186    def residue_class_field(self): 
    … …  
    370416            return self.prime() - 1 
    371417 
    372  
    373  
     418    def extension(self, modulus, prec = None, names = None, print_mode = None, halt = None): 
     419        from sage.rings.padics.extension_factory import ExtensionFactory 
     420        return ExtensionFactory(self, modulus, prec, names, print_mode, halt, check) 
     421 
     422    ext = extension 

  • sage/rings/padics/padic_generic_element.py

    r3409 r3667  
    1717#***************************************************************************** 
    1818 
     19from __future__ import with_statement 
    1920import sage.rings.padics.local_generic_element 
    2021import sage.rings.rational_field 
    … …  
    7677            return 1 
    7778 
    78     def _repr_(self, mode = None, do_latex = False, caprel = False): 
     79    def _is_exact_zero(self): 
     80        return False 
     81 
     82    def _repr_(self, mode = None, do_latex = False): 
    7983        r""" 
    8084            Prints a string representation of the element.  See set_print_mode for more details. 
    … …  
    102106                    3*p + p^3 + O(p^5) 
    103107        """ 
    104         import sage.rings.padics.padic_ring_generic 
    105         if caprel and (self.valuation() == infinity): 
    106                 return "0" 
     108        if self._is_exact_zero(): 
     109            return "0" 
    107110        if mode is None: 
    108             mode = self.parent().get_print_mode() 
    109         elif not ((mode == 'val-unit') or (mode == 'series') or (mode == 'val-unit-p') or (mode == 'series-p') or (isinstance(self.parent(), sage.rings.padics.padic_ring_generic.pAdicRingGeneric) and ((mode == 'integer') or (mode != 'integer-p')))): 
    110             raise TypeError, "printing mode must be one of 'val-unit', 'series', 'integer', 'val-unit-p', 'series-p', and 'integer-p'"  
     111            mode = self.parent().print_mode() 
     112        elif not ((mode == 'val-unit') or (mode == 'series') or (mode == 'terse')): 
     113            raise TypeError, "printing mode must be one of 'val-unit', 'series' or 'terse'" 
     114        pprint = self.parent().variable_name() 
    111115        if self._unit_part() == 0: 
    112116            if mode == 'val-unit' or mode == 'series': 
    113117                if do_latex: 
    114                     return "O(%s^{%s})"%(self.parent().prime(), self.precision_absolute()) 
     118                    return "O(%s^{%s})"%(pprint, self.precision_absolute()) 
    115119                else: 
    116                     return "O(%s^%s)"%(self.parent().prime(), self.precision_absolute()) 
    117             elif mode == 'integer': 
     120                    return "O(%s^%s)"%(pprint, self.precision_absolute()) 
     121            elif mode == 'terse': 
    118122                if do_latex: 
    119                     return "0 + O(%s^{%s})"%(self.parent().prime(), self.precision_absolute()) 
     123                    return "0 + O(%s^{%s})"%(pprint, self.precision_absolute()) 
    120124                else: 
    121                     return "0 + O(%s^%s)"%(self.parent().prime(), self.precision_absolute()) 
    122             elif mode == 'integer-p': 
    123                 if do_latex: 
    124                     return "0 + O(p^{%s})"%(self.precision_absolute()) 
    125                 else: 
    126                     return "0 + O(p^%s)"%(self.precision_absolute()) 
    127             else: 
    128                 if do_latex: 
    129                     return "O(p^{%s})"%(self.precision_absolute()) 
    130                 else: 
    131                     return "O(p^%s)"%(self.precision_absolute()) 
     125                    return "0 + O(%s^%s)"%(pprint, self.precision_absolute()) 
    132126        if mode == 'val-unit': 
    133127            if do_latex: 
    134128                if self.valuation() == 0: 
    135                     return "%s + O(%s^{%s})"%(self._unit_part(), self.parent().prime(), self.precision_absolute()) 
     129                    return "%s + O(%s^{%s})"%(self._unit_part(), pprint, self.precision_absolute()) 
    136130                if self.valuation() == 1: 
    137                     return "%s \\cdot %s + O(%s^{%s})"%(self.parent().prime(), self._unit_part(), self.parent().prime(), self.precision_absolute()) 
    138                 return "%s^{%s} \\cdot %s + O(%s^{%s})"%(self.parent().prime(), self.valuation(), self._unit_part(), self.parent().prime(), self.precision_absolute()) 
     131                    return "%s \\cdot %s + O(%s^{%s})"%(pprint, self._unit_part(), pprint, self.precision_absolute()) 
     132                return "%s^{%s} \\cdot %s + O(%s^{%s})"%(pprint, self.valuation(), self._unit_part(), pprint, self.precision_absolute()) 
    139133            else: 
    140134                if self.valuation() == 0: 
    141                     return "%s + O(%s^%s)"%(self._unit_part(), self.parent().prime(), self.precision_absolute()) 
     135                    return "%s + O(%s^%s)"%(self._unit_part(), pprint, self.precision_absolute()) 
    142136                if self.valuation() == 1: 
    143                     return "%s * %s + O(%s^%s)"%(self.parent().prime(), self._unit_part(), self.parent().prime(), self.precision_absolute()) 
    144                 return "%s^%s * %s + O(%s^%s)"%(self.parent().prime(), self.valuation(), self._unit_part(), self.parent().prime(), self.precision_absolute()) 
    145         elif mode == 'val-unit-p': 
    146             if do_latex: 
    147                 if self.valuation() == 0: 
    148                     return "%s + O(p^{%s})"%(self._unit_part(), self.precision_absolute()) 
    149                 if self.valuation() == 1: 
    150                     return "p \\cdot %s + O(p^{%s})"%(self._unit_part(), self.precision_absolute()) 
    151                 return "p^{%s} * %s + O(p^{%s})"%(self.valuation(), self._unit_part(), self.precision_absolute()) 
     137                    return "%s * %s + O(%s^%s)"%(pprint, self._unit_part(), pprint, self.precision_absolute()) 
     138                return "%s^%s * %s + O(%s^%s)"%(pprint, self.valuation(), self._unit_part(), pprint, self.precision_absolute()) 
     139        elif mode == 'terse': 
     140            if self.valuation() < 0: 
     141                ppow1 = str(self.prime() ** (-self.valuation())) 
     142                if do_latex: 
     143                    ppow2 = "%s^{%s}"%(pprint, -self.valuation()) 
     144                    if len(ppow1) < len(ppow2): 
     145                        ppow = ppow1 
     146                    else: 
     147                        ppow = ppow2 
     148                    return "%s/%s + O(%s^{%s})"%(self.unit_part().lift(), ppow, pprint, self.precision_absolute()) 
     149                else: 
     150                    ppow2 = "%s^%s"%(p, -self.valuation()) 
     151                    if len(ppow1) < len(ppow2): 
     152                        ppow = ppow1 
     153                    else: 
     154                        ppow = ppow2 
     155                    return "%s/%s + O(%s^{%s})"%(self.unit_part().lift(), ppow, pprint, self.precision_absolute()) 
    152156            else: 
    153                 if self.valuation() == 0: 
    154                     return "%s + O(p^%s)"%(self._unit_part(), self.precision_absolute()) 
    155                 if self.valuation() == 1: 
    156                     return "p * %s + O(p^%s)"%(self._unit_part(), self.precision_absolute()) 
    157                 return "p^%s * %s + O(p^%s)"%(self.valuation(), self._unit_part(), self.precision_absolute()) 
    158         elif mode == 'integer': 
    159             if do_latex: 
    160                 return "%s + O(%s^{%s})"%(self.lift(), self.parent().prime(), self.precision_absolute()) 
    161             else: 
    162                 return "%s + O(%s^%s)"%(self.lift(), self.parent().prime(), self.precision_absolute()) 
    163         elif mode == 'integer-p': 
    164             if do_latex: 
    165                 return "%s + O(p^{%s})"%(self.lift(), self.precision_absolute()) 
    166             else: 
    167                 return "%s + O(p^%s)"%(self.lift(), self.precision_absolute()) 
     157                if do_latex: 
     158                    return "%s + O(%s^{%s})"%(self.lift(), pprint, self.precision_absolute()) 
     159                else: 
     160                    return "%s + O(%s^%s)"%(self.lift(), pprint, self.precision_absolute()) 
    168161        else: 
    169162            exp = self.valuation() 
    … …  
    172165            s = "" 
    173166            while v != 0: 
     167                var = pprint 
    174168                coeff = v % p 
    175169                if coeff != 0: 
    … …  
    177171                        s += "%s + "%coeff 
    178172                    else: 
    179                         if mode == 'series': 
    180                             var = "%s"%p 
    181                         else: 
    182                             var = "p" 
    183173                        if exp != 1: 
    184174                            if do_latex: 
    … …  
    195185                exp += 1 
    196186                v = (v - coeff) / p 
    197             if mode == 'series': 
    198                 s += "O(%s"%(p) 
    199             else: 
    200                 s += "O(p" 
     187            s += "O(%s"%(pprint) 
    201188            if self.precision_absolute() == 1: 
    202189                s += ")" 

  • sage/rings/padics/padic_lazy_element.py

    r3415 r3667  
    1 import sage.rings.padics.padic_generic_element 
     1import sage.rings.padics.padic_lazy_generic_element 
    22import sys 
    33 
    44Mod = sage.rings.integer_mod.Mod 
    55Integer = sage.rings.integer.Integer 
    6 pAdicGenericElement = sage.rings.padics.padic_generic_element.pAdicGenericElement 
     6pAdicLazyGenericElement = sage.rings.padics.padic_lazy_generic_element.pAdicLazyGenericElement 
    77infinity = sage.rings.infinity.infinity 
    88HaltingError = sage.rings.padics.precision_error.HaltingError 
    … …  
    1010PrecisionError = sage.rings.padics.precision_error.PrecisionError 
    1111 
    12 class pAdicLazyElement(sage.rings.padics.padic_generic_element.pAdicGenericElement): 
     12class pAdicLazyElement(pAdicLazyGenericElement): 
    1313    def _add_(self, right): 
    1414        if isinstance(self, pAdicLazy_zero): 
    … …  
    235235        return pAdic_logah(self) 
    236236 
     237    def padded_list(self, absprec = infinity, relprec = infinity): 
     238        if absprec is infinity and relprec is infinity: 
     239            raise ValueError, "must specify at least one of absprec and relprec" 
     240        if self.parent().is_field(): 
     241            if self.valuation() is infinity: 
     242                if relprec < infinity: 
     243                    return [self.parent().residue_class_field()(0)]*relprec 
     244                else: 
     245                    return [] 
     246            relprec = min(relprec, absprec - self.valuation()) 
     247            return self.list()[:relprec] + [self.parent().residue_class_field()(0)]*(self.precision_relative() - relprec) 
     248        if self.valuation() is infinity: 
     249            if absprec < infinity: 
     250                return [self.parent().residue_class_field()(0)]*absprec 
     251            else: 
     252                raise ValueError, "would return infinite list" 
     253        absprec = min(absprec, relprec + self.valuation()) 
     254        return self.list()[:absprec] + [self.parent().residue_class_field()(0)]*(self.precision_absolute() - absprec) 
     255 
     256 
    237257    def precision_absolute(self): 
    238258        return self._cache_prec + self._base_valuation 
    … …  
    293313        return self._base_valuation + self._cache_prec 
    294314 
     315    def _is_exact_zero(self): 
     316        return False 
    295317 
    296318# The following subclasses are used to create pAdicLazyElements from other data 
    … …  
    381403    def set_precision_absolute(self, n, halt = None): 
    382404        pass 
     405 
     406    def _is_exact_zero(self): 
     407        return True 
    383408 
    384409class pAdicLazy_valpower(pAdicLazyElement): 

  • sage/rings/padics/padic_ring_capped_absolute.py

    r3405 r3667  
    9898import sage.rings.padics.padic_ring_capped_relative_element 
    9999import sage.rings.padics.padic_lazy_element 
     100import sage.rings.infinity 
    100101 
    101102Integer = sage.rings.integer.Integer 
    102103Mod = sage.rings.integer_mod.Mod 
    103 Qp = sage.rings.padics.qp.Qp 
     104infinity = sage.rings.infinity.infinity 
    104105pAdicRingBaseGeneric = sage.rings.padics.padic_ring_generic.pAdicRingBaseGeneric 
    105106pAdicFieldBaseGeneric = sage.rings.padics.padic_field_generic.pAdicFieldBaseGeneric 
    … …  
    114115    """ 
    115116     
    116     def __call__(self, x, absprec = None, relprec = None): 
     117    def __call__(self, x, absprec = infinity, relprec = infinity): 
    117118        r""" 
    118119            Casts x into self.  Uses the constructor from pAdicRingCappedAbsoluteElement. 
    … …  
    187188        Returns the fraction field of self. 
    188189        """ 
    189         return Qp(self.prime(), self.precision_cap(), 'capped-rel', self.get_print_mode()) 
     190        from sage.rings.padics.qp import Qp 
     191        return Qp(self.prime(), self.precision_cap(), 'capped-rel', self.print_mode()) 
    190192 
    191193    def random_element(self): 

  • sage/rings/padics/padic_ring_capped_absolute_element.py

    r3408 r3667  
    4747class pAdicRingCappedAbsoluteElement(pAdicRingFixedModElement): 
    4848 
    49     def __init__(self, parent, x, absprec=None, relprec = None, construct=False): 
     49    def __init__(self, parent, x, absprec=infinity, relprec = infinity, construct=False): 
    5050        sage.rings.commutative_ring_element.CommutativeRingElement.__init__(self,parent) 
    5151        if construct: 
    5252            (self._value, self._absprec) = x 
    5353            return 
    54         if not absprec is None and not relprec is None: 
     54        if not absprec is infinity and not relprec is infinity: 
    5555            raise ValueError, "can only specify one of absprec and relprec" 
    56         if relprec is None: 
    57             if absprec is None or absprec > parent.precision_cap(): 
     56        if relprec is infinity: 
     57            if absprec > parent.precision_cap(): 
    5858                absprec = parent.precision_cap() 
    5959 
    … …  
    6161            raise ValueError, "element valuation cannot be negative." 
    6262        if isinstance(x, pAdicLazyElement): 
    63             if relprec is None: 
     63            if relprec is infinity: 
    6464                absprec = min(absprec, parent.precision_cap()) 
    6565                try: 
    … …  
    7777            return 
    7878        if isinstance(x, pAdicGenericElement): 
    79             if relprec is None: 
     79            if relprec is infinity: 
    8080                self._absprec = min(x.precision_absolute(), absprec) 
    8181            else: 
    … …  
    8686        if isinstance(x, pari_gen): 
    8787            if x.type() == "t_PADIC": 
    88                 if not absprec is None: 
    89                     absprec = min(x.padicprec(parent.prime()), absprec) 
    90                 else: 
    91                     absprec = x.padicprec(parent.prime()) 
     88                absprec = min(x.padicprec(parent.prime()), absprec) 
    9289                x = x.lift() 
    9390            if x.type() == "t_INT": 
    … …  
    10299            if not k or p != parent.prime(): 
    103100                raise TypeError, "cannot change primes in creating p-adic elements" 
    104  
    105             if absprec is None: 
    106                 absprec = k 
    107             else: 
    108                 absprec = min(absprec, k) 
     101            absprec = min(absprec, k) 
    109102            x = x.lift() 
    110103 
    … …  
    129122                raise ValueError, "p divides the denominator" 
    130123        if isinstance(x, (int, long, Integer, Rational)): 
    131             if absprec is None: 
    132                 self._absprec = min(val + relprec, parent.precision_cap()) 
    133             elif relprec is None: 
    134                 self._absprec = absprec 
    135             else: 
    136                 self._absprec = min(absprec, val + relprec, parent.precision_cap()) 
     124            self._absprec = min(absprec, val + relprec, parent.precision_cap()) 
    137125            self._value = Mod(Mod(x, parent.prime_pow(self._absprec)), parent.prime_pow(parent.precision_cap())) 
    138126        else: 

  • sage/rings/padics/padic_ring_capped_relative.py

    r3402 r3667  
    9595import sage.rings.padics.padic_ring_fixed_mod 
    9696import sage.rings.padics.padic_lazy_element 
    97 import sage.rings.padics.qp 
     97import sage.rings.infinity 
    9898 
    9999from sage.rings.integer_ring import ZZ 
    … …  
    101101Integer = sage.rings.integer.Integer 
    102102Mod = sage.rings.integer_mod.Mod 
    103 Qp = sage.rings.padics.qp.Qp 
     103infinity = sage.rings.infinity.infinity 
    104104pAdicRingBaseGeneric = sage.rings.padics.padic_ring_generic.pAdicRingBaseGeneric 
    105105pAdicFieldBaseGeneric = sage.rings.padics.padic_field_generic.pAdicFieldBaseGeneric 
    … …  
    113113    """ 
    114114     
    115     def __call__(self, x, absprec = None, relprec = None): 
     115    def __call__(self, x, absprec = infinity, relprec = infinity): 
    116116        r""" 
    117117            Casts x into self.  Uses the constructor from pAdicRingCappedRelativeElement. 
    … …  
    194194         
    195195        """ 
    196         return Qp(self.prime(), self.precision_cap(), 'capped-rel', self.get_print_mode()) 
     196        from sage.rings.padics.qp import Qp 
     197        return Qp(self.prime(), self.precision_cap(), 'capped-rel', self.print_mode()) 
    197198 
    198199    def random_element(self, algorithm='default'): 

  • sage/rings/padics/padic_ring_capped_relative_element.py

    r3409 r3667  
    4747 
    4848class pAdicRingCappedRelativeElement(pAdicRingGenericElement): 
    49     def __init__(self, parent, x, absprec=None, relprec=None, construct=False): 
     49    def __init__(self, parent, x, absprec=infinity, relprec=infinity, construct=False): 
    5050        """ 
    5151        Constructs new element with given parent and value. 
    … …  
    120120            return 
    121121 
    122         if not absprec is None and not relprec is None: 
     122        if not absprec is infinity and not relprec is infinity: 
    123123            raise ValueError, "can only specify one of absprec and relprec" 
    124         if absprec is None: 
    125             if relprec is None or relprec > parent.precision_cap(): 
     124        if absprec is infinity: 
     125            if relprec > parent.precision_cap(): 
    126126                relprec = parent.precision_cap() 
    127127 
    … …  
    129129            raise ValueError, "element has negative valuation." 
    130130        if isinstance(x, pAdicLazyElement): 
    131             if relprec is None: 
     131            if parent.prime() != x.parent().prime(): 
     132                raise ValueError, "Cannot coerce between p-adic rings with different primes." 
     133            if relprec is infinity: 
    132134                try: 
    133135                    x.set_precision_absolute(absprec) 
    … …  
    149151                raise ValueError, "Cannot coerce between p-adic rings with different primes." 
    150152            self._ordp = x.valuation() 
    151             if relprec is None: 
     153            if relprec is infinity: 
    152154                if self._ordp is infinity: 
    153                     relprec = 0 
     155                    relprec = Integer(0) 
    154156                else: 
    155157                    relprec = absprec - self._ordp 
    … …  
    160162        if isinstance(x, pari_gen): 
    161163            if x.type() == "t_PADIC": 
    162                 if not absprec is None: 
    163                     absprec = min(x.padicprec(parent.prime()), absprec) 
    164                 else: 
    165                     absprec = x.padicprec(parent.prime()) 
     164                absprec = min(x.padicprec(parent.prime()), absprec) 
    166165                x = x.lift() 
    167166            if x.type() == "t_INT": 
    … …  
    183182                raise TypeError, "cannot change primes in creating p-adic elements" 
    184183            x = x.lift() 
    185             if absprec is None: 
    186                 absprec = k 
    187             else: 
    188                 absprec = min(k, absprec) 
     184            absprec = min(k, absprec) 
    189185 
    190186            # We now use the code, below, so don't make the next line elif 
    … …  
    197193        if self._ordp < 0: 
    198194            raise ValueError, "element not a p-adic integer." 
    199         elif self._ordp == infinity: 
     195        elif self._ordp is infinity: 
    200196            self._unit = Mod(0, 1) 
    201             self._relprec = 0 
     197            self._relprec = Integer(0) 
    202198            return 
    203199        x = x / self.parent().prime_pow(self._ordp) 
    204         if relprec is None: 
    205             if self._ordp is infinity: 
    206                 self._relprec = 0 
    207             else: 
    208                 self._relprec = min(absprec - self._ordp, parent.precision_cap()) 
    209         elif absprec is None: 
    210             self._relprec = relprec 
     200        if self._ordp is infinity: 
     201            self._relprec = Integer(0) 
    211202        else: 
    212203            self._relprec = min(relprec, absprec - self._ordp, parent.precision_cap()) 
    213204        self._unit = Mod(x, self.parent().prime_pow(self._relprec)) 
    214         return                               
    215  
    216     def _repr_(self, mode = None, do_latex = False): 
    217         return sage.rings.padics.padic_generic_element.pAdicGenericElement._repr_(self, mode, do_latex, True) 
    218205 
    219206    #def __mod__(self, right): 
    … …  
    397384        raise NotImplementedError         
    398385 
     386    def _is_exact_zero(self): 
     387        return self.valuation() is infinity 
     388 
    399389    def is_zero(self, prec): 
    400390        r""" 

  • sage/rings/padics/padic_ring_extension.py

    r3322 r3667  
    3434    def __init__(self, poly): 
    3535        R = poly.base_ring() 
    36         pAdicRingGeneric.__init__(self, R.prime(), R.precision_cap(), R.get_print_mode()) 
     36        pAdicRingGeneric.__init__(self, R.prime(), R.precision_cap(), R.print_mode()) 
    3737        PolynomialQuotientRing_domain.__init__(self, poly.parent(), poly) 
    3838 

  • sage/rings/padics/padic_ring_fixed_mod.py

    r3405 r3667  
    8686import sage.rings.padics.padic_ring_fixed_mod_element 
    8787import sage.rings.padics.padic_ring_capped_absolute_element 
    88 import sage.rings.padics.qp 
    8988import sage.rings.integer_mod 
    9089 
    9190Integer = sage.rings.integer.Integer 
    9291Integers = sage.rings.integer_mod_ring.IntegerModRing 
     92infinity = sage.rings.infinity.infinity 
    9393pAdicRingBaseGeneric = sage.rings.padics.padic_ring_generic.pAdicRingBaseGeneric 
    9494pAdicFieldBaseGeneric = sage.rings.padics.padic_field_generic.pAdicFieldBaseGeneric 
    … …  
    102102    """ 
    103103     
    104     def __call__(self, x, absprec = None, relprec = None): 
     104    def __call__(self, x, absprec = infinity, relprec = infinity): 
    105105        r""" 
    106106            Casts x into self.  Uses the constructor from pAdicRingFixedModElement. 
    107107        """ 
    108         return pAdicRingFixedModElement(self, x, absprec, relprec) 
     108        return pAdicRingFixedModElement(self, x) 
    109109 
    110110    def __cmp__(self, other): 
    … …  
    199199    def principal_unit_group(self): 
    200200        raise NotImplementedError 
    201  
     201         

  • sage/rings/padics/padic_ring_fixed_mod_element.py

    r3408 r3667  
    4646 
    4747class pAdicRingFixedModElement(pAdicRingGenericElement): 
    48     def __init__(self, parent, x, absprec = None, relprec = None, construct=False): 
     48    def __init__(self, parent, x, construct=False): 
    4949        r""" 
    5050        INPUT: 

  • sage/rings/padics/padic_ring_generic.py

    r3411 r3667  
    136136 
    137137class pAdicRingGeneric(sage.rings.padics.padic_generic.pAdicGeneric): 
    138  
    139     def __init__(self, p, prec, print_mode): 
    140         sage.rings.padics.padic_generic.pAdicGeneric.__init__(self, p, prec) 
    141         self.set_print_mode(print_mode) 
    142  
    143138    def _repr_(self, do_latex = False): 
    144139        return "Generic %s-adic Ring"%(self.prime()) 
    145  
    146     def get_print_mode(self): 
    147         r""" 
    148         Returns the current print mode as a string. 
    149          
    150         INPUT: 
    151             self -- a p-adic ring 
    152  
    153         OUTPUT: 
    154             string -- self's print mode 
    155  
    156         EXAMPLES: 
    157             sage: R = Zp(7,5,'fixed-mod') 
    158             sage: R.get_print_mode() 
    159             'series' 
    160         """ 
    161         return self._print_mode 
    162  
    163     def set_print_mode(self, print_mode): 
    164         """ 
    165         Sets the print mode. 
    166  
    167         INPUT: 
    168             self -- a p-adic ring 
    169             print_mode -- string (see NOTES) 
    170  
    171         EXAMPLES: 
    172             sage: R = Zp(3,5,'fixed-mod'); R.set_print_mode('val-unit') 
    173             sage: a = R(117); a 
    174             3^2 * 13 + O(3^5) 
    175             sage: R.set_print_mode('integer'); a 
    176             117 + O(3^5) 
    177             sage: R.set_print_mode('series'); a 
    178             3^2 + 3^3 + 3^4 + O(3^5) 
    179             sage: R.set_print_mode('val-unit-p'); a 
    180             p^2 * 13 + O(p^5) 
    181             sage: R.set_print_mode('integer-p'); a 
    182             117 + O(p^5) 
    183             sage: R.set_print_mode('series-p'); a 
    184             p^2 + p^3 + p^4 + O(p^5) 
    185  
    186         NOTES: 
    187             The options for print_mode are: 
    188             'val-unit' -- elements are displayed as p^k*u 
    189             'integer' -- elements are displayed as an integer 
    190             'series' -- elements are displayed as series in p 
    191             'val-unit-p' -- same as val-unit, except that p is written as "p" 
    192             'integer-p' -- same as integer, except that p is written as "p" 
    193             'series-p' -- same as series, except that p is written as "p" 
    194         """ 
    195         if (print_mode in ['val-unit', 'integer', 'series', 'val-unit-p', 'integer-p', 'series-p']): 
    196             self._print_mode = print_mode 
    197         else: 
    198             raise ValueError, "print_mode must be either val-unit, integer, series, val-unit-p, integer-p, or series-p" 
    199140 
    200141    def is_field(self): 

  • sage/rings/padics/padic_ring_generic_element.py

    r3411 r3667  
    7474 
    7575 
    76     def padded_list(self, n): 
     76    def padded_list(self, absprec = infinity, relprec = infinity): 
    7777        """ 
    78         Returns a list of coeficiants of p starting with $p^0$ up to $p^n$ exclusive (padded with zeros if needed) 
     78        Returns a list of coeficiants of p starting with $p^0$ up to $p^n$ exclusive (padded with zeros if needed), where n is the minimum of absprec and relprec + self.valuation() 
     79         
    7980        INPUT: 
    8081            self -- a p-adic element 
    81             n - an integer 
     82            absprec -- an integer 
     83            relprec -- an integer 
    8284        OUTPUT: 
    8385            list -- the list of coeficients of self 
    … …  
    8991            this differs from the padded_list method of padic_field_element 
    9092        """ 
    91         return self.list()[:n] + [0 for w in range(self.precision_absolute(), n)] 
     93        if absprec is infinity and relprec is infinity: 
     94            raise ValueError, "must specify at least one of absprec and relprec" 
     95        if self.valuation() is infinity: 
     96            if absprec < infinity: 
     97                return [self.parent().residue_class_field()(0)]*absprec 
     98            else: 
     99                raise ValueError, "would return infinite list" 
     100        absprec = min(absprec, relprec + self.valuation()) 
     101        return self.list()[:absprec] + [self.parent().residue_class_field()(0)]*(self.precision_absolute() - absprec) 
     102 
    92103 
    93104    def residue(self, prec): 

  • sage/rings/padics/padic_ring_lazy.py

    r3405 r3667  
    9494import sage.rings.padics.padic_ring_generic 
    9595import sage.rings.padics.padic_field_generic 
    96 import sage.rings.padics.qp 
    9796import sage.rings.infinity 
    9897import copy 
    … …  
    105104Integer = sage.rings.integer.Integer 
    106105Rational = sage.rings.rational.Rational 
    107 Qp = sage.rings.padics.qp.Qp 
    108106pAdicFieldGenericElement = sage.rings.padics.padic_field_generic_element.pAdicFieldGenericElement 
    109107pAdicRingGenericElement = sage.rings.padics.padic_ring_generic_element.pAdicRingGenericElement 
    … …  
    115113    An implementation of the p-adic integers with lazily evaluated elements. 
    116114    """ 
    117     def __init__(self, p, prec, print_mode, halt): 
    118         pAdicRingBaseGeneric.__init__(self, p, prec, print_mode) 
     115    def __init__(self, p, prec, print_mode, halt, names): 
     116        pAdicRingBaseGeneric.__init__(self, p, prec, print_mode, names) 
    119117        self._halt = halt 
    120118     
    … …  
    170168            if x.type() == "t_PADIC": 
    171169                try: 
     170                    from sage.rings.padics.qp import Qp 
    172171                    return lazy.pAdicLazy_otherpadic(self, Qp(parent.prime(), x.padicprec(parent.prime()) - x.valuation(parent.prime()), 'capped-rel')(x), absprec, relprec) 
    173172                except PariError: 
    … …  
    247246        Returns the fraction field of self. 
    248247        """ 
    249         return Qp(self.prime(), self.precision_cap(), 'lazy', self.get_print_mode(), self.halting_parameter()) 
     248        from sage.rings.padics.qp import Qp 
     249        return Qp(self.prime(), self.precision_cap(), 'lazy', self.print_mode(), self.halting_parameter()) 
    250250 
    251251    def random_element(self): 

  • sage/rings/padics/qp.py

    r3415 r3667  
    22import sage.rings.padics.padic_field_capped_relative 
    33import sage.rings.padics.padic_field_lazy 
     4import sage.rings.padics.unramified_field_extension_capped_relative 
     5import sage.rings.padics.unramified_field_extension_lazy 
     6 
    47 
    58Integer = sage.rings.integer.Integer 
    69pAdicFieldCappedRelative = sage.rings.padics.padic_field_capped_relative.pAdicFieldCappedRelative 
    710pAdicFieldLazy = sage.rings.padics.padic_field_lazy.pAdicFieldLazy 
     11UnramifiedFieldExtensionCappedRelative = sage.rings.padics.unramified_field_extension_capped_relative.UnramifiedFieldExtensionCappedRelative 
     12UnramifiedFieldExtensionLazy = sage.rings.padics.unramified_field_extension_lazy.UnramifiedFieldExtensionLazy 
    813 
    914 
    1015padic_field_cache = {} 
    11 def Qp(p, prec = 20, type = 'capped-rel', print_mode = None, halt = 40, check = True): 
     16def Qp(p, prec = 20, type = 'capped-rel', print_mode = None, halt = 40, names = None, check = True): 
    1217    """ 
    1318    A creation function for p-adic fields. 
    … …  
    5459        elif isinstance(halt, (int, long)): 
    5560            halt = Integer(halt) 
     61    if names is None: 
     62        names = str(p) 
    5663    if type != 'lazy': 
    57         key = (p, prec, type) 
     64        key = (p, prec, type, names) 
    5865    else: 
    59         key = (p, prec, halt) 
     66        key = (p, prec, halt, names) 
    6067    if padic_field_cache.has_key(key): 
    6168        K = padic_field_cache[key]() 
    … …  
    6673                K.set_print_mode('series') 
    6774            return K 
    68     if print_mode == None: 
     75    if print_mode is None: 
    6976        print_mode = 'series' 
    7077    if (type == 'capped-rel'): 
    71         K = pAdicFieldCappedRelative(p, prec, print_mode) 
     78        K = pAdicFieldCappedRelative(p, prec, print_mode, names) 
    7279    elif (type == 'lazy'): 
    73         K = pAdicFieldLazy(p, prec, print_mode, halt) 
     80        K = pAdicFieldLazy(p, prec, print_mode, halt, names) 
    7481    else: 
    7582        raise ValueError, "type must be either 'capped-rel' or 'lazy'" 
    … …  
    7986pAdicField = Qp # for backwards compatibility; and it's not hard. 
    8087 
    81 qadic_field_cache = {} 
    82 def Qq(q, names=None, prec=20, type='capped-rel', print_mode=None, halt=40, modulus=None, check=True): 
     88def Qq(q, prec = None, type = 'capped-rel', modulus = None, names=None, print_mode="series", halt=40, qp_name = None, check=True): 
    8389    r""" 
    8490    Given a prime power q = p^n, return the unique unramified extension 
    … …  
    9096 
    9197    from sage.rings.integer import Integer 
    92     from sage.rings.polynomial_ring import PolynomialRing 
    93     from sage.rings.padics.unramified_ring_extension import UnramifiedRingExtension 
    94     from sage.rings.integer_ring import ZZ 
    95  
    9698    if check: 
    9799        if names is None: 
    … …  
    117119        raise ValueError, "q must be a prime power" 
    118120    if F[0][1] == 1: 
    119         return Qp(q, prec, type, print_mode, halt) 
    120  
    121     if type != 'lazy': 
    122         key = (q, names, prec, type) 
    123     else: 
    124         key = (q, names, prec, halt) 
    125     if qadic_field_cache.has_key(key): 
    126         K = qadic_field_cache[key]() 
    127         if not (K is None): 
    128             if not (print_mode is None): 
    129                 K.set_print_mode(print_mode) 
    130             return K 
    131  
     121        return Qp(q, prec, type, print_mode, halt, names, check) 
     122    base = Qp(F[0][0], prec, type, print_mode, halt, qp_name, check = False) 
    132123    if modulus is None: 
    133         check = False 
    134124        from sage.rings.finite_field import GF 
    135         modulus = PolynomialRing(Qp(F[0][0], prec, type, print_mode, halt), names)(GF(q,names).modulus().change_ring(ZZ)) 
    136     if print_mode is None: 
    137         print_mode = 'series' 
    138     K = UnramifiedRingExtension(modulus, prec, print_mode, check) 
    139     qadic_field_cache[key] = weakref.ref(K) 
    140  
    141     return K 
     125        from sage.rings.integer_ring import ZZ 
     126        modulus = PolynomialRing(base, 'x')(GF(q, names).modulus().change_ring(ZZ)) 
     127    return ExtensionFactory(base, modulus, prec, names, print_mode, halt, check, unram = True) 
    142128         

  • sage/rings/padics/zp.py

    r3414 r3667  
    55import sage.rings.padics.padic_ring_lazy 
    66import sage.rings.integer 
     7import sage.rings.padics.unramified_ring_extension_capped_relative 
     8import sage.rings.padics.unramified_ring_extension_capped_absolute 
     9import sage.rings.padics.unramified_ring_extension_fixed_mod 
     10import sage.rings.padics.unramified_ring_extension_lazy 
     11 
    712 
    813from sage.rings.integer_ring import ZZ 
    914 
    1015from sage.rings.polynomial_ring import PolynomialRing 
    11 import sage.rings.padics.unramified_ring_extension 
    1216 
     17UnramifiedRingExtensionCappedRelative = sage.rings.padics.unramified_ring_extension_capped_relative.UnramifiedRingExtensionCappedRelative 
     18UnramifiedRingExtensionCappedAbsolute = sage.rings.padics.unramified_ring_extension_capped_absolute.UnramifiedRingExtensionCappedAbsolute 
     19UnramifiedRingExtensionFixedMod = sage.rings.padics.unramified_ring_extension_fixed_mod.UnramifiedRingExtensionFixedMod 
     20UnramifiedRingExtensionLazy = sage.rings.padics.unramified_ring_extension_lazy.UnramifiedRingExtensionLazy 
    1321pAdicRingCappedRelative = sage.rings.padics.padic_ring_capped_relative.pAdicRingCappedRelative 
    1422pAdicRingCappedAbsolute = sage.rings.padics.padic_ring_capped_absolute.pAdicRingCappedAbsolute 
    … …  
    1624pAdicRingLazy = sage.rings.padics.padic_ring_lazy.pAdicRingLazy 
    1725Integer = sage.rings.integer.Integer 
    18 UnramifiedRingExtension = sage.rings.padics.unramified_ring_extension.UnramifiedRingExtension 
    1926 
    2027padic_ring_cache = {} 
    21 def Zp(p, prec = 20, type = 'capped-rel', print_mode = None, halt = 40, check=True): 
     28def Zp(p, prec = 20, type = 'capped-rel', print_mode = None, halt = 40, names = None, check=True): 
    2229    """ 
    2330    A creation function for p-adic rings. 
    … …  
    6572        elif isinstance(halt, (int, long)): 
    6673            halt = Integer(halt) 
     74    if names is None: 
     75        names = str(p) 
    6776    if type != 'lazy': 
    68         key = (p, prec, type) 
     77        key = (p, prec, type, names) 
    6978    else: 
    70         key = (p, prec, halt) 
     79        key = (p, prec, halt, names) 
    7180    if padic_ring_cache.has_key(key): 
    7281        K = padic_ring_cache[key]() 
    … …  
    7887        print_mode = 'series' 
    7988    if (type == 'capped-rel'): 
    80         K = pAdicRingCappedRelative(p, prec, print_mode) 
     89        K = pAdicRingCappedRelative(p, prec, print_mode, names) 
    8190    elif (type == 'fixed-mod'): 
    82         K = pAdicRingFixedMod(p, prec, print_mode) 
     91        K = pAdicRingFixedMod(p, prec, print_mode, names) 
    8392    elif (type == 'capped-abs'): 
    84         K = pAdicRingCappedAbsolute(p, prec, print_mode) 
     93        K = pAdicRingCappedAbsolute(p, prec, print_mode, names) 
    8594    elif (type == 'lazy'): 
    86         K = pAdicRingLazy(p, prec, print_mode, halt) 
     95        K = pAdicRingLazy(p, prec, print_mode, halt, names) 
    8796    else: 
    8897        raise ValueError, "type must be one of 'capped-rel', 'fixed-mod', 'capped-abs' or 'lazy'" 
    … …  
    9099    return K 
    91100 
    92 qadic_ring_cache = {} 
    93 def Zq(q, prec = 20, type = 'capped-abs', modulus = None, names=None, print_mode = None, halt = 40, check = True): 
     101def Zq(q, prec = 20, type = 'capped-abs', modulus = None, names=None, print_mode = None, halt = 40, zp_name = None, check = True): 
    94102    r""" 
    95103    The creation function for unramified extensions of $\Z_p$ 
    … …  
    117125        raise ValueError, "q must be a prime power" 
    118126    if F[0][1] == 1: 
    119         return Zp(q, prec, type, print_mode, halt) 
    120     if type != 'lazy': 
    121         key = (q, names, prec, type, modulus) 
    122     else: 
    123         key = (q, names, prec, halt, modulus) 
    124     if qadic_ring_cache.has_key(key): 
    125         K = qadic_ring_cache[key]() 
    126         if not (K is None): 
    127             if not (print_mode is None): 
    128                 K.set_print_mode(print_mode) 
    129             return K 
     127        return Zp(q, prec, type, print_mode, halt, names, check) 
     128    base = Zp(F[0][0], prec, type, print_mode, halt, zp_name, check = False) 
    130129    if modulus is None: 
    131         check = False 
    132130        from sage.rings.finite_field import GF 
    133         modulus = PolynomialRing(Zp(F[0][0], prec, type, print_mode, halt), names)(GF(q, names).modulus().change_ring(ZZ)) 
    134     if print_mode is None: 
    135         print_mode = 'series' 
    136     K = UnramifiedRingExtension(modulus, prec, print_mode, check) 
    137     qadic_ring_cache[key] = weakref.ref(K) 
    138     return K 
    139      
     131        if zp_name is None: 
     132            zp_name = str(p) 
     133        modulus = PolynomialRing(base, 'x')(GF(q, names).modulus().change_ring(ZZ)) 
     134    return ExtensionFactory(base, modulus, prec, names, print_mode, halt, check, unram = True) 

  • sage/rings/polynomial_ring.py

    r3407 r3667  
    285285         
    286286    def __set_polynomial_class(self, cls=None): 
    287         from padics.unramified_ring_extension import UnramifiedRingExtension #here for a hack.  Should be removed after hack is gone 
    288287        if not (cls is None): 
    289288            self.__polynomial_class = cls 
    … …  
    298297        elif isinstance(R, padics.padic_field_lazy.pAdicFieldLazy): 
    299298            self.__polynomial_class = polynomial_element_generic.Polynomial_padic_field_lazy_dense 
    300         elif isinstance(R, UnramifiedRingExtension) and R.ground_ring_of_tower().is_field(): 
    301             #hack.  Should be removed after we fix inheretance structure 
    302             self.__polynomial_class = polynomial_element_generic.Polynomial_padic_field_dense 
    303299        elif isinstance(R, padics.padic_ring_generic.pAdicRingGeneric): 
    304300            self.__polynomial_class = polynomial_element_generic.Polynomial_padic_ring_dense 

  • sage/rings/polynomial_ring_constructor.py

    r3407 r3667  
    260260def _single_variate(base_ring, name, sparse): 
    261261    import polynomial_ring as m 
    262     import padics.unramified_ring_extension #needed for hack; should be deleted after hack is removed 
    263262    name = normalize_names(1, name) 
    264263    key = (base_ring, name, sparse) 
    … …  
    281280        elif isinstance(base_ring, padics.padic_field_lazy.pAdicFieldLazy): 
    282281            R = m.PolynomialRing_padic_field_lazy(base_ring, name) 
    283  
    284         elif isinstance(base_ring, padics.unramified_ring_extension.UnramifiedRingExtension) and base_ring.ground_ring_of_tower().is_field(): 
    285             # Hack to get unramified field extension polynomials working in the short term. 
    286             R = m.PolynomialRing_padic_field(base_ring, name) 
    287282 
    288283        elif isinstance(base_ring, padics.padic_field_generic.pAdicFieldGeneric): 

  • sage/structure/element.pyx

    r3415 r3417  
    19201920        return op(x1,y1)         
    19211921    except TypeError, msg: 
    1922         print msg  # this can be useful for debugging. 
     1922        #print msg  # this can be useful for debugging. 
    19231923        if not op is operator.mul: 
    19241924            raise TypeError, arith_error_message(x,y,op) 
Note: See TracChangeset for help on using the changeset viewer.