added xlim kwarg patch

svn path=/trunk/matplotlib/; revision=1161

Author: jdh2358

API_CHANGES

@@ -1,3 +1,10 @@
+API CHANGES in matplotlib-0.75
+
+  xlim/ylim/axis always return the new limits regardless of arguments.
+  They now take kwargs which allow you to selectively change the upper
+  or lower limits while leaving unnamed limits unchanged.  See
+  help(xlim) for example
+
 API CHANGES in matplotlib-0.73
 
   Removed deprecated ColormapJet and friends

CHANGELOG

@@ -1,5 +1,11 @@
 New entries should be added at the top
 
+2005-04-11 Applied a variant of rick's xlim/ylim/axis patch.  These
+           functions now take kwargs to let you selectively alter only
+           the min or max if desired.  Eg xlim(xmin=2) or
+           axis(ymax=3).  They always return the new lim
+
+
 2005-04-11 Incorporated Werner's wx patch -- wx backend should be
            compatible with wxpython2.4 and recent versions of 2.5.
            Some early versions of wxpython 2.5 will not work because

lib/matplotlib/axes.py

@@ -1,4 +1,3 @@
-
 from __future__ import division, generators
 
 import math, sys
@@ -2892,22 +2891,55 @@ def _send_ylim_event(self):
             func(self)
 
 
-    def set_xlim(self, v, emit=True):
+    def set_xlim(self, *args, **kwargs):    
         """
-        SET_XLIM(v, emit=True)
+        set_xlim(self, *args, **kwargs):
 
         Set the limits for the xaxis; v = [xmin, xmax]
+        
+        set_xlim((valmin, valmax))
+        set_xlim(valmin, valmax)
+        set_xlim(xmin=1) # xmax unchanged
+        set_xlim(xmax=1) # xmin unchanged
+
+        Valid kwargs:
 
-        If emit is false, do not trigger an event
+        xmin : the min of the xlim
+        xmax : the max of the xlim        
+        emit : notify observers of lim change
+        
+
+        Returns the current xlimits as a length 2 tuple
 
         ACCEPTS: len(2) sequence of floats
         """
-        vmin, vmax = v
+        
+        vmin, vmax = self.get_xlim()
+
+        xmin = popd(kwargs, 'xmin', None)
+        xmax = popd(kwargs, 'xmax', None)
+        emit = popd(kwargs, 'emit', False)                
+        if len(args)!=0 and (xmin is not None or xmax is not None):
+            raise TypeError('You cannot pass args and xmin/xmax kwargs')
+
+        if len(args)==0:
+            if xmin is not None: vmin = xmin
+            if xmax is not None: vmax = xmax
+        elif len(args)==1:
+            vmin, vmax = args[0]
+        elif len(args)==2:
+            vmin, vmax = args
+        else:
+            raise ValueError('args must be length 0, 1 or 2')
+        
+            
+        
         if self.transData.get_funcx().get_type()==LOG10 and min(vmin, vmax)<=0:
             raise ValueError('Cannot set nonpositive limits with log transform')
-        self.viewLim.intervalx().set_bounds(*v)
+        
+        self.viewLim.intervalx().set_bounds(vmin, vmax)
         if emit: self._send_xlim_event()
-
+        return vmin, vmax
 
     def set_xscale(self, value, basex = 10, subsx=None):
         """
@@ -2980,20 +3012,56 @@ def set_ylabel(self, ylabel, fontdict=None, **kwargs):
         label.update(kwargs)
         return label
 
-    def set_ylim(self, v, emit=True):
+
+    def set_ylim(self, *args, **kwargs):    
         """
-        SET_YLIM(v, emit=True)
+        set_ylim(self, *args, **kwargs):
+
+        Set the limits for the yaxis; v = [ymin, ymax]
+        
+        set_ylim((valmin, valmax))
+        set_ylim(valmin, valmax)
+        set_ylim(ymin=1) # ymax unchanged
+        set_ylim(ymax=1) # ymin unchanged
 
-        Set the limits for the xaxis; v = [ymin, ymax].  If emit is false, do
-        not trigger an event.
+        Valid kwargs:
+
+        ymin : the min of the ylim
+        ymax : the max of the ylim        
+        emit : notify observers of lim change
+        
+
+        Returns the current ylimits as a length 2 tuple
 
         ACCEPTS: len(2) sequence of floats
         """
-        vmin, vmax = v
+        
+        vmin, vmax = self.get_ylim()
+
+        ymin = popd(kwargs, 'ymin', None)
+        ymax = popd(kwargs, 'ymax', None)
+        emit = popd(kwargs, 'emit', False)                
+        if len(args)!=0 and (ymin is not None or ymax is not None):
+            raise TypeError('You cannot pass args and ymin/ymax kwargs')
+
+        if len(args)==0:
+            if ymin is not None: vmin = ymin
+            if ymax is not None: vmax = ymax
+        elif len(args)==1:
+            vmin, vmax = args[0]
+        elif len(args)==2:
+            vmin, vmax = args
+        else:
+            raise ValueError('args must be length 0, 1 or 2')
+        
+            
+        
         if self.transData.get_funcy().get_type()==LOG10 and min(vmin, vmax)<=0:
             raise ValueError('Cannot set nonpositive limits with log transform')
-        self.viewLim.intervaly().set_bounds(*v)
+        
+        self.viewLim.intervaly().set_bounds(vmin, vmax)
         if emit: self._send_ylim_event()
+        return vmin, vmax
 
     def set_yscale(self, value, basey=10, subsy=None):
         """

