Merged revisions 7475-7477,7480,7482 via svnmerge from

efiring · efiring · commit b2bf68e0dce8 · 2009-08-14T00:49:02.000Z
https://matplotlib.svn.sourceforge.net/svnroot/matplotlib/branches/v0_99_maint ........ r7475 | jdh2358 | 2009-08-11 14:26:50 -1000 (Tue, 11 Aug 2009) | 1 line update the contributing faq ........ r7476 | jdh2358 | 2009-08-12 01:37:13 -1000 (Wed, 12 Aug 2009) | 1 line do case insensitive color string matching, as suggested in sf bug 2834598 ........ r7477 | efiring | 2009-08-12 06:53:41 -1000 (Wed, 12 Aug 2009) | 2 lines Typo in navigation_toolbar.rst. ........ r7480 | jdh2358 | 2009-08-12 14:41:58 -1000 (Wed, 12 Aug 2009) | 1 line add the pngs referenced by sphinx css; closes sf bug 2834121 ........ r7482 | efiring | 2009-08-13 14:24:40 -1000 (Thu, 13 Aug 2009) | 2 lines Remove older versions of some functions in mlab.py; closes bug 2806535 ........ svn path=/trunk/matplotlib/; revision=7483
diff --git a/doc/_static/contents.png b/doc/_static/contents.png
diff --git a/doc/_static/navigation.png b/doc/_static/navigation.png
diff --git a/doc/faq/howto_faq.rst b/doc/faq/howto_faq.rst
@@ -516,7 +516,31 @@ list.
 
 If you have made lots of local changes and do not want to a diff
 against the entire tree, but rather against a single directory or
-file, that is fine, but we do prefer svn diffs against HEAD.
+file, that is fine, but we do prefer svn diffs against the top level
+(where setup.py lives) since it is nice to have a consistent way to
+apply them.
+
+If you are posting a patch to fix a code bug, please explain your
+patch in words -- what was broken before and how you fixed it.  Also,
+even if your patch is particularly simple, just a few lines or a
+single function replacement, we encourage people to submit svn diffs
+against HEAD or the branch they are patching.  It just makes life
+simpler for us, since we (fortunately) get a lot of contributions, and
+want to receive them in a standard format.  If possible, for any
+non-trivial change, please include a complete, free-standing example
+that the developers  can run unmodified which shows the undesired
+behavior pre-patch and the desired behavior post-patch, with a clear
+verbal description of what to look for.  The original developer may
+have written the function you are working on years ago, and may no
+longer be with the project, so it is quite possible you are the world
+expert on the code you are patching and we want to hear as much detail
+as you can offer.
+
+When emailing your patch and examples, feel free to paste any code
+into the text of the message, indeed we encourage it, but also attach
+the patches and examples since many email clients screw up the
+formatting of plain text, and we spend lots of needless time trying to
+reformat the code to make it usable.
 
 You should check out the guide to developing matplotlib to make sure
 your patch abides by our coding conventions
diff --git a/doc/users/navigation_toolbar.rst b/doc/users/navigation_toolbar.rst
@@ -35,7 +35,7 @@ The ``Pan/Zoom`` button
     figure, dragging it to a new position.  When you release it, the
     data under the point where you pressed will be moved to the point
     where you released.  If you press 'x' or 'y' while panning the
-    motion will be contrained to the x or y axis, respectively.  Press
+    motion will be constrained to the x or y axis, respectively.  Press
     the right mouse button to zoom, dragging it to a new position.
     The x axis will be zoomed in proportionate to the rightward
     movement and zoomed out proportionate to the leftward movement.
diff --git a/lib/matplotlib/colors.py b/lib/matplotlib/colors.py
@@ -282,13 +282,14 @@ def to_rgb(self, arg):
 
         try:
             if cbook.is_string_like(arg):
-                color = self.colors.get(arg, None)
+                argl = arg.lower()
+                color = self.colors.get(argl, None)
                 if color is None:
