Ticket #12974: 12974_flat.patch

File 12974_flat.patch, 45.0 KB (added by jdemeyer, 9 years ago)
  • sage/functions/piecewise.py

    # HG changeset patch
    # User Jeroen Demeyer <jdemeyer@cage.ugent.be>
    # Date 1340873533 -7200
    # Node ID e9fa419241c257b81e0e0e2715dd56d978db2472
    # Parent  8a77d4c8057f92c252be09edba7ec66f9848b71a
    change all .__ attributes to ._
    refactor the tick formatter in Graphics.matplotlib
    reorder some arguments to make it easier to find and edit them later
    
    diff --git a/sage/functions/piecewise.py b/sage/functions/piecewise.py
    a b  
    10231023            sage: p = f.plot(legend_label='$f(x)$')
    10241024            sage: lines = [
    10251025            ...     line
    1026             ...     for line in p._Graphics__objects
     1026            ...     for line in p._objects
    10271027            ...     if line.options()['legend_label'] is not None ]
    10281028            sage: len(lines)
    10291029            1
  • sage/geometry/polyhedron/base.py

    diff --git a/sage/geometry/polyhedron/base.py b/sage/geometry/polyhedron/base.py
    a b  
    25702570
    25712571            sage: p = Polyhedron([[1,2,],[1,1],[0,0]])
    25722572            sage: p_wireframe = p.render_wireframe()
    2573             sage: p_wireframe._Graphics__objects
     2573            sage: p_wireframe._objects
    25742574            [Line defined by 2 points, Line defined by 2 points, Line defined by 2 points]
    25752575        """
    25762576        proj = self.projection()
  • sage/geometry/polyhedron/plot.py

    diff --git a/sage/geometry/polyhedron/plot.py b/sage/geometry/polyhedron/plot.py
    a b  
    4747        sage: q1.show() + q2.show() + q3.show() + q4.show()
    4848        sage: from sage.geometry.polyhedron.plot import render_2d
    4949        sage: q = render_2d(p1.projection())
    50         sage: q._Graphics__objects
     50        sage: q._objects
    5151        [Point set defined by 1 point(s),
    5252         Arrow from (1.0,1.0) to (2.0,2.0),
    5353         Polygon defined by 3 points]
     
    850850            sage: hex = polytopes.regular_polygon(6)
    851851            sage: proj = hex.projection()
    852852            sage: hex_points = proj.render_points_2d()
    853             sage: hex_points._Graphics__objects
     853            sage: hex_points._objects
    854854            [Point set defined by 6 point(s)]
    855855        """
    856856        return point2d(self.coordinates_of(self.points), **kwds)
     
    864864
    865865            sage: penta = polytopes.regular_polygon(5)
    866866            sage: outline = penta.projection().render_outline_2d()
    867             sage: outline._Graphics__objects[0]
     867            sage: outline._objects[0]
    868868            Line defined by 2 points
    869869        """
    870870        wireframe = [];
  • sage/graphs/graph_list.py

    diff --git a/sage/graphs/graph_list.py b/sage/graphs/graph_list.py
    a b  
    319319        for j in range (rows*cols):
    320320            glist.append(plist[ i*rows*cols + j ])
    321321        ga = graphics_array(glist, rows, cols)
    322         ga.__set_figsize__([8,10])
     322        ga._set_figsize_([8,10])
    323323        g_arrays.append(ga)
    324324   
    325325    last = len(plist)%20
     
    332332    for i in range (last):
    333333        glist.append(plist[ i + index])
    334334    ga = graphics_array(glist, last_rows, cols)
    335     ga.__set_figsize__([8, 2*last_rows])
     335    ga._set_figsize_([8, 2*last_rows])
    336336    g_arrays.append(ga)
    337337   
    338338    return g_arrays
  • sage/plot/animate.py

    diff --git a/sage/plot/animate.py b/sage/plot/animate.py
    a b  
    7676    TESTS: This illustrates that ticket #2066 is fixed (setting axes
    7777    ranges when an endpoint is 0)::
    7878   
    79         sage: animate([plot(sin, -1,1)], xmin=0, ymin=0)._Animation__kwds['xmin']
     79        sage: animate([plot(sin, -1,1)], xmin=0, ymin=0)._kwds['xmin']
    8080        0
    8181       
    8282    We check that Trac #7981 is fixed::
     
    105105            w.append(x)
    106106        if len(w) == 0:
    107107            w = [sage.plot.graphics.Graphics()]
    108         self.__frames = w
    109         self.__kwds = kwds
     108        self._frames = w
     109        self._kwds = kwds
    110110
    111111    def _combine_kwds(self, *kwds_tuple):
    112112        """
     
    162162            sage: a[3:7].show() # optional -- ImageMagick
    163163        """
    164164        if isinstance(i, slice):
    165             return Animation(self.__frames[i], **self.__kwds)
     165            return Animation(self._frames[i], **self._kwds)
    166166        else:
    167             return self.__frames[i]
     167            return self._frames[i]
    168168
    169169    def _repr_(self):
    170170        """
     
    179179            sage: a._repr_()
    180180            'Animation with 10 frames'
    181181        """
    182         return "Animation with %s frames"%(len(self.__frames))
     182        return "Animation with %s frames"%(len(self._frames))
    183183
    184184    def __add__(self, other):
    185185        """
     
    202202        if not isinstance(other, Animation):
    203203            other = Animation(other)
    204204           
    205         kwds = self._combine_kwds(self.__kwds, other.__kwds)
     205        kwds = self._combine_kwds(self._kwds, other._kwds)
    206206
    207207        #Combine the frames
    208         m = max(len(self.__frames), len(other.__frames))
    209         frames = [a+b for a,b in zip(self.__frames, other.__frames)]
    210         frames += self.__frames[m:] + other.__frames[m:]
     208        m = max(len(self._frames), len(other._frames))
     209        frames = [a+b for a,b in zip(self._frames, other._frames)]
     210        frames += self._frames[m:] + other._frames[m:]
    211211               
    212212        return Animation(frames, **kwds)
    213213
     
    232232        if not isinstance(other, Animation):
    233233            other = Animation(other)
    234234
    235         kwds = self._combine_kwds(self.__kwds, other.__kwds)
     235        kwds = self._combine_kwds(self._kwds, other._kwds)
    236236       
    237         return Animation(self.__frames + other.__frames, **kwds)
     237        return Animation(self._frames + other._frames, **kwds)
    238238
    239239    def png(self, dir=None):
    240240        """
     
    249249            ['00000000.png', '00000001.png', '00000002.png', '00000003.png']
    250250        """
    251251        try:
    252             return self.__png_dir
     252            return self._png_dir
    253253        except AttributeError:
    254254            pass
    255255        d = sage.misc.misc.tmp_dir()
    256         G = self.__frames
    257         for i, frame in enumerate(self.__frames):
     256        G = self._frames
     257        for i, frame in enumerate(self._frames):
    258258            filename = '%s/%s'%(d,sage.misc.misc.pad_zeros(i,8))
    259             frame.save(filename + '.png', **self.__kwds)
    260         self.__png_dir = d
     259            frame.save(filename + '.png', **self._kwds)
     260        self._png_dir = d
    261261        return d
    262262
    263263    def graphics_array(self, ncols=3):
     
    288288            Graphics Array of size 2 x 2
    289289            sage: g.show('sage.png')         # optional
    290290        """
    291         n = len(self.__frames)
     291        n = len(self._frames)
    292292        ncols = int(ncols)
    293         return plot.graphics_array(self.__frames, int(n/ncols),  ncols)
     293        return plot.graphics_array(self._frames, int(n/ncols),  ncols)
    294294
    295295    def gif(self, delay=20, savefile=None, iterations=0, show_path=False,
    296296            use_ffmpeg=False):
  • sage/plot/colors.py

    diff --git a/sage/plot/colors.py b/sage/plot/colors.py
    a b  
    409409            RGB color (0.8235294117647058, 0.4117647058823529, 0.11764705882352941)
    410410        """
    411411        if g is None and b is None:
    412             self.__rgb = rgbcolor(r)
     412            self._rgb = rgbcolor(r)
    413413        else:
    414             self.__rgb = rgbcolor((r, g, b), space=space)
     414            self._rgb = rgbcolor((r, g, b), space=space)
    415415
    416416    def __repr__(self):
    417417        """
     
    428428            sage: Color(1, 0.5, 1/16, space='hsl').__repr__()
    429429            'RGB color (0.09375, 0.03125, 0.03125)'
    430430        """
    431         return "RGB color %s" % (self.__rgb, )
     431        return "RGB color %s" % (self._rgb, )
    432432
    433433    def __lt__(self, right):
    434434        """
     
    648648        """
    649649        fraction = float(fraction)
    650650        if isinstance(color, Color):
    651             color = color.__rgb
     651            color = color._rgb
    652652        if isinstance(color, (list, tuple)) and len(color) == 3:
    653653            color = map(float, color)
    654654            return Color(rgbcolor([(1 - fraction) * a + fraction * b
    655                                    for a, b in zip(self.__rgb, color)]))
     655                                   for a, b in zip(self._rgb, color)]))
    656656        raise TypeError("%s must be a Color or float-convertible 3-tuple/list" % (color, ))
    657657
    658658    def __add__(self, right):
     
    748748            RGB color (0.764705882352942, 0.1529411764705877, 0.1529411764705877)
    749749        """
    750750        right = float(right)
    751         return Color([x * right for x in self.__rgb])
     751        return Color([x * right for x in self._rgb])
    752752
    753753    def __rmul__(self, left):
    754754        """
     
    883883            sage: vector(maroon) == vector(Color(maroon)) == vector(Color('maroon'))
    884884            True
    885885        """
    886         return iter(self.__rgb)
     886        return iter(self._rgb)
    887887
    888888    def __getitem__(self, i):
    889889        """
     
    912912            ...
    913913            IndexError: tuple index out of range
    914914        """
    915         return self.__rgb[i]
     915        return self._rgb[i]
    916916
    917917    def rgb(self):
    918918        """
     
    937937            sage: Color(1, 0.7, 0.9, space='hsv').rgb()
    938938            (0.9, 0.2700000000000001, 0.2700000000000001)
    939939        """
    940         return self.__rgb
     940        return self._rgb
    941941
    942942    def hls(self):
    943943        """
     
    960960            sage: orchid.hls()
    961961            (0.8396226415094339, 0.6470588235294117, 0.5888888888888889)
    962962        """
    963         return tuple(map(float, rgb_to_hls(*self.__rgb)))
     963        return tuple(map(float, rgb_to_hls(*self._rgb)))
    964964
    965965    def hsl(self):
    966966        """
     
    981981            sage: Color('#aabbcc').hsl()
    982982            (0.5833333333333334, 0.25000000000000017, 0.7333333333333334)
    983983        """
    984         h, l, s = tuple(map(float, rgb_to_hls(*self.__rgb)))
     984        h, l, s = tuple(map(float, rgb_to_hls(*self._rgb)))
    985985        return (h, s, l)
    986986
    987987    def hsv(self):
     
    10031003            sage: Color('gray').hsv()
    10041004            (0.0, 0.0, 0.5019607843137255)
    10051005        """
    1006         return tuple(map(float, rgb_to_hsv(*self.__rgb)))
     1006        return tuple(map(float, rgb_to_hsv(*self._rgb)))
    10071007
    10081008    def html_color(self):
    10091009        """
     
    10251025            sage: honeydew.html_color()
    10261026            '#f0fff0'
    10271027        """
    1028         return float_to_html(*self.__rgb)
     1028        return float_to_html(*self._rgb)
    10291029
    10301030    def lighter(self, fraction=1.0/3.0):
    10311031        """
  • sage/plot/graphics.py

    diff --git a/sage/plot/graphics.py b/sage/plot/graphics.py
    a b  
    147147       
    148148            sage: G = Graphics()
    149149        """
    150         self.__fontsize = 10
    151         self.__show_axes = True
    152         self.__show_legend = False
    153         self.__legend_opts = {}
    154         self.__axes_color = (0, 0, 0)
    155         self.__axes_label_color = (0, 0, 0)
    156         self.__tick_label_color = (0, 0, 0)
    157         self.__axes_width = 0.8
    158         self.__objects = []
     150        self._axes_color = (0, 0, 0)
     151        self._axes_label_color = (0, 0, 0)
     152        self._axes_width = 0.8
     153        self._bbox_extra_artists = []
    159154        self._extra_kwds = {}
    160         self.__bbox_extra_artists = []
     155        self._fontsize = 10
     156        self._legend_opts = {}
     157        self._objects = []
     158        self._show_axes = True
     159        self._show_legend = False
     160        self._tick_label_color = (0, 0, 0)
    161161
    162162    def set_aspect_ratio(self, ratio):
    163163        """
     
    269269            sage: P # show with the legend
    270270        """
    271271        if show is None:
    272             return self.__show_legend
     272            return self._show_legend
    273273        else:
    274             self.__show_legend = bool(show)
     274            self._show_legend = bool(show)
    275275
    276276    def set_legend_options(self, **kwds):
    277277        r"""
     
    385385            sage: p.set_legend_options(loc=(0.5,0.5)); p # aligns the bottom of the box to the center
    386386        """
    387387        if len(kwds) == 0:
    388             return self.__legend_opts
     388            return self._legend_opts
    389389        else:
    390             self.__legend_opts.update(kwds)
     390            self._legend_opts.update(kwds)
    391391   
    392392
    393393    def get_axes_range(self):
     
    456456            {'xmin': -1.0}
    457457        """
    458458        try:
    459             return self.__axes_range
     459            return self._axes_range
    460460        except AttributeError:
    461             self.__axes_range = {}
    462             return self.__axes_range
     461            self._axes_range = {}
     462            return self._axes_range
    463463
    464464    def fontsize(self, s=None):
    465465        """
     
    488488        """
    489489        if s is None:
    490490            try:
    491                 return self.__fontsize
     491                return self._fontsize
    492492            except AttributeError:
    493                 self.__fontsize = 10
    494                 return self.__fontsize
    495         self.__fontsize = int(s)
     493                self._fontsize = 10
     494                return self._fontsize
     495        self._fontsize = int(s)
    496496
    497497    def axes(self, show=None):
    498498        """
     
    534534        """
    535535        if show is None:
    536536            try:
    537                 return self.__show_axes
     537                return self._show_axes
    538538            except AttributeError:
    539                 self.__show_axes = True
    540                 return self.__show_axes
    541         self.__show_axes = bool(show)
     539                self._show_axes = True
     540                return self._show_axes
     541        self._show_axes = bool(show)
    542542
    543543    def axes_color(self, c=None):
    544544        """
     
    579579        """
    580580        if c is None:
    581581            try:
    582                 return self.__axes_color
     582                return self._axes_color
    583583           
    584584            except AttributeError:
    585                 self.__axes_color = (0.0, 0.0, 0.0)
    586                 return self.__axes_color
    587         self.__axes_color = rgbcolor(c)
     585                self._axes_color = (0.0, 0.0, 0.0)
     586                return self._axes_color
     587        self._axes_color = rgbcolor(c)
    588588
    589589    def axes_labels(self, l=None):
    590590        """
     
    623623        """
    624624        if l is None:
    625625            try:
    626                 return self.__axes_labels
     626                return self._axes_labels
    627627            except AttributeError:
    628                 self.__axes_labels = None
    629                 return self.__axes_labels
     628                self._axes_labels = None
     629                return self._axes_labels
    630630        if not isinstance(l, (list, tuple)):
    631631            raise TypeError, "l must be a list or tuple"
    632632        if len(l) != 2:
    633633            raise ValueError, "l must have length 2"
    634         self.__axes_labels = (str(l[0]), str(l[1]))
     634        self._axes_labels = (str(l[0]), str(l[1]))
    635635
    636636    def axes_label_color(self, c=None):
    637637        r"""
     
    678678        """
    679679        if c is None:
    680680            try:
    681                 return self.__axes_label_color
     681                return self._axes_label_color
    682682            except AttributeError:
    683                 self.__axes_label_color = (0, 0, 0)
    684                 return self.__axes_label_color
    685         self.__axes_label_color = rgbcolor(c)
     683                self._axes_label_color = (0, 0, 0)
     684                return self._axes_label_color
     685        self._axes_label_color = rgbcolor(c)
    686686
    687687
    688688    def axes_width(self, w=None):
     
    719719        """
    720720        if w is None:
    721721            try:
    722                 return self.__axes_width
     722                return self._axes_width
    723723            except AttributeError:
    724                 self.__axes_width = True
    725                 return self.__axes_width
    726         self.__axes_width = float(w)
     724                self._axes_width = True
     725                return self._axes_width
     726        self._axes_width = float(w)
    727727
    728728    def tick_label_color(self, c=None):
    729729        """
     
    750750        """
    751751        if c is None:
    752752            try:
    753                 return self.__tick_label_color
     753                return self._tick_label_color
    754754            except AttributeError:
    755                 self.__tick_label_color = (0, 0, 0)
    756                 return self.__tick_label_color
    757         self.__tick_label_color = rgbcolor(c)
     755                self._tick_label_color = (0, 0, 0)
     756                return self._tick_label_color
     757        self._tick_label_color = rgbcolor(c)
    758758
    759759    def _repr_(self):
    760760        r"""
     
    863863            sage: G[1]
    864864            Circle defined by (2.0,2.0) with r=5.0
    865865        """
    866         return self.__objects[i]
     866        return self._objects[i]
    867867
    868868    def __len__(self):
    869869        """
     
    877877            sage: len(G)
    878878            3
    879879        """
    880         return len(self.__objects)
     880        return len(self._objects)
    881881
    882882    def __delitem__(self, i):
    883883        """
     
    896896            sage: len(G)
    897897            2
    898898        """
    899         del self.__objects[int(i)]
     899        del self._objects[int(i)]
    900900
    901901    def __setitem__(self, i, x):
    902902        """
     
    921921        from sage.plot.primitive import GraphicPrimitive
    922922        if not isinstance(x, GraphicPrimitive):
    923923            raise TypeError, "x must be a GraphicPrimitive"
    924         self.__objects[int(i)] = x
     924        self._objects[int(i)] = x
    925925
    926926    def __radd__(self, other):
    927927        """
     
    992992            sage: p1.set_legend_options(back_color = 'white')
    993993            sage: p2.set_legend_options(shadow = True)
    994994            sage: p3 = p1 + p2
    995             sage: p3._Graphics__legend_opts
     995            sage: p3._legend_opts
    996996            {'shadow': True, 'back_color': 'white'}
    997997
    998998        If the same legend option is specified more than once, the
     
    10031003            sage: p1.set_legend_options(shadow = True)
    10041004            sage: p2.set_legend_options(shadow = False)
    10051005            sage: p3 = p1 + p2
    1006             sage: p3._Graphics__legend_opts
     1006            sage: p3._legend_opts
    10071007            {'shadow': False}
    10081008
    10091009        """
     
    10151015                return self.plot3d() + other
    10161016            raise TypeError, "other (=%s) must be a Graphics objects"%other
    10171017        g = Graphics()
    1018         g.__objects = self.__objects + other.__objects
    1019         g.__show_legend = self.__show_legend or other.__show_legend
     1018        g._objects = self._objects + other._objects
     1019        g._show_legend = self._show_legend or other._show_legend
    10201020        g._extra_kwds.update(self._extra_kwds)
    10211021        g._extra_kwds.update(other._extra_kwds)
    1022         g._Graphics__legend_opts.update(self._Graphics__legend_opts)
    1023         g._Graphics__legend_opts.update(other._Graphics__legend_opts)
     1022        g._legend_opts.update(self._legend_opts)
     1023        g._legend_opts.update(other._legend_opts)
    10241024        if self.aspect_ratio()=='automatic':
    10251025            g.set_aspect_ratio(other.aspect_ratio())
    10261026        elif other.aspect_ratio()=='automatic':
     
    10461046            sage: G.add_primitive(A)
    10471047            sage: G
    10481048        """
    1049         self.__objects.append(primitive)
     1049        self._objects.append(primitive)
    10501050
    10511051    def plot(self, *args, **kwds):
    10521052        """
     
    10721072            sage: sum([plot(z*sin(x), 0, 10).plot3d(z) for z in range(6)]) # long time
    10731073        """
    10741074        from sage.plot.plot3d.base import Graphics3dGroup
    1075         g = Graphics3dGroup([g.plot3d(**kwds) for g in self.__objects])
     1075        g = Graphics3dGroup([g.plot3d(**kwds) for g in self._objects])
    10761076        if z:
    10771077            g = g.translate(0,0,z)
    10781078        return g
     
    11311131    # NOTE: If you intend to use a new parameter in show(), you should update
    11321132    # this dictionary to contain the default value for that parameter.
    11331133
    1134     SHOW_OPTIONS = dict(xmin=None, xmax=None, ymin=None, ymax=None,
    1135                         figsize=None, fig_tight=True,
    1136                         filename=None,
    1137                         dpi=DEFAULT_DPI, axes=None, axes_labels=None,frame=False,
    1138                         fontsize=None,
    1139                         aspect_ratio=None,
     1134    SHOW_OPTIONS = dict(filename=None,
     1135                        # axes options
     1136                        axes=None, axes_labels=None, axes_pad=.02,
     1137                        xmin=None, xmax=None, ymin=None, ymax=None,
     1138                        # Figure options
     1139                        aspect_ratio=None, dpi=DEFAULT_DPI, fig_tight=True,
     1140                        figsize=None, fontsize=None, frame=False,
     1141                        transparent=False,
     1142                        # Grid options
    11401143                        gridlines=None, gridlinesstyle=None,
    1141                         vgridlinesstyle=None, hgridlinesstyle=None,transparent=False,
    1142                         show_legend=None, legend_options={},
    1143                         axes_pad=.02, ticks_integer=False,
    1144                         ticks=None, tick_formatter=None)
     1144                        hgridlinesstyle=None, vgridlinesstyle=None,
     1145                        # Legend options
     1146                        legend_options={}, show_legend=None,
     1147                        # Ticks options
     1148                        ticks=None, tick_formatter=None, ticks_integer=False)
    11451149
    1146     @suboptions('legend', numpoints=2, borderpad=0.6, markerscale=0.6, shadow=False,
    1147                 labelspacing=0.02, handlelength=0.05, handletextpad=0.5, borderaxespad=None,
    1148                 loc='best', font_size='medium', font_family='sans-serif', font_style='normal',
    1149                 font_weight='medium', font_variant='normal', back_color=(0.9, 0.9, 0.9),
    1150                 title=None, ncol=1, columnspacing=None, fancybox=False)
     1150    @suboptions('legend',
     1151                back_color=(0.9, 0.9, 0.9), borderpad=0.6,
     1152                borderaxespad=None,
     1153                columnspacing=None,
     1154                fancybox=False, font_family='sans-serif',
     1155                font_size='medium', font_style='normal',
     1156                font_variant='normal', font_weight='medium',
     1157                handlelength=0.05, handletextpad=0.5,
     1158                labelspacing=0.02, loc='best',
     1159                markerscale=0.6, ncol=1, numpoints=2,
     1160                shadow=False, title=None)
    11511161    def show(self, **kwds):
    11521162        """
    11531163        Show this graphics image with the default image viewer.
     
    16061616            sage: list(sorted(g.get_minmax_data().items()))
    16071617            [('xmax', 3.0), ('xmin', -1.0), ('ymax', 2.0), ('ymin', 1.0)]
    16081618        """
    1609         objects = self.__objects
     1619        objects = self._objects
    16101620        if objects:
    16111621            minmax_data = [o.get_minmax_data() for o in objects]
    16121622            xmin = min(d['xmin'] for d in minmax_data)
     
    16331643            ymin -= 1
    16341644            ymax += 1
    16351645        return {'xmin':xmin, 'xmax':xmax, 'ymin':ymin, 'ymax':ymax}
    1636        
     1646
     1647    def _matplotlib_tick_formatter(self, subplot, locator_options={},
     1648                            tick_formatter=(None, None), ticks=(None, None),
     1649                            xmax=None, xmin=None, ymax=None, ymin=None):
     1650        r"""
     1651        Take a matplotlib subplot instance representing the graphic and set
     1652        the ticks formatting. This function is only for internal use.
     1653
     1654        INPUT:
     1655        - ``subplot`` -- the subplot instance.
     1656
     1657        EXAMPLES::
     1658
     1659            sage: from matplotlib.figure import Figure
     1660            sage: p = plot(x); d = p.get_minmax_data()
     1661            sage: subplot = Figure().add_subplot(111)
     1662            sage: p._objects[0]._render_on_subplot(subplot)
     1663            sage: p._matplotlib_tick_formatter(subplot, **d)
     1664            (<matplotlib.axes.AxesSubplot object at ...>,
     1665            <matplotlib.ticker.MaxNLocator instance at ...>,
     1666            <matplotlib.ticker.MaxNLocator instance at ...>,
     1667            <matplotlib.ticker.OldScalarFormatter instance at ...>,
     1668            <matplotlib.ticker.OldScalarFormatter instance at ...>)
     1669        """
     1670        # This function is created to refactor some code that is repeated
     1671        # in the matplotlib function
     1672        from matplotlib.ticker import (FixedLocator, Locator, MaxNLocator,
     1673                MultipleLocator, NullLocator, OldScalarFormatter)
     1674
     1675        x_locator, y_locator = ticks
     1676        #---------------------- Location of x-ticks ---------------------#
     1677        if x_locator is None:
     1678            x_locator = MaxNLocator(**locator_options)
     1679        elif isinstance(x_locator,Locator):
     1680            pass
     1681        elif x_locator == []:
     1682            x_locator = NullLocator()
     1683        elif isinstance(x_locator,list):
     1684            x_locator = FixedLocator(x_locator)
     1685        else: # x_locator is a number which can be made a float
     1686            from sage.functions.other import ceil, floor
     1687            if floor(xmax/x_locator)-ceil(xmin/x_locator)>1:
     1688                x_locator=MultipleLocator(float(x_locator))
     1689            else: # not enough room for two major ticks
     1690                raise ValueError('Expand the range of the independent '
     1691                'variable to allow two multiples of your tick locator '
     1692                '(option `ticks`).')
     1693
     1694        #---------------------- Location of y-ticks ---------------------#
     1695        if y_locator is None:
     1696            y_locator = MaxNLocator(**locator_options)
     1697        elif isinstance(y_locator,Locator):
     1698            pass
     1699        elif y_locator == []:
     1700            y_locator = NullLocator()
     1701        elif isinstance(y_locator,list):
     1702            y_locator = FixedLocator(y_locator)
     1703        else: # y_locator is a number which can be made a float
     1704            from sage.functions.other import ceil, floor
     1705            if floor(ymax/y_locator)-ceil(ymin/y_locator)>1:
     1706                y_locator=MultipleLocator(float(y_locator))
     1707            else: # not enough room for two major ticks
     1708                raise ValueError('Expand the range of the dependent '
     1709                'variable to allow two multiples of your tick locator '
     1710                '(option `ticks`).')
     1711
     1712        x_formatter, y_formatter = tick_formatter
     1713        from matplotlib.ticker import FuncFormatter
     1714        from sage.misc.latex import latex
     1715        from sage.symbolic.ring import SR
     1716        #---------------------- Formatting x-ticks ----------------------#
     1717        if x_formatter is None:
     1718            x_formatter = OldScalarFormatter()
     1719        elif x_formatter in SR:
     1720            from misc import _multiple_of_constant
     1721            x_const = x_formatter
     1722            x_formatter = FuncFormatter(lambda n,pos:
     1723                                        _multiple_of_constant(n,pos,x_const))
     1724        elif x_formatter == "latex":
     1725            x_formatter = FuncFormatter(lambda n,pos: '$%s$'%latex(n))
     1726        #---------------------- Formatting y-ticks ----------------------#
     1727        if y_formatter is None:
     1728            y_formatter = OldScalarFormatter()
     1729        elif y_formatter in SR:
     1730            from misc import _multiple_of_constant
     1731            y_const = y_formatter
     1732            y_formatter = FuncFormatter(lambda n,pos:
     1733                                        _multiple_of_constant(n,pos,y_const))
     1734        elif y_formatter == "latex":
     1735            y_formatter = FuncFormatter(lambda n,pos: '$%s$'%latex(n))
     1736
     1737        subplot.xaxis.set_major_locator(x_locator)
     1738        subplot.yaxis.set_major_locator(y_locator)
     1739        subplot.xaxis.set_major_formatter(x_formatter)
     1740        subplot.yaxis.set_major_formatter(y_formatter)
     1741
     1742        return (subplot, x_locator, y_locator, x_formatter, y_formatter)
     1743
    16371744    def matplotlib(self, filename=None,
    16381745                   xmin=None, xmax=None, ymin=None, ymax=None,
    16391746                   figsize=None, figure=None, sub=None,
     
    17171824        do_verify = verify
    17181825
    17191826        if axes is None:
    1720             axes = self.__show_axes
     1827            axes = self._show_axes
    17211828
    17221829        from matplotlib.figure import Figure
    17231830        from matplotlib import rcParams
     
    17421849        else:
    17431850            subplot.set_aspect(aspect_ratio, adjustable='box')
    17441851        #add all the primitives to the subplot
    1745         for g in self.__objects:
     1852        for g in self._objects:
    17461853            g._render_on_subplot(subplot)
    17471854            if hasattr(g, '_bbox_extra_artists'):
    1748                 self.__bbox_extra_artists.extend(g._bbox_extra_artists)
     1855                self._bbox_extra_artists.extend(g._bbox_extra_artists)
    17491856       
    17501857        #add the legend if requested
    17511858        if show_legend is None:
    1752             show_legend = self.__show_legend
     1859            show_legend = self._show_legend
    17531860       
    17541861        if show_legend:
    17551862            from matplotlib.font_manager import FontProperties
    17561863            lopts = dict()
    17571864            lopts.update(legend_options)
    1758             lopts.update(self.__legend_opts)
     1865            lopts.update(self._legend_opts)
    17591866            prop = FontProperties(
    17601867                    family  = lopts.pop('font_family', 'sans-serif'),
    17611868                    size    = lopts.pop('font_size', 'medium'),
     
    17801887
    17811888
    17821889        if axes is None:
    1783             axes = self.__show_axes
     1890            axes = self._show_axes
    17841891
    17851892        for spine in subplot.spines.values():
    1786             spine.set_color(self.__axes_color)
    1787             spine.set_linewidth(self.__axes_width)
     1893            spine.set_color(self._axes_color)
     1894            spine.set_linewidth(self._axes_width)
    17881895       
    17891896
    17901897        if frame:
     
    17921899            # sort of what we are used to.  We should eventually look at
    17931900            # the default one to see if we like it better.
    17941901
    1795             from matplotlib.ticker import OldScalarFormatter, MaxNLocator, MultipleLocator, FixedLocator, NullLocator, Locator
    1796             x_locator, y_locator = ticks
    1797             if x_locator is None:
    1798                 x_locator = MaxNLocator(**locator_options)
    1799             elif isinstance(x_locator,Locator):
    1800                 pass
    1801             elif x_locator == []:
    1802                 x_locator = NullLocator()
    1803             elif isinstance(x_locator,list):
    1804                 x_locator = FixedLocator(x_locator)
    1805             else: # x_locator is a number which can be made a float
    1806                 from sage.functions.other import ceil, floor
    1807                 if floor(xmax/x_locator)-ceil(xmin/x_locator)>1:
    1808                     x_locator=MultipleLocator(float(x_locator))
    1809                 else: # not enough room for two major ticks
    1810                     raise ValueError('Expand the range of the independent variable to allow two multiples of your tick locator (option `ticks`).')
    1811             if y_locator is None:
    1812                 y_locator = MaxNLocator(**locator_options)
    1813             elif isinstance(y_locator,Locator):
    1814                 pass
    1815             elif y_locator == []:
    1816                 y_locator = NullLocator()
    1817             elif isinstance(y_locator,list):
    1818                 y_locator = FixedLocator(y_locator)
    1819             else: # y_locator is a number which can be made a float
    1820                 from sage.functions.other import ceil, floor
    1821                 if floor(ymax/y_locator)-ceil(ymin/y_locator)>1:
    1822                     y_locator=MultipleLocator(float(y_locator))
    1823                 else: # not enough room for two major ticks
    1824                     raise ValueError('Expand the range of the dependent variable to allow two multiples of your tick locator (option `ticks`).')
    1825 
    1826             x_formatter, y_formatter = tick_formatter
    1827             from matplotlib.ticker import FuncFormatter
    1828             from sage.misc.latex import latex
    1829             if x_formatter is None:
    1830                 x_formatter = OldScalarFormatter()
    1831             elif x_formatter in SR:
    1832                 from misc import _multiple_of_constant
    1833                 x_const = x_formatter
    1834                 x_formatter = FuncFormatter(lambda n,pos: _multiple_of_constant(n,pos,x_const))
    1835             elif x_formatter == "latex":
    1836                 x_formatter = FuncFormatter(lambda n,pos: '$%s$'%latex(n))
    1837             if y_formatter is None:
    1838                 y_formatter = OldScalarFormatter()
    1839             elif y_formatter in SR:
    1840                 from misc import _multiple_of_constant
    1841                 y_const = y_formatter
    1842                 y_formatter = FuncFormatter(lambda n,pos: _multiple_of_constant(n,pos,y_const))
    1843             elif y_formatter == "latex":
    1844                 y_formatter = FuncFormatter(lambda n,pos: '$%s$'%latex(n))
    1845 
    1846             subplot.xaxis.set_major_locator(x_locator)
    1847             subplot.yaxis.set_major_locator(y_locator)
    1848             subplot.xaxis.set_major_formatter(x_formatter)
    1849             subplot.yaxis.set_major_formatter(y_formatter)
     1902            (subplot, x_locator, y_locator,
     1903                    x_formatter, y_formatter) = self._matplotlib_tick_formatter(
     1904                            subplot, locator_options=locator_options,
     1905                            tick_formatter=tick_formatter, ticks=ticks,
     1906                            xmax=xmax, xmin=xmin, ymax=ymax, ymin=ymin)
    18501907           
    18511908            subplot.set_frame_on(True)
    18521909            if axes:
    18531910                if ymin<=0 and ymax>=0:
    1854                     subplot.axhline(color=self.__axes_color,
    1855                                     linewidth=self.__axes_width)
     1911                    subplot.axhline(color=self._axes_color,
     1912                                    linewidth=self._axes_width)
    18561913                if xmin<=0 and xmax>=0:
    1857                     subplot.axvline(color=self.__axes_color,
    1858                                     linewidth=self.__axes_width)
     1914                    subplot.axvline(color=self._axes_color,
     1915                                    linewidth=self._axes_width)
    18591916           
    18601917        elif axes:
    18611918            ymiddle=False
     
    19031960            # For now, set the formatter to the old one, since that is
    19041961            # sort of what we are used to.  We should eventually look at
    19051962            # the default one to see if we like it better.
     1963
     1964            (subplot, x_locator, y_locator,
     1965                    x_formatter, y_formatter) = self._matplotlib_tick_formatter(
     1966                            subplot, locator_options=locator_options,
     1967                            tick_formatter=tick_formatter, ticks=ticks,
     1968                            xmax=xmax, xmin=xmin, ymax=ymax, ymin=ymin)
    19061969           
    1907             from matplotlib.ticker import OldScalarFormatter, MaxNLocator, MultipleLocator, FixedLocator, NullLocator, Locator
    1908             x_locator, y_locator = ticks
    1909             if x_locator is None:
    1910                 x_locator = MaxNLocator(**locator_options)
    1911             elif isinstance(x_locator,Locator):
    1912                 pass
    1913             elif x_locator == []:
    1914                 x_locator = NullLocator()
    1915             elif isinstance(x_locator,list):
    1916                 x_locator = FixedLocator(x_locator)
    1917             else: # x_locator is a number which can be made a float
    1918                 from sage.functions.other import ceil, floor
    1919                 if floor(xmax/x_locator)-ceil(xmin/x_locator)>1:
    1920                     x_locator=MultipleLocator(float(x_locator))
    1921                 else: # not enough room for two major ticks
    1922                     raise ValueError('Expand the range of the independent variable to allow two multiples of your tick locator (option `ticks`).')
    1923             if y_locator is None:
    1924                 y_locator = MaxNLocator(**locator_options)
    1925             elif isinstance(y_locator,Locator):
    1926                 pass
    1927             elif y_locator == []:
    1928                 y_locator = NullLocator()
    1929             elif isinstance(y_locator,list):
    1930                 y_locator = FixedLocator(y_locator)
    1931             else: # y_locator is a number which can be made a float
    1932                 from sage.functions.other import ceil, floor
    1933                 if floor(ymax/y_locator)-ceil(ymin/y_locator)>1:
    1934                     y_locator=MultipleLocator(float(y_locator))
    1935                 else: # not enough room for two major ticks
    1936                     raise ValueError('Expand the range of the dependent variable to allow two multiples of your tick locator (option `ticks`).')
    1937 
    1938             x_formatter, y_formatter = tick_formatter
    1939             from matplotlib.ticker import FuncFormatter
    1940             from sage.misc.latex import latex
    1941             from sage.symbolic.ring import SR
    1942             if x_formatter is None:
    1943                 x_formatter = OldScalarFormatter()
    1944             elif x_formatter in SR:
    1945                 from misc import _multiple_of_constant
    1946                 x_const = x_formatter
    1947                 x_formatter = FuncFormatter(lambda n,pos: _multiple_of_constant(n,pos,x_const))
    1948             elif x_formatter == "latex":
    1949                 x_formatter = FuncFormatter(lambda n,pos: '$%s$'%latex(n))
    1950             if y_formatter is None:
    1951                 y_formatter = OldScalarFormatter()
    1952             elif y_formatter in SR:
    1953                 from misc import _multiple_of_constant
    1954                 y_const = y_formatter
    1955                 y_formatter = FuncFormatter(lambda n,pos: _multiple_of_constant(n,pos,y_const))
    1956             elif y_formatter == "latex":
    1957                 y_formatter = FuncFormatter(lambda n,pos: '$%s$'%latex(n))
    1958 
    1959             subplot.xaxis.set_major_locator(x_locator)
    1960             subplot.yaxis.set_major_locator(y_locator)
    1961             subplot.xaxis.set_major_formatter(x_formatter)
    1962             subplot.yaxis.set_major_formatter(y_formatter)
    1963 
    19641970            # Make ticklines go on both sides of the axes
    19651971            #             if xmiddle:
    19661972            #                 for t in subplot.xaxis.get_majorticklines():
     
    19821988            # inside the picture
    19831989            if xmiddle and ymiddle:
    19841990                from sage.plot.plot import SelectiveFormatter
    1985                 subplot.yaxis.set_major_formatter(SelectiveFormatter(subplot.yaxis.get_major_formatter(),skip_values=[0]))
    1986                 subplot.xaxis.set_major_formatter(SelectiveFormatter(subplot.xaxis.get_major_formatter(),skip_values=[0]))
     1991                subplot.yaxis.set_major_formatter(SelectiveFormatter(
     1992                    subplot.yaxis.get_major_formatter(),skip_values=[0]))
     1993                subplot.xaxis.set_major_formatter(SelectiveFormatter(
     1994                    subplot.xaxis.get_major_formatter(),skip_values=[0]))
    19871995
    19881996        else:
    19891997            for spine in subplot.spines.values():
     
    20112019                subplot.yaxis.get_majorticklabels() + \
    20122020                subplot.yaxis.get_minorticklabels()
    20132021            for ticklabel in ticklabels:
    2014                 ticklabel.set_fontsize(self.__fontsize)
    2015                 ticklabel.set_color(self.__tick_label_color)
     2022                ticklabel.set_fontsize(self._fontsize)
     2023                ticklabel.set_color(self._tick_label_color)
    20162024
    20172025            ticklines=subplot.xaxis.get_majorticklines() + \
    20182026                subplot.xaxis.get_minorticklines() + \
    20192027                subplot.yaxis.get_majorticklines() + \
    20202028                subplot.yaxis.get_minorticklines()
    20212029            for tickline in ticklines:
    2022                 tickline.set_color(self.__axes_color)
     2030                tickline.set_color(self._axes_color)
    20232031               
    20242032           
    20252033        if gridlines is not None:
     
    20802088
    20812089
    20822090
    2083         if self.__axes_labels is not None:
     2091        if self._axes_labels is not None:
    20842092            label_options={}
    2085             label_options['color']=self.__axes_label_color
    2086             label_options['size']=self.__fontsize
    2087             subplot.set_xlabel(self.__axes_labels[0], **label_options)
    2088             subplot.set_ylabel(self.__axes_labels[1], **label_options)
     2093            label_options['color']=self._axes_label_color
     2094            label_options['size']=self._fontsize
     2095            subplot.set_xlabel(self._axes_labels[0], **label_options)
     2096            subplot.set_ylabel(self._axes_labels[1], **label_options)
    20892097               
    20902098
    20912099            if axes is True and frame is False:
     
    21202128                xlabel.set_horizontalalignment(xaxis_horiz)
    21212129                xlabel.set_verticalalignment(xaxis_vert)
    21222130                trans=subplot.spines[xaxis].get_transform()
    2123                 labeltrans=offset_copy(trans, figure, x=xaxis_labeloffset, y=0, units='points')
    2124                 subplot.xaxis.set_label_coords(x=xaxis_labelx,y=xaxis_labely,transform=labeltrans)
     2131                labeltrans=offset_copy(trans, figure, x=xaxis_labeloffset,
     2132                                    y=0, units='points')
     2133                subplot.xaxis.set_label_coords(x=xaxis_labelx,
     2134                                    y=xaxis_labely, transform=labeltrans)
    21252135
    21262136                ylabel=subplot.yaxis.get_label()
    21272137                ylabel.set_horizontalalignment('center')
    21282138                ylabel.set_verticalalignment(yaxis_vert)
    21292139                ylabel.set_rotation('horizontal')
    21302140                trans=subplot.spines[yaxis].get_transform()
    2131                 labeltrans=offset_copy(trans, figure, x=0, y=yaxis_labeloffset, units='points')
    2132                 subplot.yaxis.set_label_coords(x=yaxis_labelx,y=yaxis_labely,transform=labeltrans)
     2141                labeltrans=offset_copy(trans, figure, x=0,
     2142                                    y=yaxis_labeloffset, units='points')
     2143                subplot.yaxis.set_label_coords(x=yaxis_labelx,
     2144                                    y=yaxis_labely, transform=labeltrans)
    21332145
    21342146        # This option makes the xlim and ylim limits not take effect
    21352147        # todo: figure out which limits were specified, and let the
     
    21402152    # ALLOWED_EXTENSIONS is the list of recognized formats.
    21412153    # filename argument is written explicitly so that it can be used as a
    21422154    # positional one, which is a very likely usage for this function.
    2143     @suboptions('legend', numpoints=2, borderpad=0.6, markerscale=0.6, shadow=False,
    2144                 labelspacing=0.02, handlelength=0.05, handletextpad=0.5, borderaxespad=None,
    2145                 loc='best', font_size='medium', font_family='sans-serif', font_style='normal',
    2146                 font_weight='medium', font_variant='normal', back_color=(0.9, 0.9, 0.9),
    2147                 title=None, ncol=1, columnspacing=None, fancybox=False)
     2155    @suboptions('legend',
     2156                back_color=(0.9, 0.9, 0.9), borderpad=0.6,
     2157                borderaxespad=None,
     2158                columnspacing=None,
     2159                fancybox=False, font_family='sans-serif',
     2160                font_size='medium', font_style='normal',
     2161                font_variant='normal', font_weight='medium',
     2162                handlelength=0.05, handletextpad=0.5,
     2163                labelspacing=0.02, loc='best',
     2164                markerscale=0.6, ncol=1, numpoints=2,
     2165                shadow=False, title=None)
    21482166    def save(self, filename=None, **kwds):
    21492167        r"""
    21502168        Save the graphics to an image file.
     
    22452263            SageObject.save(self, filename)
    22462264        else:
    22472265            figure = self.matplotlib(**options)
    2248             # You can output in PNG, PS, EPS, PDF, or SVG format, depending on the file extension.
     2266            # You can output in PNG, PS, EPS, PDF, or SVG format, depending
     2267            # on the file extension.
    22492268            # matplotlib looks at the file extension to see what the renderer should be.
    22502269            # The default is FigureCanvasAgg for PNG's because this is by far the most
    22512270            # common type of files rendered, like in the notebook, for example.
     
    22602279
    22612280            if fig_tight is True:
    22622281                figure.savefig(filename, dpi=dpi, bbox_inches='tight',
    2263                     bbox_extra_artists=self.__bbox_extra_artists,
     2282                    bbox_extra_artists=self._bbox_extra_artists,
    22642283                    transparent=transparent)
    22652284            else:
    22662285                figure.savefig(filename, dpi=dpi,
     
    24652484        i = int(i)
    24662485        self._glist[i] = g
    24672486       
    2468     def __set_figsize__(self, ls):
     2487    def _set_figsize_(self, ls):
    24692488        """
    24702489        Set the figsize of all plots in the array.
    24712490
     
    25882607            sage: G = graphics_array(L)
    25892608            sage: G.save(F,500,axes=False)  # long time (6s on sage.math, 2012)
    25902609        """
    2591         if (figsize is not None): self.__set_figsize__(figsize)
     2610        if (figsize is not None): self._set_figsize_(figsize)
    25922611        self._render(filename, dpi=dpi, figsize=self._figsize, axes = axes, **args)
    25932612
    25942613    def show(self, filename=None, dpi=DEFAULT_DPI, figsize=None,
     
    26192638            sage: G = graphics_array([[plot(sin), plot(cos)], [plot(tan), plot(sec)]])
    26202639            sage: G.show(axes=False)
    26212640        """
    2622         if (figsize is not None): self.__set_figsize__(figsize)
     2641        if (figsize is not None): self._set_figsize_(figsize)
    26232642        if sage.plot.plot.DOCTEST_MODE:
    26242643            self.save(DOCTEST_MODE_FILE,
    26252644                      dpi=dpi, figsize=self._figsize, axes = axes, **args)
  • sage/plot/primitive.py

    diff --git a/sage/plot/primitive.py b/sage/plot/primitive.py
    a b  
    4848            sage: GraphicPrimitive({})
    4949            Graphics primitive
    5050        """
    51         self.__options = options
     51        self._options = options
    5252       
    5353    def _allowed_options(self):
    5454        """
     
    133133            sage: q.options()['zorder']
    134134            3
    135135        """
    136         self.__options['zorder'] = zorder
     136        self._options['zorder'] = zorder
    137137       
    138138    def options(self):
    139139        """
     
    150150        """
    151151        from sage.plot.graphics import do_verify
    152152        from sage.plot.colors import hue
    153         O = dict(self.__options)
     153        O = dict(self._options)
    154154        if do_verify:
    155155            A = self._allowed_options()
    156156            t = False
  • sage/rings/padics/padic_base_generic.py

    diff --git a/sage/rings/padics/padic_base_generic.py b/sage/rings/padics/padic_base_generic.py
    a b  
    365365            all.append(tuple(p))
    366366        g = points(all, **args)
    367367        # Set default plotting options
    368         g._Graphics__show_axes = False
    369         g._Graphics__aspect_ratio = 1
     368        g.axes(False)
     369        g.set_aspect_ratio(1)
    370370        return g