lib/matplotlib/backends/backend_wx.py

@@ -690,7 +690,7 @@ def __init__(self, parent, id, figure):
         l,b,w,h = figure.bbox.get_bounds()
         w = int(math.ceil(w))
         h = int(math.ceil(h))
-
+ 
         wx.Panel.__init__(self, parent, id, size=wx.Size(w, h))
         # Create the drawing bitmap
         self.bitmap =wx.EmptyBitmap(w, h)

lib/matplotlib/pylab.py

@@ -484,7 +484,7 @@ def raise_msg_to_str(msg):
 
 
 
-def axis(*v):
+def axis(*v, **kwargs):
     """
     Set/Get the axis properties::
 
@@ -498,6 +498,13 @@ def axis(*v):
         axis('equal') sets the xlim width and ylim height to be to be
             identical.  The longer of the two intervals is chosen
 
+
+       if len(*v)==0, you can pass in xmin, xmax, ymin, ymax as kwargs
+       selectively to alter just those limits w/o changing the others.
+       See help(xlim) and help(ylim) for more information
+
+       The xmin, xmax, ymin, ymax tuple is returned
+
     """
 
     if len(v)==1 and is_string_like(v[0]):
@@ -520,21 +527,28 @@ def axis(*v):
 
         else:
             raise ValueError('Unrecognized string %s to axis; try on or off' % s)
-        return
+        ax  = gca()
+        xmin, xmax = ax.get_xlim() 
+        ymin, ymax = ax.get_ylim()
+        draw_if_interactive()
+        return xmin, xmax, ymin, ymax
 
     try: v[0]
     except IndexError:
-        xlim = gca().get_xlim()
-        ylim = gca().get_ylim()
-        return [xlim[0], xlim[1], ylim[0], ylim[1]]
+        xmin, xmax = gca().set_xlim(**kwargs)
+        ymin, ymax = gca().set_ylim(**kwargs)
+        draw_if_interactive()
+        return [xmin, xmax, ymin, ymax]
 
     v = v[0]
     if len(v) != 4:
         raise ValueError('v must contain [xmin xmax ymin ymax]')
-
+    
+    
     gca().set_xlim([v[0], v[1]])
     gca().set_ylim([v[2], v[3]])
     draw_if_interactive()
+    return v
 
 def axes(*args, **kwargs):
     """
@@ -1099,14 +1113,21 @@ def xlim(*args, **kwargs):
     xmin, xmax = xlim()   : return the current xlim
     xlim( (xmin, xmax) )  : set the xlim to xmin, xmax
     xlim( xmin, xmax )    : set the xlim to xmin, xmax
+
+    If you do not specify args, you can pass the xmin and xmax as
+    kwargs, eg
+
+      xlim(xmax=3) # adjust the max leaving min unchanged
+      xlim(xmin=1) # adjust the min leaving max unchanged
+
+    The new axis limits are returned as a length 2 tuple
+
     """
     ax = gca()
-    if len(args)==0: return ax.get_xlim()
-    elif len(args)==1: lim = ax.set_xlim(args)
-    elif len(args)==2: lim = ax.set_xlim((args[0], args[1]))
-    else: raise TypeError('Illegal number of arguments to xlim')
+    ret = ax.set_xlim(*args, **kwargs)
     draw_if_interactive()
-    return lim
+    return ret
+
 
 def ylim(*args, **kwargs):
     """
@@ -1115,14 +1136,23 @@ def ylim(*args, **kwargs):
     ymin, ymax = ylim()   : return the current ylim
     ylim( (ymin, ymax) )  : set the ylim to ymin, ymax
     ylim( ymin, ymax )    : set the ylim to ymin, ymax
+
+    If you do not specify args, you can pass the ymin and ymax as
+    kwargs, eg
+
+      ylim(ymax=3) # adjust the max leaving min unchanged
+      ylim(ymin=1) # adjust the min leaving max unchanged
+
+    The new axis limits are returned as a length 2 tuple
+
     """
     ax = gca()
-    if len(args)==0: return ax.get_ylim()
-    elif len(args)==1: lim = ax.set_ylim(args)
-    elif len(args)==2: lim = ax.set_ylim((args[0], args[1]))
-    else: raise TypeError('Illegal number of arguments to ylim')
+    ret = ax.set_ylim(*args, **kwargs)
     draw_if_interactive()
-    return lim
+    return ret
+
+
+
 
 def xticks(*args, **kwargs):
     """