-                    str1 = cnames.get(arg, arg)
+                    str1 = cnames.get(argl, argl)
                     if str1.startswith('#'):
                         color = hex2color(str1)
                     else:
-                        fl = float(arg)
+                        fl = float(argl)
                         if fl < 0 or fl > 1:
                             raise ValueError(
                                    'gray (string) must be in range 0-1')
diff --git a/lib/matplotlib/mlab.py b/lib/matplotlib/mlab.py
@@ -1304,181 +1304,6 @@ def splitfunc(x):
     else: return X
 
 
-def slopes(x,y):
-    """
-    SLOPES calculate the slope y'(x) Given data vectors X and Y SLOPES
-    calculates Y'(X), i.e the slope of a curve Y(X). The slope is
-    estimated using the slope obtained from that of a parabola through
-    any three consecutive points.
-
-    This method should be superior to that described in the appendix
-    of A CONSISTENTLY WELL BEHAVED METHOD OF INTERPOLATION by Russel
-    W. Stineman (Creative Computing July 1980) in at least one aspect:
-
-    Circles for interpolation demand a known aspect ratio between x-
-    and y-values.  For many functions, however, the abscissa are given
-    in different dimensions, so an aspect ratio is completely
-    arbitrary.
-
-    The parabola method gives very similar results to the circle
-    method for most regular cases but behaves much better in special
-    cases
-
-    Norbert Nemec, Institute of Theoretical Physics, University or
-    Regensburg, April 2006 Norbert.Nemec at physik.uni-regensburg.de
-
-    (inspired by a original implementation by Halldor Bjornsson,
-    Icelandic Meteorological Office, March 2006 halldor at vedur.is)
-    """
-    # Cast key variables as float.
-    x=np.asarray(x, np.float_)
-    y=np.asarray(y, np.float_)
-
-    yp=np.zeros(y.shape, np.float_)
-
-    dx=x[1:] - x[:-1]
-    dy=y[1:] - y[:-1]
-    dydx = dy/dx
-    yp[1:-1] = (dydx[:-1] * dx[1:] + dydx[1:] * dx[:-1])/(dx[1:] + dx[:-1])
-    yp[0] = 2.0 * dy[0]/dx[0] - yp[1]
-    yp[-1] = 2.0 * dy[-1]/dx[-1] - yp[-2]
-    return yp
-
-
-def stineman_interp(xi,x,y,yp=None):
-    """
-    STINEMAN_INTERP Well behaved data interpolation.  Given data
-    vectors X and Y, the slope vector YP and a new abscissa vector XI
-    the function stineman_interp(xi,x,y,yp) uses Stineman
-    interpolation to calculate a vector YI corresponding to XI.
-
-    Here's an example that generates a coarse sine curve, then
-    interpolates over a finer abscissa:
-
-      x = linspace(0,2*pi,20);  y = sin(x); yp = cos(x)
-      xi = linspace(0,2*pi,40);
-      yi = stineman_interp(xi,x,y,yp);
-      plot(x,y,'o',xi,yi)
-
-    The interpolation method is described in the article A
-    CONSISTENTLY WELL BEHAVED METHOD OF INTERPOLATION by Russell
-    W. Stineman. The article appeared in the July 1980 issue of
-    Creative Computing with a note from the editor stating that while
-    they were
-
-      not an academic journal but once in a while something serious
-      and original comes in adding that this was
-      "apparently a real solution" to a well known problem.
-
-    For yp=None, the routine automatically determines the slopes using
-    the "slopes" routine.
-
-    X is assumed to be sorted in increasing order
-
-    For values xi[j] < x[0] or xi[j] > x[-1], the routine tries a
-    extrapolation.  The relevance of the data obtained from this, of
-    course, questionable...
-
-    original implementation by Halldor Bjornsson, Icelandic
-    Meteorolocial Office, March 2006 halldor at vedur.is
-
-    completely reworked and optimized for Python by Norbert Nemec,
-    Institute of Theoretical Physics, University or Regensburg, April
-    2006 Norbert.Nemec at physik.uni-regensburg.de
-
-    """
-
-    # Cast key variables as float.
-    x=np.asarray(x, np.float_)
-    y=np.asarray(y, np.float_)
-    assert x.shape == y.shape
-    N=len(y)
-
-    if yp is None:
-        yp = slopes(x,y)
-    else:
-        yp=np.asarray(yp, np.float_)
-
-    xi=np.asarray(xi, np.float_)
-    yi=np.zeros(xi.shape, np.float_)
-
-    # calculate linear slopes
-    dx = x[1:] - x[:-1]
-    dy = y[1:] - y[:-1]
-    s = dy/dx  #note length of s is N-1 so last element is #N-2
-
-    # find the segment each xi is in
-    # this line actually is the key to the efficiency of this implementation
-    idx = np.searchsorted(x[1:-1], xi)
-
-    # now we have generally: x[idx[j]] <= xi[j] <= x[idx[j]+1]
-    # except at the boundaries, where it may be that xi[j] < x[0] or xi[j] > x[-1]
-
-    # the y-values that would come out from a linear interpolation:
-    sidx = s.take(idx)
-    xidx = x.take(idx)
-    yidx = y.take(idx)
-    xidxp1 = x.take(idx+1)
-    yo = yidx + sidx * (xi - xidx)
-
-    # the difference that comes when using the slopes given in yp
-    dy1 = (yp.take(idx)- sidx) * (xi - xidx)       # using the yp slope of the left point
-    dy2 = (yp.take(idx+1)-sidx) * (xi - xidxp1) # using the yp slope of the right point
-
-    dy1dy2 = dy1*dy2
-    # The following is optimized for Python. The solution actually
-    # does more calculations than necessary but exploiting the power
-    # of numpy, this is far more efficient than coding a loop by hand
-    # in Python
-    yi = yo + dy1dy2 * np.choose(np.array(np.sign(dy1dy2), np.int32)+1,
-                                 ((2*xi-xidx-xidxp1)/((dy1-dy2)*(xidxp1-xidx)),
-                                  0.0,
-                                  1/(dy1+dy2),))
-    return yi
-
-def inside_poly(points, verts):
-    """
-    points is a sequence of x,y points
-    verts is a sequence of x,y vertices of a poygon
-
-    return value is a sequence of indices into points for the points
-    that are inside the polygon
-    """
-    res, =  np.nonzero(nxutils.points_inside_poly(points, verts))
-    return res
-
-def poly_below(ymin, xs, ys):
-    """
-    given a arrays *xs* and *ys*, return the vertices of a polygon
-    that has a scalar lower bound *ymin* and an upper bound at the *ys*.
-
-    intended for use with Axes.fill, eg::
-
-      xv, yv = poly_below(0, x, y)
-      ax.fill(xv, yv)
-    """
-    return poly_between(xs, ys, xmin)
-
-
-def poly_between(x, ylower, yupper):
-    """
-    given a sequence of x, ylower and yupper, return the polygon that
-    fills the regions between them.  ylower or yupper can be scalar or
-    iterable.  If they are iterable, they must be equal in length to x
-
-    return value is x, y arrays for use with Axes.fill
-    """
-    Nx = len(x)
-    if not cbook.iterable(ylower):
-        ylower = ylower*np.ones(Nx)
-
-    if not cbook.iterable(yupper):
-        yupper = yupper*np.ones(Nx)
-
-    x = np.concatenate( (x, x[::-1]) )
-    y = np.concatenate( (yupper, ylower[::-1]) )
-    return x,y
-
 ### the following code was written and submitted by Fernando Perez
 ### from the ipython numutils package under a BSD license
 # begin fperez functions
