Many improvements to chararray. Fixes Trac bugs 1199, 856, 855, 1231, 1235, 1240, 1241. docstrings, full unit-test coverage, C-based vectorized string operations.

10 files changed, 3141 insertions, 582 deletions

diff --git a/doc/source/reference/arrays.classes.rst b/doc/source/reference/arrays.classes.rst
index 9e94d5c4d..6d5e7bde0 100644
--- a/doc/source/reference/arrays.classes.rst
+++ b/doc/source/reference/arrays.classes.rst
@@ -228,11 +228,12 @@ Character arrays (:mod:`numpy.char`)
    single: character arrays
 
 .. note::
-   The chararray module exists for backwards compatibility with Numarray,
-   it is not recommended for new development. If one needs arrays of
-   strings, use arrays of `dtype` object.
+   The chararray module exists for backwards compatibility with
+   Numarray, it is not recommended for new development. If one needs
+   arrays of strings, use arrays of `dtype` `object_`, `string_` or
+   `unicode_`.
 
-These are enhanced arrays of either :class:`string` type or
+These are enhanced arrays of either :class:`string_` type or
 :class:`unicode_` type.  These arrays inherit from the
 :class:`ndarray`, but specially-define the operations ``+``, ``*``,
 and ``%`` on a (broadcasting) element-by-element basis.  These
@@ -244,7 +245,7 @@ to create a chararray is to use :meth:`self.view(chararray)
 <ndarray.view>` where *self* is an ndarray of string or unicode
 data-type. However, a chararray can also be created using the
 :meth:`numpy.chararray` constructor, or via the
-:func:`numpy.char.array` function:
+:func:`numpy.char.array <core.defchararray.array>` function:
 
 .. autosummary::
    :toctree: generated/
diff --git a/doc/source/reference/routines.array-creation.rst b/doc/source/reference/routines.array-creation.rst
index 4eabb8ec7..ef9c0041d 100644
--- a/doc/source/reference/routines.array-creation.rst
+++ b/doc/source/reference/routines.array-creation.rst
@@ -66,6 +66,7 @@ Creating character arrays (:mod:`numpy.char`)
    :toctree: generated/
 
    core.defchararray.array
+   core.defchararray.asarray
 
 Numerical ranges
 ----------------
diff --git a/doc/source/reference/routines.char.rst b/doc/source/reference/routines.char.rst
new file mode 100644
index 000000000..2e995a772
--- /dev/null
+++ b/doc/source/reference/routines.char.rst
@@ -0,0 +1,88 @@
+String operations
+*****************
+
+.. currentmodule:: numpy.core.defchararray
+
+This module provides a set of vectorized string operations for arrays
+of type `numpy.string_` or `numpy.unicode_`.   All of them are based on
+the string methods in the Python standard library.
+
+String operations
+-----------------
+
+.. autosummary::
+   :toctree: generated/
+
+   add
+   multiply
+   mod
+   capitalize
+   center
+   decode
+   encode
+   join
+   ljust
+   lower
+   lstrip
+   partition
+   replace
+   rjust
+   rpartition
+   rsplit
+   rstrip
+   split
+   splitlines
+   strip
+   swapcase
+   title
+   translate
+   upper
+   zfill
+
+Comparison
+----------
+
+Unlike the standard numpy comparison operators, the ones in the `char`
+module strip trailing whitespace characters before performing the
+comparison.
+
+.. autosummary::
+   :toctree: generated/
+
+   equal
+   not_equal
+   greater_equal
+   less_equal
+   greater
+   less
+
+String information
+------------------
+
+.. autosummary::
+   :toctree: generated/
+
+   count
+   len
+   find
+   index
+   isalpha
+   isdecimal
+   isdigit
+   islower
+   isnumeric
+   isspace
+   istitle
+   isupper
+   rfind
+   rindex
+   startswith
+
+Convenience class
+-----------------
+
+.. autosummary::
+   :toctree: generated/
+
+   chararray
+
diff --git a/doc/source/reference/routines.rst b/doc/source/reference/routines.rst
index eb2e9fc4e..90fe1c189 100644
--- a/doc/source/reference/routines.rst
+++ b/doc/source/reference/routines.rst
@@ -34,3 +34,4 @@ Routines
    routines.numarray
    routines.oldnumeric
    routines.ctypeslib
+   routines.char
diff --git a/numpy/core/defchararray.py b/numpy/core/defchararray.py
index 580bde59a..b59f27065 100644
--- a/numpy/core/defchararray.py
+++ b/numpy/core/defchararray.py
@@ -1,75 +1,1672 @@
 """
-Module for character arrays.
+This module contains a set of functions for vectorized string
+operations and methods.
 
 .. note::
-   The chararray module exists for backwards compatibility with Numarray,
-   it is not recommended for new development. If one needs arrays of
-   strings, use arrays of `dtype` object.
+   The chararray module exists for backwards compatibility with
+   Numarray, it is not recommended for new development. If one needs
+   arrays of strings, use arrays of `dtype` `object_`, `string_` or
+   `unicode_`.
 
-The preferred alias for `defchararray` is `numpy.char`.
+Methods will only be available if the corresponding str method is
+available in your version of Python.
 
+The preferred alias for `defchararray` is `numpy.char`.
 """
+
 import sys
-from numerictypes import string_, unicode_, integer, object_
-from numeric import ndarray, broadcast, empty, compare_chararrays
+from numerictypes import string_, unicode_, integer, object_, bool_, character
+from numeric import ndarray, compare_chararrays
 from numeric import array as narray
+from numpy.core.multiarray import _vec_string
+import numpy
 
 __all__ = ['chararray']
 
 _globalvar = 0
 _unicode = unicode
+_len = len
+
+def _use_unicode(*args):
+    """
+    Helper function for determining the output type of some string
+    operations.
+
+    For an operation on two ndarrays, if at least one is unicode, the
+    result should be unicode.
+    """
+    for x in args:
+        if (isinstance(x, _unicode)
+            or issubclass(numpy.asarray(x).dtype.type, unicode_)):
+            return unicode_
+    return string_
+
+def _to_string_or_unicode_array(result):
+    """
+    Helper function to cast a result back into a string or unicode array
+    if an object array must be used as an intermediary.
+    """
+    return numpy.asarray(result.tolist())
+
+def _clean_args(*args):
+    """
+    Helper function for delegating arguments to Python string
+    functions.
+
+    Many of the Python string operations that have optional arguments
+    do not use 'None' to indicate a default value.  In these cases,
+    we need to remove all `None` arguments, and those following them.
+    """
+    newargs = []
+    for chk in args:
+        if chk is None:
+            break
+        newargs.append(chk)
+    return newargs
+
+def _get_num_chars(a):
+    """
+    Helper function that returns the number of characters per field in
+    a string or unicode array.  This is to abstract out the fact that
+    for a unicode array this is itemsize / 4.
+    """
+    if issubclass(a.dtype.type, unicode_):
+        return a.itemsize / 4
+    return a.itemsize
+
+
+def equal(x1, x2):
+    """
+    Return (x1 == x2) element-wise.
+
+    Unlike `numpy.equal`, this comparison is performed by first
+    stripping whitespace characters from the end of the string.  This
+    behavior is provided for backward-compatibility with numarray.
+
+    Parameters
+    ----------
+    x1, x2 : array_like of string_ or unicode_
+        Input arrays of the same shape.
+
+    Returns
+    -------
+    out : {ndarray, bool}
+        Output array of bools, or a single bool if x1 and x2 are scalars.
+
+    See Also
+    --------
+    not_equal, greater_equal, less_equal, greater, less
+    """
+    return compare_chararrays(x1, x2, '==', True)
+
+def not_equal(x1, x2):
+    """
+    Return (x1 != x2) element-wise.
+
+    Unlike `numpy.not_equal`, this comparison is performed by first
+    stripping whitespace characters from the end of the string.  This
+    behavior is provided for backward-compatibility with numarray.
+
+    Parameters
+    ----------
+    x1, x2 : array_like of string_ or unicode_
+        Input arrays of the same shape.
+
+    Returns
+    -------
+    out : {ndarray, bool}
+        Output array of bools, or a single bool if x1 and x2 are scalars.
+
+    See Also
+    --------
+    equal, greater_equal, less_equal, greater, less
+    """
+    return compare_chararrays(x1, x2, '!=', True)
+
+def greater_equal(x1, x2):
+    """
+    Return (x1 >= x2) element-wise.
+
+    Unlike `numpy.greater_equal`, this comparison is performed by
+    first stripping whitespace characters from the end of the string.
+    This behavior is provided for backward-compatibility with
+    numarray.
+
+    Parameters
+    ----------
+    x1, x2 : array_like of string_ or unicode_
+        Input arrays of the same shape.
+
+    Returns
+    -------
+    out : {ndarray, bool}
+        Output array of bools, or a single bool if x1 and x2 are scalars.
+
+    See Also
+    --------
+    equal, not_equal, less_equal, greater, less
+    """
+    return compare_chararrays(x1, x2, '>=', True)
+
+def less_equal(x1, x2):
+    """
+    Return (x1 <= x2) element-wise.
+
+    Unlike `numpy.less_equal`, this comparison is performed by first
+    stripping whitespace characters from the end of the string.  This
+    behavior is provided for backward-compatibility with numarray.
+
+    Parameters
+    ----------
+    x1, x2 : array_like of string_ or unicode_
+        Input arrays of the same shape.
+
+    Returns
+    -------
+    out : {ndarray, bool}
+        Output array of bools, or a single bool if x1 and x2 are scalars.
+
+    See Also
+    --------
+    equal, not_equal, greater_equal, greater, less
+    """
+    return compare_chararrays(x1, x2, '<=', True)
+
+def greater(x1, x2):
+    """
+    Return (x1 > x2) element-wise.
+
+    Unlike `numpy.greater`, this comparison is performed by first
+    stripping whitespace characters from the end of the string.  This
+    behavior is provided for backward-compatibility with numarray.
+
+    Parameters
+    ----------
+    x1, x2 : array_like of string_ or unicode_
+        Input arrays of the same shape.
+
+    Returns
+    -------
+    out : {ndarray, bool}
+        Output array of bools, or a single bool if x1 and x2 are scalars.
+
+    See Also
+    --------
+    equal, not_equal, greater_equal, less_equal, less
+    """
+    return compare_chararrays(x1, x2, '>', True)
+
+def less(x1, x2):
+    """
+    Return (x1 < x2) element-wise.
+
+    Unlike `numpy.greater`, this comparison is performed by first
+    stripping whitespace characters from the end of the string.  This
+    behavior is provided for backward-compatibility with numarray.
+
+    Parameters
+    ----------
+    x1, x2 : array_like of string_ or unicode_
+        Input arrays of the same shape.
+
+    Returns
+    -------
+    out : {ndarray, bool}
+        Output array of bools, or a single bool if x1 and x2 are scalars.
+
+    See Also
+    --------
+    equal, not_equal, greater_equal, less_equal, greater
+    """
+    return compare_chararrays(x1, x2, '<', True)
+
+def str_len(a):
+    """
+    Return len(a) element-wise.
+
+    Parameters
+    ----------
+    a : array_like of string_ or unicode_
+
+    Returns
+    -------
+    out : ndarray
+        Output array of integers
+
+    See also
+    --------
+    __builtin__.len
+    """
+    return _vec_string(a, integer, '__len__')
+
+def add(x1, x2):
+    """
+    Return (x1 + x2), that is string concatenation, element-wise for a
+    pair of array_likes of string_ or unicode_.
+
+    Parameters
+    ----------
+    x1 : array_like of string_ or unicode_
+    x2 : array_like of string_ or unicode_
+
+    Returns
+    -------
+    out : ndarray
+        Output array of string_ or unicode_, depending on input types
+    """
+    arr1 = numpy.asarray(x1)
+    arr2 = numpy.asarray(x2)
+    out_size = _get_num_chars(arr1) + _get_num_chars(arr2)
+    dtype = _use_unicode(arr1, arr2)
+    return _vec_string(arr1, (dtype, out_size), '__add__', (arr2,))
+
+def multiply(a, i):
+    """
+    Return (a * i), that is string multiple concatenation,
+    element-wise.
+
+    Values in `i` of less than 0 are treated as 0 (which yields an
+    empty string).
+
+    Parameters
+    ----------
+    a : array_like of string_ or unicode_
+    i : array_like of integers
+
+    Returns
+    -------
+    out : ndarray
+        Output array of str or unicode, depending on input types
+    """
+    a_arr = numpy.asarray(a)
+    i_arr = numpy.asarray(i)
+    if not issubclass(i_arr.dtype.type, integer):
+        raise ValueError, "Can only multiply by integers"
+    out_size = _get_num_chars(a_arr) * max(long(i_arr.max()), 0)
+    return _vec_string(
+        a_arr, (a_arr.dtype.type, out_size), '__mul__', (i_arr,))
+
+def mod(a, values):
+    """
+    Return (a % i), that is pre-Python 2.6 string formatting
+    (iterpolation), element-wise for a pair of array_likes of string_
+    or unicode_.
+
+    Parameters
+    ----------
+    a : array_like of string_ or unicode_
+    values : array_like of values
+       These values will be element-wise interpolated into the string.
+
+    Returns
+    -------
+    out : ndarray
+        Output array of string_ or unicode_, depending on input types
+
+    See also
+    --------
+    str.__mod__
+    """
+    return _to_string_or_unicode_array(
+        _vec_string(a, object_, '__mod__', (values,)))
+
+def capitalize(a):
+    """
+    Return a copy of `a` with only the first character of each element
+    capitalized.
 
-# special sub-class for character arrays (string_ and unicode_)
-# This adds + and * operations and methods of str and unicode types
-#  which operate on an element-by-element basis
+    Calls `str.capitalize` element-wise.
+
+    For 8-bit strings, this method is locale-dependent.
+
+    Parameters
+    ----------
+    a : array_like of string_ or unicode_
+
+    Returns
+    -------
+    out : ndarray
+        Output array of string_ or unicode_, depending on input types
+
+    See also
+    --------
+    str.capitalize
+
+    Examples
+    --------
+    >>> c = np.array(['a1b2','1b2a','b2a1','2a1b'],'S4'); c
+    array(['a1b2', '1b2a', 'b2a1', '2a1b'],
+        dtype='|S4')
+    >>> np.char.capitalize(c)
+    array(['A1b2', '1b2a', 'B2a1', '2a1b'],
+        dtype='|S4')
+    """
+    a_arr = numpy.asarray(a)
+    return _vec_string(a_arr, a_arr.dtype, 'capitalize')
+
+if sys.version_info >= (2, 4):
+    def center(a, width, fillchar=' '):
+        """
+        Return a copy of `a` with its elements centered in a string of
+        length `width`.
+
+        Calls `str.center` element-wise.
+
+        Parameters
+        ----------
+        a : array_like of string_ or unicode_
+        width : int
+            The length of the resulting strings
+        fillchar : str or unicode, optional
+            The padding character to use (default is space).
+
+        Returns
+        -------
+        out : ndarray
+            Output array of string_ or unicode_, depending on input types
+
+        See also
+        --------
+        str.center
+        """
+        a_arr = numpy.asarray(a)
+        width_arr = numpy.asarray(width)
+        size = long(numpy.max(width_arr.flat))
+        return _vec_string(
+            a_arr, (a_arr.dtype.type, size), 'center', (width_arr, fillchar))
+else:
+    def center(a, width):
+        """
+        Return an array with the elements of `a` centered in a string
+        of length width.
+
+        Calls `str.center` element-wise.
+
+        Parameters
+        ----------
+        a : array_like of string_ or unicode_
+        width : int
+            The length of the resulting strings
+
+        Returns
+        -------
+        out : ndarray, str or unicode
+            Output array of string_ or unicode_, depending on input types
+
+        See also
+        --------
+        str.center
+        """
+        a_arr = numpy.asarray(a)
+        width_arr = numpy.asarray(width)
+        size = long(numpy.max(width_arr.flat))
+        return _vec_string(
+            a_arr, (a_arr.dtype.type, size), 'center', (width_arr,))
+
+def count(a, sub, start=0, end=None):
+    """
+    Returns an array with the number of non-overlapping occurrences of
+    substring `sub` in the range [`start`, `end`].
+
+    Calls `str.count` element-wise.
+
+    Parameters
+    ----------
+    a : array_like of string_ or unicode_
+    sub : str or unicode
+       The substring to search for
+    start, end : int, optional
+       Optional arguments `start` and `end` are interpreted as slice
+       notation to specify the range in which to count.
+
+    Returns
+    -------
+    out : ndarray
+        Output array of integers.
+
+    See also
+    --------
+    str.count
+
+    Examples
+    --------
+    >>> c = np.array(['aAaAaA', '  aA  ', 'abBABba'])
+    >>> c
+    array(['aAaAaA', '  aA', 'abBABba'],
+        dtype='|S7')
+    >>> np.char.count(c, 'A')
+    array([3, 1, 1])
+    >>> np.char.count(c, 'aA')
+    array([3, 1, 0])
+    >>> np.char.count(c, 'A', start=1, end=4)
+    array([2, 1, 1])
+    >>> np.char.count(c, 'A', start=1, end=3)
+    array([1, 0, 0])
+    """
+    return _vec_string(a, integer, 'count', [sub, start] + _clean_args(end))
+
+def decode(a, encoding=None, errors=None):
+    """
+    Calls `str.decode` element-wise.
+
+    Parameters
+    ----------
+    a : array_like of string_ or unicode_
+    encoding : str, optional
+       The name of an encoding
+    errors : str, optional
+       Specifies how to handle encoding errors
+
+    Returns
+    -------
+    out : ndarray
+
+    Notes
+    -----
+    The type of the result will depend on the encoding specified.
+
+    See also
+    --------
+    str.decode
+
+    Examples
+    --------
+    >>> c = np.array(['aAaAaA', '  aA  ', 'abBABba'])
+    >>> c
+    array(['aAaAaA', '  aA', 'abBABba'],
+        dtype='|S7')
+    >>> np.char.encode(c, encoding='cp037')
+    array(['\\x81\\xc1\\x81\\xc1\\x81\\xc1', '@@\\x81\\xc1@@',
+        '\\x81\\x82\\xc2\\xc1\\xc2\\x82\\x81'],
+        dtype='|S7')
+    """
+    return _to_string_or_unicode_array(
+        _vec_string(a, object_, 'decode', _clean_args(encoding, errors)))
+
+def encode(a, encoding=None, errors=None):
+    """
+    Calls `str.encode` element-wise.
+
+    Parameters
+    ----------
+    a : array_like of string_ or unicode_
+    encoding : str, optional
+       The name of an encoding
+    errors : str, optional
+       Specifies how to handle encoding errors
+
+    Returns
+    -------
+    out : ndarray
+
+    Notes
+    -----
+    The type of the result will depend on the encoding specified.
+
+    See also
+    --------
+    str.encode
+    """
+    return _to_string_or_unicode_array(
+        _vec_string(a, object_, 'encode', _clean_args(encoding, errors)))
+
+def endswith(a, suffix, start=0, end=None):
+    """
+    Returns a boolean array which is `True` where the string element
+    in `a` ends with `suffix`, otherwise `False`.
+
+    Calls `str.endswith` element-wise.
+
+    Parameters
+    ----------
+    a : array_like of string or unicode
+    suffix : str
+    start, end : int, optional
+        With optional `start`, test beginning at that position. With
+        optional `end`, stop comparing at that position.
+
+    Returns
+    -------
+    out : ndarray
+        Outputs an array of booleans.
+
+    See also
+    --------
+    str.endswith
+
+    Examples
+    --------
+    >>> s = np.array(['foo', 'bar'])
+    >>> s[0] = 'foo'
+    >>> s[1] = 'bar'
+    >>> s
+    array(['foo', 'bar'],
+        dtype='|S3')
+    >>> np.charendswith(s, 'ar')
+    array([False,  True], dtype=bool)
+    >>> s.endswith(s, 'a', start=1, end=2)
+    array([False,  True], dtype=bool)
+    """
+    return _vec_string(
+        a, bool_, 'endswith', [suffix, start] + _clean_args(end))
+
+def expandtabs(a, tabsize=8):
+    """
+    Return a copy of each string element where all tab characters are
+    replaced by one or more spaces.
+
+    Calls `str.expandtabs` element-wise.
+
+    Return a copy of each string element where all tab characters are
+    replaced by one or more spaces, depending on the current column
+    and the given `tabsize`. The column number is reset to zero after
+    each newline occurring in the string. If `tabsize` is not given, a
+    tab size of 8 characters is assumed. This doesn’t understand other
+    non-printing characters or escape sequences.
+
+    Parameters
+    ----------
+    a : array_like of string or unicode
+    tabsize : int, optional
+
+    Returns
+    -------
+    out : ndarray
+        Output array of str or unicode, depending on input type
+
+    See also
+    --------
+    str.expandtabs
+    """
+    return _to_string_or_unicode_array(
+        _vec_string(a, object_, 'expandtabs', (tabsize,)))
+
+def find(a, sub, start=0, end=None):
+    """
+    For each element, return the lowest index in the string where
+    substring `sub` is found.
+
+    Calls `str.find` element-wise.
+
+    For each element, return the lowest index in the string where
+    substring `sub` is found, such that `sub` is contained in the
+    range [`start`, `end`].
+
+    Parameters
+    ----------
+    a : array_like of string_ or unicode_
+    sub : str or unicode
+    start, end : int, optional
+        Optional arguments `start` and `end` are interpreted as in
+        slice notation.
+
+    Returns
+    -------
+    out : {ndarray, integer}
+        Output array of integers.  Returns -1 if `sub` is not found.
+
+    See also
+    --------
+    str.find
+    """
+    return _vec_string(
+        a, integer, 'find', [sub, start] + _clean_args(end))
+
+if sys.version_info >= (2.6):
+    def format(a, *args, **kwargs):
+        # _vec_string doesn't support kwargs at present
+        raise NotImplementedError
+
+def index(a, sub, start=0, end=None):
+    """
+    Like `find`, but raises `ValueError` when the substring is not found.
+
+    Calls `str.index` element-wise.
+
+    Parameters
+    ----------
+    a : array_like of string_ or unicode_
+    sub : str or unicode
+    start, end : int, optional
+
+    Returns
+    -------
+    out : ndarray
+        Output array of integers.  Returns -1 if `sub` is not found.
+
+    See also
+    --------
+    find, str.find
+    """
+    return _vec_string(
+        a, integer, 'index', [sub, start] + _clean_args(end))
+
+def isalnum(a):
+    """
+    Returns true for each element if all characters in the string are
+    alphanumeric and there is at least one character, false otherwise.
+
+    Calls `str.isalnum` element-wise.
+
+    For 8-bit strings, this method is locale-dependent.
+
+    Parameters
+    ----------
+    a : array_like of string_ or unicode_
+
+    Returns
+    -------
+    out : ndarray
+        Output array of str or unicode, depending on input type
+
+    See also
+    --------
+    str.isalnum
+    """
+    return _vec_string(a, bool_, 'isalnum')
+
+def isalpha(a):
+    """
+    Returns true for each element if all characters in the string are
+    alphabetic and there is at least one character, false otherwise.
+
+    Calls `str.isalpha` element-wise.
+
+    For 8-bit strings, this method is locale-dependent.
+
+    Parameters
+    ----------
+    a : array_like of string_ or unicode_
+
+    Returns
+    -------
+    out : ndarray
+        Output array of booleans
+
+    See also
+    --------
+    str.isalpha
+    """
+    return _vec_string(a, bool_, 'isalpha')
+
+def isdigit(a):
+    """
+    Returns true for each element if all characters in the string are
+    digits and there is at least one character, false otherwise.
+
+    Calls `str.isdigit` element-wise.
+
+    For 8-bit strings, this method is locale-dependent.
+
+    Parameters
+    ----------
+    a : array_like of string_ or unicode_
+
+    Returns
+    -------
+    out : ndarray
+        Output array of booleans
+
+    See also
+    --------
+    str.isdigit
+    """
+    return _vec_string(a, bool_, 'isdigit')
+
+def islower(a):
+    """
+    Returns true for each element if all cased characters in the
+    string are lowercase and there is at least one cased character,
+    false otherwise.
+
+    Calls `str.islower` element-wise.
+
+    For 8-bit strings, this method is locale-dependent.
+
+    Parameters
+    ----------
+    a : array_like of string_ or unicode_
+
+    Returns
+    -------
+    out : ndarray
+        Output array of booleans
+
+    See also
+    --------
+    str.islower
+    """
+    return _vec_string(a, bool_, 'islower')
+
+def isspace(a):
+    """
+    Returns true for each element if there are only whitespace
+    characters in the string and there is at least one character,
+    false otherwise.
+
+    Calls `str.isspace` element-wise.
+
+    For 8-bit strings, this method is locale-dependent.
+
+    Parameters
+    ----------
+    a : array_like of string_ or unicode_
+
+    Returns
+    -------
+    out : ndarray
+        Output array of booleans
+
+    See also
+    --------
+    str.isspace
+    """
+    return _vec_string(a, bool_, 'isspace')
+
+def istitle(a):
+    """
+    Returns true for each element if the element is a titlecased
+    string and there is at least one character, false otherwise.
+
+    Call `str.istitle` element-wise.
+
+    For 8-bit strings, this method is locale-dependent.
+
+    Parameters
+    ----------
+    a : array_like of string_ or unicode_
+
+    Returns
+    -------
+    out : ndarray
+        Output array of booleans
+
+    See also
+    --------
+    str.istitle
+    """
+    return _vec_string(a, bool_, 'istitle')
+
+def isupper(a):
+    """
+    Returns true for each element if all cased characters in the
+    string are uppercase and there is at least one character, false
+    otherwise.
+
+    Call `str.isupper` element-wise.
+
+    For 8-bit strings, this method is locale-dependent.
+
+    Parameters
+    ----------
+    a : array_like of string_ or unicode_
+
+    Returns
+    -------
+    out : ndarray
+        Output array of booleans
+
+    See also
+    --------
+    str.isupper
+    """
+    return _vec_string(a, bool_, 'isupper')
+
+def join(sep, seq):
+    """
+    Return a string which is the concatenation of the strings in the
+    sequence `seq`.
+
+    Calls `str.join` element-wise.
+
+    Parameters
+    ----------
+    sep : array_like of string_ or unicode_
+    seq : array_like of string_ or unicode_
+
+    Returns
+    -------
+    out : ndarray
+        Output array of string_ or unicode_, depending on input types
+
+    See also
+    --------
+    str.join
+    """
+    return _to_string_or_unicode_array(
+        _vec_string(sep, object_, 'join', (seq,)))
+
+if sys.version_info >= (2, 4):
+    def ljust(a, width, fillchar=' '):
+        """
+        Return an array with the elements of `a` left-justified in a
+        string of length `width`.
+
+        Calls `str.ljust` element-wise.
+
+        Parameters
+        ----------
+        a : array_like of string_ or unicode_
+        width : int
+            The length of the resulting strings
+        fillchar : str or unicode, optional
+            The character to use for padding
+
+        Returns
+        -------
+        out : ndarray
+            Output array of str or unicode, depending on input type
+
+        See also
+        --------
+        str.ljust
+        """
+        a_arr = numpy.asarray(a)
+        width_arr = numpy.asarray(width)
+        size = long(numpy.max(width_arr.flat))
+        return _vec_string(
+            a_arr, (a_arr.dtype.type, size), 'ljust', (width_arr, fillchar))
+else:
+    def ljust(a, width):
+        """
+        Return an array with the elements of `a` left-justified in a
+        string of length `width`.
+
+        Calls `str.ljust` element-wise.
+
+        Parameters
+        ----------
+        a : array_like of string_ or unicode_
+        width : int
+            The length of the resulting strings
+
+        Returns
+        -------
+        out : ndarray
+            Output array of str or unicode, depending on input type
+
+        See also
+        --------
+        str.ljust
+        """
+        a_arr = numpy.asarray(a)
+        width_arr = numpy.asarray(width)
+        size = long(numpy.max(width_arr.flat))
+        return _vec_string(
+            a_arr, (a_arr.dtype.type, size), 'ljust', (width_arr,))
+
+def lower(a):
+    """
+    Return an array with the elements of `a` converted to lowercase.
+
+    Call `str.lower` element-wise.
+
+    For 8-bit strings, this method is locale-dependent.
+
+    Parameters
+    ----------
+    a : array-like of str or unicode
+
+    Returns
+    -------
+    out : ndarray, str or unicode
+        Output array of str or unicode, depending on input type
+
+    See also
+    --------
+    str.lower
+
+    Examples
+    --------
+    >>> c = np.array(['A1B C', '1BCA', 'BCA1']); c
+    array(['A1B C', '1BCA', 'BCA1'],
+          dtype='|S5')
+    >>> np.char.lower(c)
+    array(['a1b c', '1bca', 'bca1'],
+          dtype='|S5')
+    """
+    a_arr = numpy.asarray(a)
+    return _vec_string(a_arr, a_arr.dtype, 'lower')
+
+def lstrip(a, chars=None):
+    """
+    For each element in `a`, return a copy with the leading characters
+    removed.
+
+    Calls `str.lstrip` element-wise.
+
+    Parameters
+    ----------
+    a : array-like of str or unicode
+    chars : str or unicode, optional
+       The `chars` argument is a string specifying the set of
+       characters to be removed. If omitted or None, the `chars`
+       argument defaults to removing whitespace. The `chars` argument
+       is not a prefix; rather, all combinations of its values are
+       stripped.
+
+    Returns
+    -------
+    out : ndarray, str or unicode
+        Output array of str or unicode, depending on input type
+
+    See also
+    --------
+    str.lstrip
+
+    Examples
+    --------
+    >>> c = np.array(['aAaAaA', '  aA  ', 'abBABba'])
+    >>> c
+    array(['aAaAaA', '  aA', 'abBABba'],
+        dtype='|S7')
+    >>> np.char.lstrip(c, 'a') # 'a' unstripped from c[1] because whitespace leading
+    array(['AaAaA', '  aA', 'bBABba'],
+        dtype='|S6')
+    >>> np.char.lstrip(c, 'A') # leaves c unchanged
+    array(['aAaAaA', '  aA', 'abBABba'],
+        dtype='|S7')
+    >>> (np.char.lstrip(c, ' ') == np.char.lstrip(c, '')).all()
+    True
+    >>> (np.char.lstrip(c, ' ') == np.char.lstrip(c, None)).all()
+    True
+    """
+    a_arr = numpy.asarray(a)
+    return _vec_string(a_arr, a_arr.dtype, 'lstrip', (chars,))
+
+if sys.version_info >= (2, 5):
+    def partition(a, sep):
+        """
+        Partition each element in `a` around `sep`.
+
+        Calls `str.partition` element-wise.
+
+        For each element in `a`, split the element as the first
+        occurrence of `sep`, and return 3 strings containing the part
+        before the separator, the separator itself, and the part after
+        the separator. If the separator is not found, return 3 strings
+        containing the string itself, followed by two empty strings.
+
+        Parameters
+        ----------
+        a : array-like of str or unicode
+        sep : str or unicode
+
+        Returns
+        -------
+        out : ndarray
+            Output array of string or unicode, depending on input
+            type.  The output array will have an extra dimension with
+            3 elements per input element.
+
+        See also
+        --------
+        str.partition
+        """
+        return _to_string_or_unicode_array(
+            _vec_string(a, object_, 'partition', (sep,)))
+
+def replace(a, old, new, count=None):
+    """
+    For each element in `a`, return a copy of the string with all
+    occurrences of substring `old` replaced by `new`.
+
+    Calls `str.replace` element-wise.
+
+    Parameters
+    ----------
+    a : array-like of str or unicode
+    old, new : str or unicode
+    count : int, optional
+        If the optional argument `count` is given, only the first
+        `count` occurrences are replaced.
+
+    Returns
+    -------
+    out : ndarray
+        Output array of str or unicode, depending on input type
+
+    See also
+    --------
+    str.replace
+    """
+    return _to_string_or_unicode_array(
+        _vec_string(
+            a, object_, 'replace', [old, new] +_clean_args(count)))
+
+def rfind(a, sub, start=0, end=None):
+    """
+    For each element in `a`, return the highest index in the string
+    where substring `sub` is found, such that `sub` is contained
+    within [`start`, `end`].
+
+    Calls `str.rfind` element-wise.
+
+    Parameters
+    ----------
+    a : array-like of str or unicode
+    sub : str or unicode
+    start, end : int, optional
+        Optional arguments `start` and `end` are interpreted as in
+        slice notation.
+
+    Returns
+    -------
+    out : ndarray
+       Output array of integers.  Return -1 on failure.
+
+    See also
+    --------
+    str.rfind
+    """
+    return _vec_string(
+        a, integer, 'rfind', [sub, start] + _clean_args(end))
+
+def rindex(a, sub, start=0, end=None):
+    """
+    Like `rfind`, but raises `ValueError` when the substring `sub` is
+    not found.
+
+    Calls `str.rindex` element-wise.
+
+    Parameters
+    ----------
+    a : array-like of str or unicode
+    sub : str or unicode
+    start, end : int, optional
+
+    Returns
+    -------
+    out : ndarray
+       Output array of integers.
+
+    See also
+    --------
+    rfind, str.rindex
+    """
+    return _vec_string(
+        a, integer, 'rindex', [sub, start] + _clean_args(end))
+
+if sys.version_info >= (2, 4):
+    def rjust(a, width, fillchar=' '):
+        """
+        Return an array with the elements of `a` right-justified in a
+        string of length `width`.
+
+        Calls `str.rjust` element-wise.
+
+        Parameters
+        ----------
+        a : array_like of string_ or unicode_
+        width : int
+            The length of the resulting strings
+        fillchar : str or unicode, optional
+            The character to use for padding
+
+        Returns
+        -------
+        out : ndarray
+            Output array of str or unicode, depending on input type
+
+        See also
+        --------
+        str.rjust
+        """
+        a_arr = numpy.asarray(a)
+        width_arr = numpy.asarray(width)
+        size = long(numpy.max(width_arr.flat))
+        return _vec_string(
+            a_arr, (a_arr.dtype.type, size), 'rjust', (width_arr, fillchar))
+else:
+    def rjust(a, width):
+        """
+        Return an array with the elements of `a` right-justified in a
+        string of length `width`.
+
+        Calls `str.rjust` element-wise.
+
+        Parameters
+        ----------
+        a : array_like of string_ or unicode_
+        width : int
+            The length of the resulting strings
+
+        Returns
+        -------
+        out : ndarray
+            Output array of str or unicode, depending on input type
+
+        See also
+        --------
+        str.rjust
+        """
+        a_arr = numpy.asarray(a)
+        width_arr = numpy.asarray(width)
+        size = long(numpy.max(width_arr.flat))
+        return _vec_string(
+            a_arr, (a_arr.dtype.type, size), 'rjust', (width,))
+
+if sys.version_info >= (2, 5):
+    def rpartition(a, sep):
+        """
+        Partition each element in `a` around `sep`.
+
+        Calls `str.rpartition` element-wise.
+
+        For each element in `a`, split the element as the last
+        occurrence of `sep`, and return 3 strings containing the part
+        before the separator, the separator itself, and the part after
+        the separator. If the separator is not found, return 3 strings
+        containing the string itself, followed by two empty strings.
+
+        Parameters
+        ----------
+        a : array-like of str or unicode
+        sep : str or unicode
+
+        Returns
+        -------
+        out : ndarray
+            Output array of string or unicode, depending on input
+            type.  The output array will have an extra dimension with
+            3 elements per input element.
+
+        See also
+        --------
+        str.rpartition
+        """
+        return _to_string_or_unicode_array(
+            _vec_string(a, object_, 'rpartition', (sep,)))
+
+if sys.version_info >= (2, 4):
+    def rsplit(a, sep=None, maxsplit=None):
+        """
+        For each element in `a`, return a list of the words in the
+        string, using `sep` as the delimiter string.
+
+        Calls `str.rsplit` element-wise.
+
+        Except for splitting from the right, `rsplit`
+        behaves like `split`.
+
+        Parameters
+        ----------
+        a : array_like of string_ or unicode_
+        sep : str or unicode, optional
+            If `sep` is not specified or `None`, any whitespace string
+            is a separator.
+        maxsplit : int, optional
+            If `maxsplit` is given, at most `maxsplit` splits are done,
+            the rightmost ones.
+
+        Returns
+        -------
+        out : ndarray
+           Array of list objects
+
+        See also
+        --------
+        str.rsplit, split
+        """
+        # This will return an array of lists of different sizes, so we
+        # leave it as an object array
+        return _vec_string(
+            a, object_, 'rsplit', [sep] + _clean_args(maxsplit))
+
+def rstrip(a, chars=None):
+    """
+    For each element in `a`, return a copy with the trailing
+    characters removed.
+
+    Calls `str.rstrip` element-wise.
+
+    Parameters
+    ----------
+    a : array-like of str or unicode
+    chars : str or unicode, optional
+       The `chars` argument is a string specifying the set of
+       characters to be removed. If omitted or None, the `chars`
+       argument defaults to removing whitespace. The `chars` argument
+       is not a suffix; rather, all combinations of its values are
+       stripped.
+
+    Returns
+    -------
+    out : ndarray
+        Output array of str or unicode, depending on input type
+
+    See also
+    --------
+    str.rstrip
+
+    Examples
+    --------
+    >>> c = np.array(['aAaAaA', 'abBABba'], dtype='S7'); c
+    array(['aAaAaA', 'abBABba'],
+        dtype='|S7')
+    >>> np.char.rstrip(c, 'a')
+    array(['aAaAaA', 'abBABb'],
+        dtype='|S6')
+    >>> np.char.rstrip(c, 'A')
+    array(['aAaAa', 'abBABba'],
+        dtype='|S7')
+    """
+    a_arr = numpy.asarray(a)
+    return _vec_string(a_arr, a_arr.dtype, 'rstrip', (chars,))
+
+def split(a, sep=None, maxsplit=None):
+    """
+    For each element in `a`, return a list of the words in the
+    string, using `sep` as the delimiter string.
+
+    Calls `str.rsplit` element-wise.
+
+    Parameters
+    ----------
+    a : array_like of string_ or unicode_
+    sep : str or unicode, optional
+       If `sep` is not specified or `None`, any whitespace string is a
+       separator.
+    maxsplit : int, optional
+        If `maxsplit` is given, at most `maxsplit` splits are done.
+
+    Returns
+    -------
+    out : ndarray
+        Array of list objects
+
+    See also
+    --------
+    str.split, rsplit
+    """
+    # This will return an array of lists of different sizes, so we
+    # leave it as an object array
+    return _vec_string(
+        a, object_, 'split', [sep] + _clean_args(maxsplit))
+
+def splitlines(a, keepends=None):
+    """
+    For each element in `a`, return a list of the lines in the
+    element, breaking at line boundaries.
+
+    Calls `str.splitlines` element-wise.
+
+    Parameters
+    ----------
+    a : array_like of string_ or unicode_
+    keepends : bool, optional
+        Line breaks are not included in the resulting list unless
+        keepends is given and true.
+
+    Returns
+    -------
+    out : ndarray
+        Array of list objects
+
+    See also
+    --------
+    str.splitlines
+    """
+    return _vec_string(
+        a, object_, 'splitlines', _clean_args(keepends))
+
+def startswith(a, prefix, start=0, end=None):
+    """
+    Returns a boolean array which is `True` where the string element
+    in `a` starts with `prefix`, otherwise `False`.
+
+    Calls `str.startswith` element-wise.
+
+    Parameters
+    ----------
+    a : array_like of string or unicode
+    suffix : str
+    start, end : int, optional
+    end : int, optional
+        With optional `start`, test beginning at that position. With
+        optional `end`, stop comparing at that position.
+
+    Returns
+    -------
+    out : ndarray
+        Array of booleans
+
+    See also
+    --------
+    str.startswith
+    """
+    return _vec_string(
+        a, bool_, 'startswith', [prefix, start] + _clean_args(end))
+
+def strip(a, chars=None):
+    """
+    For each element in `a`, return a copy with the leading and
+    trailing characters removed.
+
+    Calls `str.rstrip` element-wise.
+
+    Parameters
+    ----------
+    a : array-like of str or unicode
+    chars : str or unicode, optional
+       The `chars` argument is a string specifying the set of
+       characters to be removed. If omitted or None, the `chars`
+       argument defaults to removing whitespace. The `chars` argument
+       is not a prefix or suffix; rather, all combinations of its
+       values are stripped.
+
+    Returns
+    -------
+    out : ndarray
+        Output array of str or unicode, depending on input type
+
+    See also
+    --------
+    str.strip
+
+    Examples
+    --------
+    >>> c = np.array(['aAaAaA', '  aA  ', 'abBABba'])
+    >>> c
+    array(['aAaAaA', '  aA', 'abBABba'],
+        dtype='|S7')
+    >>> np.char.strip(c)
+    array(['aAaAaA', 'aA', 'abBABba'],
+        dtype='|S7')
+    >>> np.char.strip(c, 'a') # 'a' unstripped from c[1] because whitespace leads
+    array(['AaAaA', '  aA', 'bBABb'],
+        dtype='|S6')
+    >>> np.char.strip(c, 'A') # 'A' unstripped from c[1] because (unprinted) ws trails
+    array(['aAaAa', '  aA', 'abBABba'],
+        dtype='|S7')
+    """
+    a_arr = numpy.asarray(a)
+    return _vec_string(a_arr, a_arr.dtype, 'strip', _clean_args(chars))
+
+def swapcase(a):
+    """
+    For each element in `a`, return a copy of the string with
+    uppercase characters converted to lowercase and vice versa.
+
+    Calls `str.swapcase` element-wise.
+
+    For 8-bit strings, this method is locale-dependent.
+
+    Parameters
+    ----------
+    a : array-like of str or unicode
+
+    Returns
+    -------
+    out : ndarray
+        Output array of str or unicode, depending on input type
+
+    See also
+    --------
+    str.swapcase
+
+    Examples
+    --------
+    >>> c=np.array(['a1B c','1b Ca','b Ca1','cA1b'],'S5'); c
+    array(['a1B c', '1b Ca', 'b Ca1', 'cA1b'],
+        dtype='|S5')
+    >>> np.char.swapcase(c)
+    array(['A1b C', '1B cA', 'B cA1', 'Ca1B'],
+        dtype='|S5')
+    """
+    a_arr = numpy.asarray(a)
+    return _vec_string(a_arr, a_arr.dtype, 'swapcase')
+
+def title(a):
+    """
+    For each element in `a`, return a titlecased version of the
+    string: words start with uppercase characters, all remaining cased
+    characters are lowercase.
+
+    Calls `str.title` element-wise.
+
+    For 8-bit strings, this method is locale-dependent.
+
+    Parameters
+    ----------
+    a : array-like of str or unicode
+
+    Returns
+    -------
+    out : ndarray
+        Output array of str or unicode, depending on input type
+
+    See also
+    --------
+    str.title
+
+    Examples
+    --------
+    >>> c=np.array(['a1b c','1b ca','b ca1','ca1b'],'S5'); c
+    array(['a1b c', '1b ca', 'b ca1', 'ca1b'],
+        dtype='|S5')
+    >>> np.char.title(c)
+    chararray(['A1B C', '1B Ca', 'B Ca1', 'Ca1B'],
+        dtype='|S5')
+    """
+    a_arr = numpy.asarray(a)
+    return _vec_string(a_arr, a_arr.dtype, 'title')
+
+def translate(a, table, deletechars=None):
+    """
+    For each element in `a`, return a copy of the string where all
+    characters occurring in the optional argument `deletechars` are
+    removed, and the remaining characters have been mapped through the
+    given translation table.
+
+    Calls `str.translate` element-wise.
+
+    Parameters
+    ----------
+    a : array-like of str or unicode
+    table : str of length 256
+    deletechars : str
+
+    Returns
+    -------
+    out : ndarray
+        Output array of str or unicode, depending on input type
+
+    See also
+    --------
+    str.translate
+    """
+    a_arr = numpy.asarray(a)
+    if issubclass(a_arr.dtype.type, unicode_):
+        return _vec_string(
+            a_arr, a_arr.dtype, 'translate', (table,))
+    else:
+        return _vec_string(
+            a_arr, a_arr.dtype, 'translate', [table] + _clean_args(deletechars))
+
+def upper(a):
+    """
+    Return an array with the elements of `a` converted to uppercase.
+
+    Calls `str.upper` element-wise.
+
+    For 8-bit strings, this method is locale-dependent.
+
+    Parameters
+    ----------
+    a : array-like of str or unicode
+
+    Returns
+    -------
+    out : ndarray
+        Output array of str or unicode, depending on input type
+
+    See also
+    --------
+    str.upper
+
+    Examples
+    --------
+    >>> c = np.array(['a1b c', '1bca', 'bca1']); c
+    array(['a1b c', '1bca', 'bca1'],
+        dtype='|S5')
+    >>> numpy.char.upper(c)
+    array(['A1B C', '1BCA', 'BCA1'],
+        dtype='|S5')
+    """
+    a_arr = numpy.asarray(a)
+    return _vec_string(a_arr, a_arr.dtype, 'upper')
+
+def zfill(a, width):
+    """
+    Return the numeric string left-filled with zeros in a string of
+    length `width`.
+
+    Calls `str.zfill` element-wise.
+
+    Parameters
+    ----------
+    a : array-like of str or unicode
+    width : int
+
+    Returns
+    -------
+    out : ndarray
+        Output array of str or unicode, depending on input type
+
+    See also
+    --------
+    str.zfill
+    """
+    a_arr = numpy.asarray(a)
+    width_arr = numpy.asarray(width)
+    size = long(numpy.max(width_arr.flat))
+    return _vec_string(
+        a_arr, (a_arr.dtype.type, size), 'zfill', (width_arr,))
+
+def isnumeric(a):
+    """
+    For each element in `a`, return True if there are only numeric
+    characters in the element.
+
+    Calls `unicode.isnumeric` element-wise.
+
+    Numeric characters include digit characters, and all characters
+    that have the Unicode numeric value property, e.g. ``U+2155,
+    VULGAR FRACTION ONE FIFTH``.
+
+    Parameters
+    ----------
+    a : array-like of unicode
+
+    Returns
+    -------
+    out : ndarray
+        Array of booleans
+
+    See also
+    --------
+    unicode.isnumeric
+    """
+    if _use_unicode(a) != unicode_:
+        raise TypeError, "isnumeric is only available for Unicode strings and arrays"
+    return _vec_string(a, bool_, 'isnumeric')
+
+def isdecimal(a):
+    """
+    For each element in `a`, return True if there are only decimal
+    characters in the element.
+
+    Calls `unicode.isdecimal` element-wise.
+
+    Decimal characters include digit characters, and all characters
+    that that can be used to form decimal-radix numbers,
+    e.g. ``U+0660, ARABIC-INDIC DIGIT ZERO``.
+
+    Parameters
+    ----------
+    a : array-like of unicode
+
+    Returns
+    -------
+    out : ndarray
+        Array of booleans
+
+    See also
+    --------
+    unicode.isdecimal
+    """
+    if _use_unicode(a) != unicode_:
+        raise TypeError, "isnumeric is only available for Unicode strings and arrays"
+    return _vec_string(a, bool_, 'isdecimal')
 
-# It also strips white-space on element retrieval and on
-#   comparisons
 
 class chararray(ndarray):
     """
     chararray(shape, itemsize=1, unicode=False, buffer=None, offset=0,
               strides=None, order=None)
 
-    An array of fixed size (perhaps unicode) strings.
+    Provides a convenient view on arrays of string and unicode values.
 
     .. note::
-       The chararray module exists for backwards compatibility with Numarray,
-       it is not recommended for new development. If one needs arrays of
-       strings, use arrays of `dtype` object.
+       This class is provided for numarray backward-compatibility.
+       New code (not concerned with numarray compatibility) should use
+       arrays of type object_, string_ or unicode_ and use the free
+       functions in :mod:`numpy.char <numpy.core.defchararray>` for
+       fast vectorized string operations instead.
+
+    Versus a regular Numpy array of type 'string_' or 'unicode_', this
+    class adds the following functionality:
 
-    Create the array, using `buffer` (with `offset` and `strides`) if it is
-    not ``None``. If `buffer` is ``None``, then construct a new array with
-    `strides` in "C order," unless both ``len(shape) >= 2`` and
-    ``order='Fortran'``, in which case `strides` is in "Fortran order."
+
+      1) values automatically have whitespace removed from the end
+         when indexed
+
+      2) comparison operators automatically remove whitespace from the
+         end when comparing values
+
+      3) vectorized string operations are provided as methods
+         (e.g. `.endswith`) and infix operators (e.g. +, *, %)
+
+    chararrays should be created using `numpy.char.array
+    <numpy.core.defchararray.array>` or `numpy.char.asarray
+    <numpy.core.defchararray.asarray>`, rather than this constructor
+    directly.
+
+    Create the array, using `buffer` (with `offset` and `strides`) if
+    it is not ``None``. If `buffer` is ``None``, then construct a new
+    array with `strides` in "C order," unless both ``len(shape) >= 2``
+    and ``order='Fortran'``, in which case `strides` is in "Fortran
+    order."
 
     Parameters
     ----------
     shape : tuple
-        Shape of the array.
+       Shape of the array.
 
     itemsize : int_like, > 0, optional
-        Length of each array element, in number of characters. Default is 1.
+       Length of each array element, in number of characters. Default is 1.
 
     unicode : {True, False}, optional
-        Are the array elements of unicode-type (``True``) or string-type
-        (``False``, the default).
+       Are the array elements of unicode-type (``True``) or string-type
+       (``False``, the default).
 
     buffer : integer, > 0, optional
-        Memory address of the start of the array data.  If ``None`` (the
-        default), a new array is created.
+       Memory address of the start of the array data.  If ``None``
+       (the default), a new array is created.
 
     offset : integer, >= 0, optional
-        Fixed stride displacement from the beginning of an axis? Default is
-        0.
+       Fixed stride displacement from the beginning of an axis?
+       Default is 0.
 
     strides : array_like(?), optional
-        Strides for the array (see `numpy.ndarray.strides` for full
-        description), default is ``None``.
+       Strides for the array (see `numpy.ndarray.strides` for full
+       description), default is ``None``.
 
     order : {'C', 'F'}, optional
-        The order in which the array data is stored in memory: 'C' -> "row
-        major" order (the default), 'F' -> "column major" (Fortran) order
+       The order in which the array data is stored in memory: 'C' ->
+       "row major" order (the default), 'F' -> "column major"
+       (Fortran) order.
 
     Examples
     --------
@@ -87,7 +1684,6 @@ class chararray(ndarray):
            ['abc', 'abc', 'abc'],
            ['abc', 'abc', 'abc']],
           dtype='|S5')
-
     """
     def __new__(subtype, shape, itemsize=1, unicode=False, buffer=None,
                 offset=0, strides=None, order='C'):
@@ -98,6 +1694,11 @@ class chararray(ndarray):
         else:
             dtype = string_
 
+        # force itemsize to be a Python long, since using Numpy integer
+        # types results in itemsize.itemsize being used as the size of
+        # strings in the new array.
+        itemsize = long(itemsize)
+
         _globalvar = 1
         if buffer is None:
             self = ndarray.__new__(subtype, shape, (dtype, itemsize),
@@ -117,87 +1718,134 @@ class chararray(ndarray):
 
     def __getitem__(self, obj):
         val = ndarray.__getitem__(self, obj)
-        if isinstance(val, (string_, unicode_)):
+        if issubclass(val.dtype.type, character):
             temp = val.rstrip()
-            if len(temp) == 0:
+            if _len(temp) == 0:
                 val = ''
             else:
                 val = temp
         return val
 
+    # IMPLEMENTATION NOTE: Most of the methods of this class are
+    # direct delegations to the free functions in this module.
+    # However, those that return an array of strings should instead
+    # return a chararray, so some extra wrapping is required.
+
     def __eq__(self, other):
-        return compare_chararrays(self, other, '==', True)
+        """
+        Return (self == other) element-wise.
+
+        See also
+        --------
+        equal
+        """
+        return equal(self, other)
 
     def __ne__(self, other):
-        return compare_chararrays(self, other, '!=', True)
+        """
+        Return (self != other) element-wise.
+
+        See also
+        --------
+        not_equal
+        """
+        return not_equal(self, other)
 
     def __ge__(self, other):
-        return compare_chararrays(self, other, '>=', True)
+        """
+        Return (self >= other) element-wise.
+
+        See also
+        --------
+        greater_equal
+        """
+        return greater_equal(self, other)
 
     def __le__(self, other):
-        return compare_chararrays(self, other, '<=', True)
+        """
+        Return (self <= other) element-wise.
+
+        See also
+        --------
+        less_equal
+        """
+        return less_equal(self, other)
 
     def __gt__(self, other):
-        return compare_chararrays(self, other, '>', True)
+        """
+        Return (self > other) element-wise.
+
+        See also
+        --------
+        greater
+        """
+        return greater(self, other)
 
     def __lt__(self, other):
-        return compare_chararrays(self, other, '<', True)
+        """
+        Return (self < other) element-wise.
+
+        See also
+        --------
+        less
+        """
+        return less(self, other)
 
     def __add__(self, other):
-        b = broadcast(self, other)
-        arr = b.iters[1].base
-        outitem = self.itemsize + arr.itemsize
-        result = chararray(b.shape, outitem, self.dtype is unicode_)
-        res = result.flat
-        for k, val in enumerate(b):
-            res[k] = (val[0] + val[1])
-        return result
+        """
+        Return (self + other), that is string concatenation,
+        element-wise for a pair of array_likes of string_ or unicode_.
+
+        See also
+        --------
+        add
+        """
+        return asarray(add(self, other))
 
     def __radd__(self, other):
-        b = broadcast(other, self)
-        outitem = b.iters[0].base.itemsize + \
-                  b.iters[1].base.itemsize
-        result = chararray(b.shape, outitem, self.dtype is unicode_)
-        res = result.flat
-        for k, val in enumerate(b):
-            res[k] = (val[0] + val[1])
-        return result
-
-    def __mul__(self, other):
-        b = broadcast(self, other)
-        arr = b.iters[1].base
-        if not issubclass(arr.dtype.type, integer):
-            raise ValueError, "Can only multiply by integers"
-        outitem = b.iters[0].base.itemsize * arr.max()
-        result = chararray(b.shape, outitem, self.dtype is unicode_)
-        res = result.flat
-        for k, val in enumerate(b):
-            res[k] = val[0]*val[1]
-        return result
-
-    def __rmul__(self, other):
-        b = broadcast(self, other)
-        arr = b.iters[1].base
-        if not issubclass(arr.dtype.type, integer):
-            raise ValueError, "Can only multiply by integers"
-        outitem = b.iters[0].base.itemsize * arr.max()
-        result = chararray(b.shape, outitem, self.dtype is unicode_)
-        res = result.flat
-        for k, val in enumerate(b):
-            res[k] = val[0]*val[1]
-        return result
-
-    def __mod__(self, other):
-        b = broadcast(self, other)
-        res = [None]*b.size
-        maxsize = -1
-        for k,val in enumerate(b):
-            newval = val[0] % val[1]
-            maxsize = max(len(newval), maxsize)
-            res[k] = newval
-        newarr = chararray(b.shape, maxsize, self.dtype is unicode_)
-        newarr[:] = res
-        return newarr
+        """
+        Return (other + self), that is string concatenation,
+        element-wise for a pair of array_likes of string_ or unicode_.
+
+        See also
+        --------
+        add
+        """
+        return asarray(add(numpy.asarray(other), self))
+
+    def __mul__(self, i):
+        """
+        Return (self * i), that is string multiple concatenation,
+        element-wise.
+
+        See also
+        --------
+        multiply
+        """
+        return asarray(multiply(self, i))
+
+    def __rmul__(self, i):
+        """
+        Return (self * i), that is string multiple concatenation,
+        element-wise.
+
+        See also
+        --------
+        multiply
+        """
+        return asarray(multiply(self, i))
+
+    def __mod__(self, i):
+        """
+        Return (self % i), that is pre-Python 2.6 string formatting
+        (iterpolation), element-wise for a pair of array_likes of string_
+        or unicode_.
+
+        See also
+        --------
+        mod
+        """
+        return asarray(mod(self, i))
 
     def __rmod__(self, other):
         return NotImplemented
@@ -221,587 +1869,659 @@ class chararray(ndarray):
 
         """
         return self.__array__().argsort(axis, kind, order)
-
-    def _generalmethod(self, name, myiter):
-        res = [None]*myiter.size
-        maxsize = -1
-        for k, val in enumerate(myiter):
-            newval = []
-            for chk in val[1:]:
-                if not chk or (chk.dtype is object_ and chk.item() is None):
-                    break
-                newval.append(chk)
-            newitem = getattr(val[0],name)(*newval)
-            maxsize = max(len(newitem), maxsize)
-            res[k] = newitem
-        newarr = chararray(myiter.shape, maxsize, self.dtype is unicode_)
-        newarr[:] = res
-        return newarr
-
-    def _typedmethod(self, name, myiter, dtype):
-        result = empty(myiter.shape, dtype=dtype)
-        res = result.flat
-        for k, val in enumerate(myiter):
-            newval = []
-            for chk in val[1:]:
-                if not chk or (chk.dtype is object_ and chk.item() is None):
-                    break
-                newval.append(chk)
-            this_str = val[0].rstrip('\x00')
-            newitem = getattr(this_str,name)(*newval)
-            res[k] = newitem
-        return result
-
-    def _samemethod(self, name):
-        result = self.copy()
-        res = result.flat
-        for k, val in enumerate(self.flat):
-            res[k] = getattr(val, name)()
-        return result
+    argsort.__doc__ = ndarray.argsort.__doc__
 
     def capitalize(self):
         """
-        Capitalize the first character of each array element.
-
-        For each element of `self`, if the first character is a letter
-        possessing both "upper-case" and "lower-case" forms, and it is
-        presently in lower-case, change it to upper-case; otherwise, leave
-        it untouched.
-
-        Parameters
-        ----------
-        None
-
-        Returns
-        -------
-        ret : chararray
-            `self` with each element "title-cased."
+        Return a copy of `self` with only the first character of each element
+        capitalized.
 
-        Examples
+        See also
         --------
-        >>> c = np.array(['a1b2','1b2a','b2a1','2a1b'],'S4').view(np.chararray); c
-        chararray(['a1b2', '1b2a', 'b2a1', '2a1b'],
-              dtype='|S4')
-        >>> c.capitalize()
-        chararray(['A1b2', '1b2a', 'B2a1', '2a1b'],
-              dtype='|S4')
-
+        capitalize
         """
-        return self._samemethod('capitalize')
+        return asarray(capitalize(self))
 
-    if sys.version[:3] >= '2.4':
+    if sys.version_info >= (2, 4):
         def center(self, width, fillchar=' '):
-            return self._generalmethod('center',
-                                       broadcast(self, width, fillchar))
-        def ljust(self, width, fillchar=' '):
-            return self._generalmethod('ljust',
-                                       broadcast(self, width, fillchar))
-        def rjust(self, width, fillchar=' '):
-            return self._generalmethod('rjust',
-                                       broadcast(self, width, fillchar))
-        def rsplit(self, sep=None, maxsplit=None):
-            return self._typedmethod('rsplit', broadcast(self, sep, maxsplit),
-                                     object)
+            """
+            Return a copy of `self` with its elements centered in a
+            string of length `width`.
+
+            See also
+            --------
+            center
+            """
+            return asarray(center(self, width, fillchar))
     else:
-        def ljust(self, width):
-            return self._generalmethod('ljust', broadcast(self, width))
-        def rjust(self, width):
-            return self._generalmethod('rjust', broadcast(self, width))
         def center(self, width):
-            return self._generalmethod('center', broadcast(self, width))
+            """
+            Return a copy of `self` with its elements centered in a
+            string of length `width`.
 
-    def count(self, sub, start=None, end=None):
-        """
-        Return the number of occurrences of a sub-string in each array element.
+            See also
+            --------
+            center
+            """
+            return asarray(center(self, width))
 
-        Parameters
-        ----------
-        sub : string
-            The sub-string to count.
-        start : int, optional
-            The string index at which to start counting in each element.
-        end : int, optional
-            The string index at which to end counting in each element.
-
-        Returns
-        -------
-        ret : ndarray of ints
-            Array whose elements are the number of occurrences of `sub` in each
-            element of `self`.
+    def count(self, sub, start=0, end=None):
+        """
+        Returns an array with the number of non-overlapping occurrences of
+        substring `sub` in the range [`start`, `end`].
 
-        Examples
+        See also
         --------
-        >>> c = np.array(['aAaAaA', '  aA  ', 'abBABba']).view(np.chararray)
-        >>> c
-        chararray(['aAaAaA', '  aA', 'abBABba'],
-              dtype='|S7')
-        >>> c.count('A')
-        array([3, 1, 1])
-        >>> c.count('aA')
-        array([3, 1, 0])
-        >>> c.count('A', start=1, end=4)
-        array([2, 1, 1])
-        >>> c.count('A', start=1, end=3)
-        array([1, 0, 0])
-
+        count
         """
-        return self._typedmethod('count', broadcast(self, sub, start, end), int)
+        return count(self, sub, start, end)
+
 
-    def decode(self,encoding=None,errors=None):
+    def decode(self, encoding=None, errors=None):
         """
-        Return elements decoded according to the value of `encoding`.
+        Calls `str.decode` element-wise.
 
-        Parameters
-        ----------
-        encoding : string, optional
-            The encoding to use; for a list of acceptable values, see the
-            Python docstring for the package 'encodings'
-        error : Python exception object?, optional
-            The exception to raise if decoding fails?
+        See also
+        --------
+        decode
+        """
+        return decode(self, encoding, errors)
 
-        Returns
-        -------
-        ret : chararray
-            A view of `self`, suitably decoded.
+    def encode(self, encoding=None, errors=None):
+        """
+        Calls `str.encode` element-wise.
 
-        See Also
+        See also
         --------
         encode
-        encodings
-            (package)
-
-        Examples
-        --------
-        >>> c = np.array(['aAaAaA', '  aA  ', 'abBABba']).view(np.chararray)
-        >>> c
-        chararray(['aAaAaA', '  aA', 'abBABba'],
-              dtype='|S7')
-        >>> c = c.encode(encoding='cp037'); c
-        chararray(['\\x81\\xc1\\x81\\xc1\\x81\\xc1', '@@\\x81\\xc1@@',
-               '\\x81\\x82\\xc2\\xc1\\xc2\\x82\\x81'],
-              dtype='|S7')
-        >>> c.decode(encoding='cp037')
-        chararray(['aAaAaA', '  aA', 'abBABba'],
-              dtype='|S7')
-
         """
-        return self._generalmethod('decode', broadcast(self, encoding, errors))
+        return encode(self, encoding, errors)
 
-    def encode(self,encoding=None,errors=None):
+    def endswith(self, suffix, start=0, end=None):
         """
-        Return elements encoded according to the value of `encoding`.
-
-        Parameters
-        ----------
-        encoding : string, optional
-            The encoding to use; for a list of acceptable values, see the
-            Python docstring for `encodings`.
-        error : Python exception object, optional
-            The exception to raise if encoding fails.
+        Returns a boolean array which is `True` where the string element
+        in `self` ends with `suffix`, otherwise `False`.
 
-        Returns
-        -------
-        ret : chararray
-            A view of `self`, suitably encoded.
-
-        See Also
-        --------
-        decode
-
-        Examples
+        See also
         --------
-        >>> c = np.array(['aAaAaA', '  aA  ', 'abBABba']).view(np.chararray)
-        >>> c
-        chararray(['aAaAaA', '  aA', 'abBABba'],
-              dtype='|S7')
-        >>> c.encode(encoding='cp037')
-        chararray(['\\x81\\xc1\\x81\\xc1\\x81\\xc1', '@@\\x81\\xc1@@',
-               '\\x81\\x82\\xc2\\xc1\\xc2\\x82\\x81'],
-              dtype='|S7')
-
+        endswith
         """
-        return self._generalmethod('encode', broadcast(self, encoding, errors))
+        return endswith(self, suffix, start, end)
 
-    def endswith(self, suffix, start=None, end=None):
+    def expandtabs(self, tabsize=8):
         """
-        Check whether elements end with specified suffix
-
-        Given an array of strings, return a new bool array of same shape with
-        the result of comparing suffix against each element; each element
-        of bool array is ``True`` if element ends with specified suffix and
-        ``False`` otherwise.
+        Return a copy of each string element where all tab characters are
+        replaced by one or more spaces.
 
-        Parameters
-        ----------
-        suffix : string
-            Compare each element in array to this.
-        start : int, optional
-            For each element, start searching from this position.
-        end : int, optional
-            For each element, stop comparing at this position.
+        See also
+        --------
+        expandtabs
+        """
+        return asarray(expandtabs(self, tabsize))
 
-        Returns
-        -------
-        endswith : ndarray
-            Output array of bools
+    def find(self, sub, start=0, end=None):
+        """
+        For each element, return the lowest index in the string where
+        substring `sub` is found.
 
-        See Also
+        See also
         --------
-        count
         find
-        index
-        startswith
-
-        Examples
-        --------
-        >>> s = chararray(3, itemsize=3)
-        >>> s[0] = 'foo'
-        >>> s[1] = 'bar'
-        >>> s
-        chararray(['foo', 'bar'],
-              dtype='|S3')
-        >>> s.endswith('ar')
-        array([False,  True], dtype=bool)
-        >>> s.endswith('a', start=1, end=2)
-        array([False,  True], dtype=bool)
-
         """
-        return self._typedmethod('endswith', broadcast(self, suffix, start, end), bool)
-
-    def expandtabs(self, tabsize=None):
-        return self._generalmethod('endswith', broadcast(self, tabsize))
-
-    def find(self, sub, start=None, end=None):
-        return self._typedmethod('find', broadcast(self, sub, start, end), int)
+        return find(self, sub, start, end)
 
-    def index(self, sub, start=None, end=None):
-        return self._typedmethod('index', broadcast(self, sub, start, end), int)
+    def index(self, sub, start=0, end=None):
+        """
+        Like `find`, but raises `ValueError` when the substring is not found.
 
-    def _ismethod(self, name):
-        result = empty(self.shape, dtype=bool)
-        res = result.flat
-        for k, val in enumerate(self.flat):
-            item = val.rstrip('\x00')
-            res[k] = getattr(item, name)()
-        return result
+        See also
+        --------
+        index
+        """
+        return index(self, sub, start, end)
 
     def isalnum(self):
-        return self._ismethod('isalnum')
+        """
+        Returns true for each element if all characters in the string
+        are alphanumeric and there is at least one character, false
+        otherwise.
+
+        See also
+        --------
+        isalnum
+        """
+        return isalnum(self)
 
     def isalpha(self):
-        return self._ismethod('isalpha')
+        """
+        Returns true for each element if all characters in the string
+        are alphabetic and there is at least one character, false
+        otherwise.
+
+        See also
+        --------
+        isalpha
+        """
+        return isalpha(self)
 
     def isdigit(self):
-        return self._ismethod('isdigit')
+        """
+        Returns true for each element if all characters in the string are
+        digits and there is at least one character, false otherwise.
+
+        See also
+        --------
+        isdigit
+        """
+        return isdigit(self)
 
     def islower(self):
-        return self._ismethod('islower')
+        """
+        Returns true for each element if all cased characters in the
+        string are lowercase and there is at least one cased character,
+        false otherwise.
+
+        See also
+        --------
+        islower
+        """
+        return islower(self)
 
     def isspace(self):
-        return self._ismethod('isspace')
+        """
+        Returns true for each element if there are only whitespace
+        characters in the string and there is at least one character,
+        false otherwise.
+
+        See also
+        --------
+        isspace
+        """
+        return isspace(self)
 
     def istitle(self):
-        return self._ismethod('istitle')
+        """
+        Returns true for each element if the element is a titlecased
+        string and there is at least one character, false otherwise.
+
+        See also
+        --------
+        istitle
+        """
+        return istitle(self)
 
     def isupper(self):
-        return self._ismethod('isupper')
+        """
+        Returns true for each element if all cased characters in the
+        string are uppercase and there is at least one character, false
+        otherwise.
 
-    def join(self, seq):
-        return self._generalmethod('join', broadcast(self, seq))
+        See also
+        --------
+        isupper
+        """
+        return isupper(self)
 
-    def lower(self):
+    def join(self, seq):
         """
-        Assure that every character of each array element is lower-case.
+        Return a string which is the concatenation of the strings in the
+        sequence `seq`.
 
-        For each character possessing both "upper-case" and "lower-case" forms,
-        if it is in upper-case, change it to lower; otherwise, leave it unchanged.
+        See also
+        --------
+        join
+        """
+        return join(self, seq)
 
-        Parameters
-        ----------
-        None
+    if sys.version_info >= (2, 4):
+        def ljust(self, width, fillchar=' '):
+            """
+            Return an array with the elements of `self` left-justified in a
+            string of length `width`.
+
+            See also
+            --------
+            ljust
+            """
+            return asarray(ljust(self, width, fillchar))
+    else:
+        def ljust(self, width):
+            """
+            Return an array with the elements of `self` left-justified in a
+            string of length `width`.
 
-        Returns
-        -------
-        ret : chararray
-            `self` with all capital letters changed to lower-case.
+            See also
+            --------
+            ljust
+            """
+            return asarray(ljust(self, width))
 
-        Examples
+    def lower(self):
+        """
+        Return an array with the elements of `self` converted to
+        lowercase.
+        See also
         --------
-        >>> c = np.array(['A1B C', '1BCA', 'BCA1']).view(np.chararray); c
-        chararray(['A1B C', '1BCA', 'BCA1'],
-              dtype='|S5')
-        >>> c.lower()
-        chararray(['a1b c', '1bca', 'bca1'],
-              dtype='|S5')
-
+        lower
         """
-        return self._samemethod('lower')
+        return asarray(lower(self))
 
-    def lstrip(self, chars):
+    def lstrip(self, chars=None):
         """
-        Remove leading characters from each element.
+        For each element in `self`, return a copy with the leading characters
+        removed.
 
-        Returns a view of ``self`` with `chars` stripped from the start of
-        each element.  Note: **No Default** - `chars` must be specified (but if
-        it is explicitly ``None`` or the empty string '', leading whitespace is
-        removed).
+        See also
+        --------
+        lstrip
+        """
+        return asarray(lstrip(self, chars))
 
-        Parameters
-        ----------
-        chars : string_like or None
-            Character(s) to strip; whitespace stripped if `chars` == ``None``
-            or `chars` == ''.
+    if sys.version_info >= (2, 5):
+        def partition(self, sep):
+            """
+            Partition each element in `self` around `sep`.
 
-        Returns
-        -------
-        ret : chararray
-            View of ``self``, each element suitably stripped.
+            See also
+            --------
+            partition
+            """
+            return asarray(partition(self, sep))
 
-        Raises
-        ------
-        TypeError: lstrip() takes exactly 2 arguments (1 given)
-            If `chars` is not supplied.
+    def replace(self, old, new, count=None):
+        """
+        For each element in `self`, return a copy of the string with all
+        occurrences of substring `old` replaced by `new`.
 
-        Examples
+        See also
         --------
-        >>> c = np.array(['aAaAaA', '  aA  ', 'abBABba']).view(np.chararray)
-        >>> c
-        chararray(['aAaAaA', '  aA', 'abBABba'],
-              dtype='|S7')
-        >>> c.lstrip('a') # 'a' unstripped from c[1] because whitespace leading
-        chararray(['AaAaA', '  aA', 'bBABba'],
-              dtype='|S6')
-        >>> c.lstrip('A') # leaves c unchanged
-        chararray(['aAaAaA', '  aA', 'abBABba'],
-              dtype='|S7')
-        >>> (c.lstrip(' ') == c.lstrip('')).all()
-        True
-        >>> (c.lstrip(' ') == c.lstrip(None)).all()
-        True
-
+        replace
         """
-        return self._generalmethod('lstrip', broadcast(self, chars))
+        return asarray(replace(self, old, new, count))
 
-    def replace(self, old, new, count=None):
-        return self._generalmethod('replace', broadcast(self, old, new, count))
+    def rfind(self, sub, start=0, end=None):
+        """
+        For each element in `self`, return the highest index in the string
+        where substring `sub` is found, such that `sub` is contained
+        within [`start`, `end`].
 
-    def rfind(self, sub, start=None, end=None):
-        return self._typedmethod('rfind', broadcast(self, sub, start, end), int)
+        See also
+        --------
+        rfind
+        """
+        return rfind(self, sub, start, end)
 
-    def rindex(self, sub, start=None, end=None):
-        return self._typedmethod('rindex', broadcast(self, sub, start, end), int)
+    def rindex(self, sub, start=0, end=None):
+        """
+        Like `rfind`, but raises `ValueError` when the substring `sub` is
+        not found.
 
-    def rstrip(self, chars=None):
+        See also
+        --------
+        rindex
         """
-        Remove trailing characters.
+        return rindex(self, sub, start, end)
 
-        Returns a view of ``self`` with `chars` stripped from the end of each
-        element.
+    if sys.version_info >= (2, 4):
+        def rjust(self, width, fillchar=' '):
+            """
+            Return an array with the elements of `self`
+            right-justified in a string of length `width`.
+
+            See also
+            --------
+            rjust
+            """
+            return asarray(rjust(self, width, fillchar))
+    else:
+        def rjust(self, width):
+            """
+            Return an array with the elements of `self`
+            right-justified in a string of length `width`.
+
+            See also
+            --------
+            rjust
+            """
+            return asarray(rjust(self, width))
+
+    if sys.version_info >= (2, 5):
+        def rpartition(self, sep):
+            """
+            Partition each element in `self` around `sep`.
+
+            See also
+            --------
+            rpartition
+            """
+            return asarray(rpartition(self, sep))
+
+    if sys.version_info >= (2, 4):
+        def rsplit(self, sep=None, maxsplit=None):
+            """
+            For each element in `self`, return a list of the words in
+            the string, using `sep` as the delimiter string.
 
-        Parameters
-        ----------
-        chars : string_like, optional, default=None
-            Character(s) to remove.
+            See also
+            --------
+            rsplit
+            """
+            return rsplit(self, sep, maxsplit)
 
-        Returns
-        -------
-        ret : chararray
-            View of ``self``, each element suitably stripped.
+    def rstrip(self, chars=None):
+        """
+        For each element in `self`, return a copy with the trailing
+        characters removed.
 
-        Examples
+        See also
         --------
-        >>> c = np.array(['aAaAaA', 'abBABba'], dtype='S7').view(np.chararray); c
-        chararray(['aAaAaA', 'abBABba'],
-              dtype='|S7')
-        >>> c.rstrip('a')
-        chararray(['aAaAaA', 'abBABb'],
-              dtype='|S6')
-        >>> c.rstrip('A')
-        chararray(['aAaAa', 'abBABba'],
-              dtype='|S7')
-
+        rstrip
         """
-        return self._generalmethod('rstrip', broadcast(self, chars))
+        return asarray(rstrip(self, chars))
 
     def split(self, sep=None, maxsplit=None):
-        return self._typedmethod('split', broadcast(self, sep, maxsplit), object)
+        """
+        For each element in `self`, return a list of the words in the
+        string, using `sep` as the delimiter string.
 
-    def splitlines(self, keepends=None):
-        return self._typedmethod('splitlines', broadcast(self, keepends), object)
+        See also
+        --------
+        split
+        """
+        return split(self, sep, maxsplit)
 
-    def startswith(self, prefix, start=None, end=None):
-        return self._typedmethod('startswith', broadcast(self, prefix, start, end), bool)
+    def splitlines(self, keepends=None):
+        """
+        For each element in `self`, return a list of the lines in the
+        element, breaking at line boundaries.
 
-    def strip(self, chars=None):
+        See also
+        --------
+        splitlines
         """
-        Remove leading and trailing characters, whitespace by default.
+        return splitlines(self, keepends)
 
-        Returns a view of ``self`` with `chars` stripped from the start and end of
-        each element; by default leading and trailing whitespace is removed.
+    def startswith(self, prefix, start=0, end=None):
+        """
+        Returns a boolean array which is `True` where the string element
+        in `self` starts with `prefix`, otherwise `False`.
 
-        Parameters
-        ----------
-        chars : string_like, optional, default=None
-            Character(s) to strip; whitespace by default.
+        See also
+        --------
+        startswith
+        """
+        return startswith(self, prefix, start, end)
 
-        Returns
-        -------
-        ret : chararray
-            View of ``self``, each element suitably stripped.
+    def strip(self, chars=None):
+        """
+        For each element in `self`, return a copy with the leading and
+        trailing characters removed.
 
-        Examples
+        See also
         --------
-        >>> c = np.array(['aAaAaA', '  aA  ', 'abBABba']).view(np.chararray)
-        >>> c
-        chararray(['aAaAaA', '  aA', 'abBABba'],
-              dtype='|S7')
-        >>> c.strip()
-        chararray(['aAaAaA', 'aA', 'abBABba'],
-              dtype='|S7')
-        >>> c.strip('a') # 'a' unstripped from c[1] because whitespace leads
-        chararray(['AaAaA', '  aA', 'bBABb'],
-              dtype='|S6')
-        >>> c.strip('A') # 'A' unstripped from c[1] because (unprinted) ws trails
-        chararray(['aAaAa', '  aA', 'abBABba'],
-              dtype='|S7')
-
+        strip
         """
-        return self._generalmethod('strip', broadcast(self, chars))
+        return asarray(strip(self, chars))
 
     def swapcase(self):
         """
-        Switch upper-case letters to lower-case, and vice-versa.
+        For each element in `self`, return a copy of the string with
+        uppercase characters converted to lowercase and vice versa.
 
-        Parameters
-        ----------
-        None
+        See also
+        --------
+        swapcase
+        """
+        return asarray(swapcase(self))
 
-        Returns
-        -------
-        ret : chararray
-            `self` with all lower-case letters capitalized and all upper-case
-            changed to lower case.
+    def title(self):
+        """
+        For each element in `self`, return a titlecased version of the
+        string: words start with uppercase characters, all remaining cased
+        characters are lowercase.
 
-        Examples
+        See also
         --------
-        >>> c=np.array(['a1B c','1b Ca','b Ca1','cA1b'],'S5').view(np.chararray);c
-        chararray(['a1B c', '1b Ca', 'b Ca1', 'cA1b'],
-              dtype='|S5')
-        >>> c.swapcase()
-        chararray(['A1b C', '1B cA', 'B cA1', 'Ca1B'],
-              dtype='|S5')
+        title
+        """
+        return asarray(title(self))
 
+    def translate(self, table, deletechars=None):
         """
-        return self._samemethod('swapcase')
+        For each element in `self`, return a copy of the string where
+        all characters occurring in the optional argument
+        `deletechars` are removed, and the remaining characters have
+        been mapped through the given translation table.
 
-    def title(self):
+        See also
+        --------
+        translate
         """
-        Capitalize the first character of each array element.
+        return asarray(translate(self, table, deletechars))
 
-        For each element of `self`, if the first character is a letter
-        possessing both "upper-case" and "lower-case" forms, and it is
-        presently in lower-case, change it to upper-case; otherwise, leave
-        it untouched.
+    def upper(self):
+        """
+        Return an array with the elements of `self` converted to
+        uppercase.
 
-        Parameters
-        ----------
-        None
+        See also
+        --------
+        upper
+        """
+        return asarray(upper(self))
 
-        Returns
-        -------
-        ret : chararray
-            `self` with
+    def zfill(self, width):
+        """
+        Return the numeric string left-filled with zeros in a string of
+        length `width`.
 
-        Examples
+        See also
         --------
-        >>> c=np.array(['a1b c','1b ca','b ca1','ca1b'],'S5').view(np.chararray);c
-        chararray(['a1b c', '1b ca', 'b ca1', 'ca1b'],
-              dtype='|S5')
-        >>> c.title()
-        chararray(['A1B C', '1B Ca', 'B Ca1', 'Ca1B'],
-              dtype='|S5')
+        zfill
+        """
+        return asarray(zfill(self, width))
 
+    def isnumeric(self):
         """
-        return self._samemethod('title')
+        For each element in `self`, return True if there are only
+        numeric characters in the element.
 
-    def translate(self, table, deletechars=None):
-        if self.dtype is unicode_:
-            return self._generalmethod('translate', broadcast(self, table))
-        else:
-            return self._generalmethod('translate', broadcast(self, table, deletechars))
+        See also
+        --------
+        isnumeric
+        """
+        return isnumeric(self)
 
-    def upper(self):
+    def isdecimal(self):
         """
-        Capitalize every character of each array element.
+        For each element in `self`, return True if there are only
+        decimal characters in the element.
 
-        For each character possessing both "upper-case" and "lower-case" forms,
-        if it is in lower-case, change it to upper; otherwise, leave it unchanged.
+        See also
+        --------
+        isdecimal
+        """
+        return isdecimal(self)
 
-        Parameters
-        ----------
-        None
 
-        Returns
-        -------
-        ret : chararray
-            `self` with all characters capitalized.
+def array(obj, itemsize=None, copy=True, unicode=None, order=None):
+    """
+    Create a `chararray`.
 
-        Examples
-        --------
-        >>> c = np.array(['a1b c', '1bca', 'bca1']).view(np.chararray); c
-        chararray(['a1b c', '1bca', 'bca1'],
-              dtype='|S5')
-        >>> c.upper()
-        chararray(['A1B C', '1BCA', 'BCA1'],
-              dtype='|S5')
+    .. note::
+       This class is provided for numarray backward-compatibility.
+       New code (not concerned with numarray compatibility) should use
+       arrays of type object_, string_ or unicode_ and use the free
+       functions in :mod:`numpy.char <numpy.core.defchararray>` for
+       fast vectorized string operations instead.
 
-        """
-        return self._samemethod('upper')
+    Versus a regular Numpy array of type `string_` or `unicode_`, this
+    class adds the following functionality:
 
-    def zfill(self, width):
-        return self._generalmethod('zfill', broadcast(self, width))
+      1) values automatically have whitespace removed from the end
+         when indexed
 
+      2) comparison operators automatically remove whitespace from the
+         end when comparing values
 
-def array(obj, itemsize=None, copy=True, unicode=False, order=None):
+      3) vectorized string operations are provided as methods
+         (e.g. `str.endswith`) and infix operators (e.g. +, *, %)
+
+    Parameters
+    ----------
+    obj : array of str or unicode-like
+
+    itemsize : int, optional
+        `itemsize` is the number of characters per scalar in the
+        resulting array.  If `itemsize` is None, and `obj` is an
+        object array or a Python list, the `itemsize` will be
+        automatically determined.  If `itemsize` is provided and `obj`
+        is of type `str` or `unicode`, then the `obj` string will be
+        chunked into `itemsize` pieces.
+
+    copy : bool, optional
+        If true (default), then the object is copied.  Otherwise, a copy
+        will only be made if __array__ returns a copy, if obj is a
+        nested sequence, or if a copy is needed to satisfy any of the other
+        requirements (`itemsize`, `unicode`, `order`, etc.).
+
+    unicode : bool, optional
+        When true, the resulting `chararray` can contain Unicode
+        characters, when false only 8-bit characters.  If `unicode` is
+        `None` and `obj` is one of the following:
+
+          - a `chararray`,
+          - an ndarray of type `string_` or `unicode_`
+          - a Python str or unicode object,
+
+        then the unicode setting of the output array will be
+        automatically determined.
+
+    order : {'C', 'F', 'A'}, optional
+        Specify the order of the array.  If order is 'C' (default), then the
+        array will be in C-contiguous order (last-index varies the
+        fastest).  If order is 'F', then the returned array
+        will be in Fortran-contiguous order (first-index varies the
+        fastest).  If order is 'A', then the returned array may
+        be in any order (either C-, Fortran-contiguous, or even
+        discontiguous).
+    """
+    if isinstance(obj, (str, _unicode)):
+        if unicode is None:
+            if isinstance(obj, _unicode):
+                unicode = True
+            else:
+                unicode = False
+        if itemsize is None:
+            itemsize = _len(obj)
+        shape = _len(obj) / itemsize
+        return chararray(shape, itemsize=itemsize, unicode=unicode,
+                         buffer=obj, order=order)
+
+    if isinstance(obj, (list, tuple)):
+        obj = numpy.asarray(obj)
+
+    if isinstance(obj, ndarray) and issubclass(obj.dtype.type, character):
+        # If we just have a vanilla chararray, create a chararray
+        # view around it.
+        if not isinstance(obj, chararray):
+            obj = obj.view(chararray)
 
-    if isinstance(obj, chararray):
         if itemsize is None:
             itemsize = obj.itemsize
-        if copy or (itemsize != obj.itemsize) \
-           or (not unicode and obj.dtype == unicode_) \
-           or (unicode and obj.dtype == string_):
-            return obj.astype("%s%d" % (obj.dtype.char, itemsize))
+            # itemsize is in 8-bit chars, so for Unicode, we need
+            # to divide by the size of a single Unicode character,
+            # which for Numpy is always 4
+            if issubclass(obj.dtype.type, unicode_):
+                itemsize /= 4
+
+        if unicode is None:
+            if issubclass(obj.dtype.type, unicode_):
+                unicode = True
+            else:
+                unicode = False
+
+        if unicode:
+            dtype = unicode_
         else:
-            return obj
+            dtype = string_
 
-    if isinstance(obj, ndarray) and (obj.dtype in [unicode_, string_]):
-        new = obj.view(chararray)
-        if unicode and obj.dtype == string_:
-            return new.astype((unicode_, obj.itemsize))
-        elif obj.dtype == unicode_:
-            return new.astype((string_, obj.itemsize))
+        if order is not None:
+            obj = numpy.asarray(obj, order=order)
+        if (copy
+            or (itemsize != obj.itemsize)
+            or (not unicode and isinstance(obj, unicode_))
+            or (unicode and isinstance(obj, string_))):
+            obj = obj.astype((dtype, long(itemsize)))
+        return obj
 
-        if copy: return new.copy()
-        else: return new
+    if isinstance(obj, ndarray) and issubclass(obj.dtype.type, object):
+        if itemsize is None:
+            # Since no itemsize was specified, convert the input array to
+            # a list so the ndarray constructor will automatically
+            # determine the itemsize for us.
+            obj = obj.tolist()
+            # Fall through to the default case
+
+    if unicode:
+        dtype = unicode_
+    else:
+        dtype = string_
 
-    if unicode: dtype = "U"
-    else: dtype = "S"
+    if itemsize is None:
+        val = narray(obj, dtype=dtype, order=order, subok=True)
+    else:
+        val = narray(obj, dtype=(dtype, itemsize), order=order, subok=True)
+    return val.view(chararray)
 
-    if itemsize is not None:
-        dtype += str(itemsize)
 
-    if isinstance(obj, (str, _unicode)):
-        if itemsize is None:
-            itemsize = len(obj)
-        shape = len(obj) / itemsize
-        return chararray(shape, itemsize=itemsize, unicode=unicode,
-                         buffer=obj)
+def asarray(obj, itemsize=None, unicode=None, order=None):
+    """
+    Convert the input to a `chararray`, copying the data only if
+    necessary.
 
-    # default
-    val = narray(obj, dtype=dtype, order=order, subok=1)
+    Versus a regular Numpy array of type `string_` or `unicode_`, this
+    class adds the following functionality:
 
-    return val.view(chararray)
+      1) values automatically have whitespace removed from the end
+         when indexed
+
+      2) comparison operators automatically remove whitespace from the
+         end when comparing values
+
+      3) vectorized string operations are provided as methods
+         (e.g. `str.endswith`) and infix operators (e.g. +, *, %)
+
+    Parameters
+    ----------
+    obj : array of str or unicode-like
 
-def asarray(obj, itemsize=None, unicode=False, order=None):
+    itemsize : int, optional
+        `itemsize` is the number of characters per scalar in the
+        resulting array.  If `itemsize` is None, and `obj` is an
+        object array or a Python list, the `itemsize` will be
+        automatically determined.  If `itemsize` is provided and `obj`
+        is of type `str` or `unicode`, then the `obj` string will be
+        chunked into `itemsize` pieces.
+
+    unicode : bool, optional
+        When true, the resulting `chararray` can contain Unicode
+        characters, when false only 8-bit characters.  If `unicode` is
+        `None` and `obj` is one of the following:
+
+          - a `chararray`,
+          - an ndarray of type `string_` or 'unicode_`
+          - a Python str or unicode object,
+
+        then the unicode setting of the output array will be
+        automatically determined.
+
+    order : {'C', 'F'}, optional
+        Specify the order of the array.  If order is 'C' (default), then the
+        array will be in C-contiguous order (last-index varies the
+        fastest).  If order is 'F', then the returned array
+        will be in Fortran-contiguous order (first-index varies the
+        fastest).
+    """
     return array(obj, itemsize, copy=False,
                  unicode=unicode, order=order)
diff --git a/numpy/core/src/multiarray/arraytypes.c.src b/numpy/core/src/multiarray/arraytypes.c.src
index 1021f8d7f..9cff6836e 100644
--- a/numpy/core/src/multiarray/arraytypes.c.src
+++ b/numpy/core/src/multiarray/arraytypes.c.src
@@ -1333,7 +1333,7 @@ static void
  *           longlong, ulonglong, float, double, longdouble,
  *           cfloat, cdouble, clongdouble, char, char, char, datetime,
  *           timedelta#
- * #skip = 1*17, aip->descr->elsize*3, 1*2#
+ * #skip = 1*17, aop->descr->elsize*3, 1*2#
  */
 static void
 OBJECT_to_@TOTYPE@(PyObject **ip, @totype@ *op, intp n,
@@ -1389,7 +1389,10 @@ static void
                 return;
             }
         }
-        @to@_setitem(temp,(char *)op, aop);
+        if (@to@_setitem(temp,(char *)op, aop)) {
+            Py_DECREF(temp);
+            return;
+        }
         Py_DECREF(temp);
     }
 }
@@ -1417,7 +1420,10 @@ static void
             Py_INCREF(Py_False);
             temp = Py_False;
         }
-        @to@_setitem(temp,(char *)op, aop);
+        if (@to@_setitem(temp,(char *)op, aop)) {
+            Py_DECREF(temp);
+            return;
+        }
         Py_DECREF(temp);
     }
 }
@@ -3146,7 +3152,7 @@ NPY_NO_EXPORT PyArray_Descr @from@_Descr = {
 /**end repeat**/
 
 static void
-_init_datetime_descr(PyArray_Descr *descr) 
+_init_datetime_descr(PyArray_Descr *descr)
 {
     PyArray_DatetimeMetaData *dt_data;
     PyObject *cobj;
@@ -3156,12 +3162,12 @@ _init_datetime_descr(PyArray_Descr *descr)
     dt_data->num = 1;
     dt_data->den = 1;
     dt_data->events = 1;
-    
+
     cobj = PyCObject_FromVoidPtr((void *)dt_data, _pya_free);
     descr->metadata = PyDict_New();
     PyDict_SetItemString(descr->metadata, NPY_METADATA_DTSTR, cobj);
     Py_DECREF(cobj);
-    
+
 }
 
 #define _MAX_LETTER 128
@@ -3251,7 +3257,7 @@ PyArray_DescrFromType(int type)
 	    _init_datetime_descr(ret);
 	}
     }
-    
+
     return ret;
 }
 
diff --git a/numpy/core/src/multiarray/common.c b/numpy/core/src/multiarray/common.c
index ae1d264f7..80b676a38 100644
--- a/numpy/core/src/multiarray/common.c
+++ b/numpy/core/src/multiarray/common.c
@@ -8,7 +8,7 @@
 #include "npy_config.h"
 
 #include "usertypes.h"
- 
+
 #include "common.h"
 
 /*
@@ -66,6 +66,10 @@ _array_small_type(PyArray_Descr *chktype, PyArray_Descr* mintype)
             mintype->type_num == PyArray_STRING) {
             testsize = MAX(chksize, 4*minsize);
         }
+        else if (chktype->type_num == PyArray_STRING &&
+                 mintype->type_num == PyArray_UNICODE) {
+            testsize = MAX(chksize*4, minsize);
+        }
         else {
             testsize = MAX(chksize, minsize);
         }
diff --git a/numpy/core/src/multiarray/multiarraymodule.c b/numpy/core/src/multiarray/multiarraymodule.c
index 17c72aa6b..30def71e3 100644
--- a/numpy/core/src/multiarray/multiarraymodule.c
+++ b/numpy/core/src/multiarray/multiarraymodule.c
@@ -1796,7 +1796,7 @@ static PyObject *array_correlate(PyObject *NPY_UNUSED(dummy), PyObject *args, Py
 }
 
 static PyObject*
-array_correlate2(PyObject *NPY_UNUSED(dummy), PyObject *args, PyObject *kwds) 
+array_correlate2(PyObject *NPY_UNUSED(dummy), PyObject *args, PyObject *kwds)
 {
     PyObject *shape, *a0;
     int mode = 0;
@@ -1979,10 +1979,10 @@ array_set_datetimeparse_function(PyObject *NPY_UNUSED(dummy), PyObject *args, Py
 	    PyErr_SetString(PyExc_TypeError, "Argument must be callable.");
 	    return NULL;
 	}
-	Py_INCREF(op);		
+	Py_INCREF(op);
     }
     PyArray_SetDatetimeParseFunction(op);
-    Py_DECREF(op);  
+    Py_DECREF(op);
     Py_INCREF(Py_None);
     return Py_None;
 }
@@ -2316,6 +2316,221 @@ compare_chararrays(PyObject *NPY_UNUSED(dummy), PyObject *args, PyObject *kwds)
     return NULL;
 }
 
+static PyObject *
+_vec_string_with_args(PyArrayObject* char_array, PyArray_Descr* type,
+                      PyObject* method, PyObject* args)
+{
+    PyObject* broadcast_args[NPY_MAXARGS];
+    PyArrayMultiIterObject* in_iter = NULL;
+    PyArrayObject* result = NULL;
+    PyArrayIterObject* out_iter = NULL;
+    PyObject* args_tuple = NULL;
+    Py_ssize_t i, n, nargs;
+
+    nargs = PySequence_Size(args) + 1;
+    if (nargs == -1 || nargs > NPY_MAXARGS) {
+        PyErr_Format(PyExc_ValueError, "len(args) must be < %d", NPY_MAXARGS - 1);
+        goto err;
+    }
+
+    broadcast_args[0] = (PyObject*)char_array;
+    for (i = 1; i < nargs; i++) {
+        PyObject* item = PySequence_GetItem(args, i-1);
+        if (item == NULL) {
+            goto err;
+        }
+        broadcast_args[i] = item;
+        Py_DECREF(item);
+    }
+    in_iter = (PyArrayMultiIterObject*)PyArray_MultiIterFromObjects
+        (broadcast_args, nargs, 0);
+    if (in_iter == NULL) {
+        goto err;
+    }
+    n = in_iter->numiter;
+
+    result = (PyArrayObject*)PyArray_SimpleNewFromDescr
+        (in_iter->nd, in_iter->dimensions, type);
+    if (result == NULL) {
+        goto err;
+    }
+
+    out_iter = (PyArrayIterObject*)PyArray_IterNew((PyObject*)result);
+    if (out_iter == NULL) {
+        goto err;
+    }
+
+    args_tuple = PyTuple_New(n);
+    if (args_tuple == NULL) {
+        goto err;
+    }
+
+    while (PyArray_MultiIter_NOTDONE(in_iter)) {
+        for (i = 0; i < n; i++) {
+            PyArrayIterObject* it = in_iter->iters[i];
+            PyObject* arg = PyArray_ToScalar(PyArray_ITER_DATA(it), it->ao);
+            if (arg == NULL) {
+                goto err;
+            }
+            PyTuple_SetItem(args_tuple, i, arg); /* Steals ref to arg */
+        }
+
+        PyObject* item_result = PyObject_CallObject(method, args_tuple);
+        if (item_result == NULL) {
+            goto err;
+        }
+
+        if (PyArray_SETITEM(result, PyArray_ITER_DATA(out_iter), item_result)) {
+            Py_DECREF(item_result);
+            PyErr_SetString(
+                PyExc_TypeError,
+                "result array type does not match underlying function");
+            goto err;
+        }
+        Py_DECREF(item_result);
+
+        PyArray_MultiIter_NEXT(in_iter);
+        PyArray_ITER_NEXT(out_iter);
+    }
+
+    Py_DECREF(in_iter);
+    Py_DECREF(out_iter);
+    Py_DECREF(args_tuple);
+
+    return (PyObject*)result;
+
+ err:
+    Py_XDECREF(in_iter);
+    Py_XDECREF(out_iter);
+    Py_XDECREF(args_tuple);
+    Py_XDECREF(result);
+
+    return 0;
+}
+
+static PyObject *
+_vec_string_no_args(PyArrayObject* char_array,
+                                   PyArray_Descr* type, PyObject* method)
+{
+    /* This is a faster version of _vec_string_args to use when there
+       are no additional arguments to the string method.  This doesn't
+       require a broadcast iterator (and broadcast iterators don't work
+       with 1 argument anyway). */
+    PyArrayIterObject* in_iter = NULL;
+    PyArrayObject* result = NULL;
+    PyArrayIterObject* out_iter = NULL;
+
+    in_iter = (PyArrayIterObject*)PyArray_IterNew((PyObject*)char_array);
+    if (in_iter == NULL) {
+        goto err;
+    }
+
+    result = (PyArrayObject*)PyArray_SimpleNewFromDescr
+        (PyArray_NDIM(char_array), PyArray_DIMS(char_array), type);
+    if (result == NULL) {
+        goto err;
+    }
+
+    out_iter = (PyArrayIterObject*)PyArray_IterNew((PyObject*)result);
+    if (out_iter == NULL) {
+        goto err;
+    }
+
+    while (PyArray_ITER_NOTDONE(in_iter)) {
+        PyObject* item = PyArray_ToScalar(in_iter->dataptr, in_iter->ao);
+        if (item == NULL) {
+            goto err;
+        }
+
+        PyObject* item_result = PyObject_CallFunctionObjArgs(method, item, NULL);
+        Py_DECREF(item);
+        if (item_result == NULL) {
+            goto err;
+        }
+
+        if (PyArray_SETITEM(result, PyArray_ITER_DATA(out_iter), item_result)) {
+            Py_DECREF(item_result);
+            PyErr_SetString(
+                PyExc_TypeError,
+                "result array type does not match underlying function");
+            goto err;
+        }
+        Py_DECREF(item_result);
+
+        PyArray_ITER_NEXT(in_iter);
+        PyArray_ITER_NEXT(out_iter);
+    }
+
+    Py_DECREF(in_iter);
+    Py_DECREF(out_iter);
+
+    return (PyObject*)result;
+
+ err:
+    Py_XDECREF(in_iter);
+    Py_XDECREF(out_iter);
+    Py_XDECREF(result);
+
+    return 0;
+}
+
+static PyObject *
+_vec_string(PyObject *NPY_UNUSED(dummy), PyObject *args, PyObject *kwds)
+{
+    PyArrayObject* char_array = NULL;
+    PyArray_Descr *type = NULL;
+    PyObject* method_name;
+    PyObject* args_seq = NULL;
+
+    PyObject* method = NULL;
+    PyObject* result = NULL;
+
+    if (!PyArg_ParseTuple(args, "O&O&O|O",
+                          PyArray_Converter,
+                          &char_array,
+                          PyArray_DescrConverter,
+                          &type,
+                          &method_name,
+                          &args_seq)) {
+        goto err;
+    }
+
+    if (PyArray_TYPE(char_array) == NPY_STRING) {
+        method = PyObject_GetAttr((PyObject *)&PyString_Type, method_name);
+    } else if (PyArray_TYPE(char_array) == NPY_UNICODE) {
+        method = PyObject_GetAttr((PyObject *)&PyUnicode_Type, method_name);
+    } else {
+        PyErr_SetString(PyExc_TypeError, "string operation on non-string array");
+        goto err;
+    }
+    if (method == NULL) {
+        goto err;
+    }
+
+    if (args_seq == NULL ||
+        (PySequence_Check(args_seq) && PySequence_Size(args_seq) == 0)) {
+        result = _vec_string_no_args(char_array, type, method);
+    } else if (PySequence_Check(args_seq)) {
+        result = _vec_string_with_args(char_array, type, method, args_seq);
+    } else {
+        PyErr_SetString(PyExc_TypeError, "'args' must be a sequence of arguments");
+        goto err;
+    }
+    if (result == NULL) {
+        goto err;
+    }
+
+    Py_DECREF(char_array);
+    Py_DECREF(method);
+
+    return (PyObject*)result;
+
+ err:
+    Py_XDECREF(char_array);
+    Py_XDECREF(method);
+
+    return 0;
+}
 
 #ifndef __NPY_PRIVATE_NO_SIGNAL
 
@@ -2397,7 +2612,7 @@ static struct PyMethodDef array_module_methods[] = {
     {"set_numeric_ops",
         (PyCFunction)array_set_ops_function,
         METH_VARARGS|METH_KEYWORDS, NULL},
-    {"set_datetimeparse_function", 
+    {"set_datetimeparse_function",
         (PyCFunction)array_set_datetimeparse_function,
         METH_VARARGS|METH_KEYWORDS, NULL},
     {"set_typeDict",
@@ -2475,6 +2690,9 @@ static struct PyMethodDef array_module_methods[] = {
     {"compare_chararrays",
         (PyCFunction)compare_chararrays,
         METH_VARARGS | METH_KEYWORDS, NULL},
+    {"_vec_string",
+        (PyCFunction)_vec_string,
+        METH_VARARGS | METH_KEYWORDS, NULL},
     {"test_interrupt",
         (PyCFunction)test_interrupt,
         METH_VARARGS, NULL},
@@ -2729,7 +2947,7 @@ PyMODINIT_FUNC initmultiarray(void) {
     if (PyErr_Occurred()) {
         goto err;
     }
-    
+
     /*
      * PyExc_Exception should catch all the standard errors that are
      * now raised instead of the string exception "multiarray.error"
diff --git a/numpy/core/tests/test_defchararray.py b/numpy/core/tests/test_defchararray.py
index f5053edb6..723f7b598 100644
--- a/numpy/core/tests/test_defchararray.py
+++ b/numpy/core/tests/test_defchararray.py
@@ -1,15 +1,111 @@
 from numpy.testing import *
 from numpy.core import *
 import numpy as np
+import sys
+from numpy.core.multiarray import _vec_string
 
 class TestBasic(TestCase):
-    def test_construction(self):
-        A = np.array([['abc', '123'],
-                      ['789', 'xyz']])
-        A1 = A.view(np.chararray)
-        A2 = np.chararray.__new__(np.chararray, A.shape, itemsize=A.itemsize,
-                                  buffer=A)
-        assert all(A1 == A2)
+    def test_from_object_array(self):
+        A = np.array([['abc', 2],
+                      ['long   ', '0123456789']], dtype='O')
+        B = np.char.array(A)
+        assert_equal(B.dtype.itemsize, 10)
+        assert_array_equal(B, [['abc', '2'], ['long', '0123456789']])
+
+    def test_from_object_array_unicode(self):
+        A = np.array([['abc', u'Sigma \u03a3'],
+                      ['long   ', '0123456789']], dtype='O')
+        self.failUnlessRaises(ValueError, np.char.array, (A,))
+        B = np.char.array(A, unicode=True)
+        assert_equal(B.dtype.itemsize, 10 * np.array('a', 'U').dtype.itemsize)
+        assert_array_equal(B, [['abc', u'Sigma \u03a3'], ['long', '0123456789']])
+
+    def test_from_string_array(self):
+        A = np.array([['abc', 'foo'],
+                      ['long   ', '0123456789']])
+        assert_equal(A.dtype.type, np.string_)
+        B = np.char.array(A)
+        assert_array_equal(B, A)
+        assert_equal(B.dtype, A.dtype)
+        assert_equal(B.shape, A.shape)
+        B[0,0] = 'changed'
+        assert B[0,0] != A[0,0]
+        C = np.char.asarray(A)
+        assert_array_equal(C, A)
+        assert_equal(C.dtype, A.dtype)
+        C[0,0] = 'changed again'
+        assert C[0,0] != B[0,0]
+        assert C[0,0] == A[0,0]
+
+    def test_from_unicode_array(self):
+        A = np.array([['abc', u'Sigma \u03a3'],
+                      ['long   ', '0123456789']])
+        assert_equal(A.dtype.type, np.unicode_)
+        B = np.char.array(A)
+        assert_array_equal(B, A)
+        assert_equal(B.dtype, A.dtype)
+        assert_equal(B.shape, A.shape)
+        B = np.char.array(A, unicode=True)
+        assert_array_equal(B, A)
+        assert_equal(B.dtype, A.dtype)
+        assert_equal(B.shape, A.shape)
+        def fail():
+            B = np.char.array(A, unicode=False)
+        self.failUnlessRaises(UnicodeEncodeError, fail)
+
+    def test_unicode_upconvert(self):
+        A = np.char.array(['abc'])
+        B = np.char.array([u'\u03a3'])
+        assert issubclass((A + B).dtype.type, np.unicode_)
+
+    def test_from_string(self):
+        A = np.char.array('abc')
+        assert_equal(len(A), 1)
+        assert_equal(len(A[0]), 3)
+        assert issubclass(A.dtype.type, np.string_)
+
+    def test_from_unicode(self):
+        A = np.char.array(u'\u03a3')
+        assert_equal(len(A), 1)
+        assert_equal(len(A[0]), 1)
+        assert_equal(A.itemsize, 4)
+        assert issubclass(A.dtype.type, np.unicode_)
+
+class TestVecString(TestCase):
+    def test_non_existent_method(self):
+        def fail():
+            _vec_string('a', np.string_, 'bogus')
+        self.failUnlessRaises(AttributeError, fail)
+
+    def test_non_string_array(self):
+        def fail():
+            _vec_string(1, np.string_, 'strip')
+        self.failUnlessRaises(TypeError, fail)
+
+    def test_invalid_args_tuple(self):
+        def fail():
+            _vec_string(['a'], np.string_, 'strip', 1)
+        self.failUnlessRaises(TypeError, fail)
+
+    def test_invalid_type_descr(self):
+        def fail():
+            _vec_string(['a'], 'BOGUS', 'strip')
+        self.failUnlessRaises(TypeError, fail)
+
+    def test_invalid_function_args(self):
+        def fail():
+            _vec_string(['a'], np.string_, 'strip', (1,))
+        self.failUnlessRaises(TypeError, fail)
+
+    def test_invalid_result_type(self):
+        def fail():
+            _vec_string(['a'], np.integer, 'strip')
+        self.failUnlessRaises(TypeError, fail)
+
+    def test_broadcast_error(self):
+        def fail():
+            _vec_string([['abc', 'def']], np.integer, 'find', (['a', 'd', 'j'],))
+        self.failUnlessRaises(ValueError, fail)
 
 
 class TestWhitespace(TestCase):
@@ -21,15 +117,394 @@ class TestWhitespace(TestCase):
 
     def test1(self):
         assert all(self.A == self.B)
-
+        assert all(self.A >= self.B)
+        assert all(self.A <= self.B)
+        assert all(negative(self.A > self.B))
+        assert all(negative(self.A < self.B))
+        assert all(negative(self.A != self.B))
 
 class TestChar(TestCase):
     def setUp(self):
         self.A = np.array('abc1', dtype='c').view(np.chararray)
 
     def test_it(self):
-        assert self.A.shape == (4,)
-        assert self.A.upper()[:2].tostring() == 'AB'    
+        assert_equal(self.A.shape, (4,))
+        assert_equal(self.A.upper()[:2].tostring(), 'AB')
+
+class TestComparisons(TestCase):
+    def setUp(self):
+        self.A = np.array([['abc', '123'],
+                           ['789', 'xyz']]).view(np.chararray)
+        self.B = np.array([['efg', '123  '],
+                           ['051', 'tuv']]).view(np.chararray)
+
+    def test_not_equal(self):
+        assert_array_equal((self.A != self.B), [[True, False], [True, True]])
+
+    def test_equal(self):
+        assert_array_equal((self.A == self.B), [[False, True], [False, False]])
+
+    def test_greater_equal(self):
+        assert_array_equal((self.A >= self.B), [[False, True], [True, True]])
+
+    def test_less_equal(self):
+        assert_array_equal((self.A <= self.B), [[True, True], [False, False]])
+
+    def test_greater(self):
+        assert_array_equal((self.A > self.B), [[False, False], [True, True]])
+
+    def test_less(self):
+        assert_array_equal((self.A < self.B), [[True, False], [False, False]])
+
+class TestInformation(TestCase):
+    def setUp(self):
+        self.A = np.array([[' abc ', ''],
+                           ['12345', 'MixedCase'],
+                           ['123 \t 345 \0 ', 'UPPER']]).view(np.chararray)
+        self.B = np.array([[u' \u03a3 ', u''],
+                           [u'12345', u'MixedCase'],
+                           [u'123 \t 345 \0 ', u'UPPER']]).view(np.chararray)
+
+    def test_len(self):
+        assert issubclass(np.char.str_len(self.A).dtype.type, np.integer)
+        assert_array_equal(np.char.str_len(self.A), [[5, 0], [5, 9], [12, 5]])
+        assert_array_equal(np.char.str_len(self.B), [[3, 0], [5, 9], [12, 5]])
+
+    def test_count(self):
+        assert issubclass(self.A.count('').dtype.type, np.integer)
+        assert_array_equal(self.A.count('a'), [[1, 0], [0, 1], [0, 0]])
+        assert_array_equal(self.A.count('123'), [[0, 0], [1, 0], [1, 0]])
+        # Python doesn't seem to like counting NULL characters
+        # assert_array_equal(self.A.count('\0'), [[0, 0], [0, 0], [1, 0]])
+        assert_array_equal(self.A.count('a', 0, 2), [[1, 0], [0, 0], [0, 0]])
+        assert_array_equal(self.B.count('a'), [[0, 0], [0, 1], [0, 0]])
+        assert_array_equal(self.B.count('123'), [[0, 0], [1, 0], [1, 0]])
+        # assert_array_equal(self.B.count('\0'), [[0, 0], [0, 0], [1, 0]])
+
+    def test_endswith(self):
+        assert issubclass(self.A.endswith('').dtype.type, np.bool_)
+        assert_array_equal(self.A.endswith(' '), [[1, 0], [0, 0], [1, 0]])
+        assert_array_equal(self.A.endswith('3', 0, 3), [[0, 0], [1, 0], [1, 0]])
+        def fail():
+            self.A.endswith('3', 'fdjk')
+        self.failUnlessRaises(TypeError, fail)
+
+    def test_find(self):
+        assert issubclass(self.A.find('a').dtype.type, np.integer)
+        assert_array_equal(self.A.find('a'), [[1, -1], [-1, 6], [-1, -1]])
+        assert_array_equal(self.A.find('3'), [[-1, -1], [2, -1], [2, -1]])
+        assert_array_equal(self.A.find('a', 0, 2), [[1, -1], [-1, -1], [-1, -1]])
+        assert_array_equal(self.A.find(['1', 'P']), [[-1, -1], [0, -1], [0, 1]])
+
+    def test_index(self):
+        def fail():
+            self.A.index('a')
+        self.failUnlessRaises(ValueError, fail)
+        assert np.char.index('abcba', 'b') == 1
+        assert issubclass(np.char.index('abcba', 'b').dtype.type, np.integer)
+
+    def test_isalnum(self):
+        assert issubclass(self.A.isalnum().dtype.type, np.bool_)
+        assert_array_equal(self.A.isalnum(), [[False, False], [True, True], [False, True]])
+
+    def test_isalpha(self):
+        assert issubclass(self.A.isalpha().dtype.type, np.bool_)
+        assert_array_equal(self.A.isalpha(), [[False, False], [False, True], [False, True]])
+
+    def test_isdigit(self):
+        assert issubclass(self.A.isdigit().dtype.type, np.bool_)
+        assert_array_equal(self.A.isdigit(), [[False, False], [True, False], [False, False]])
+
+    def test_islower(self):
+        assert issubclass(self.A.islower().dtype.type, np.bool_)
+        assert_array_equal(self.A.islower(), [[True, False], [False, False], [False, False]])
+
+    def test_isspace(self):
+        assert issubclass(self.A.isspace().dtype.type, np.bool_)
+        assert_array_equal(self.A.isspace(), [[False, False], [False, False], [False, False]])
+
+    def test_istitle(self):
+        assert issubclass(self.A.istitle().dtype.type, np.bool_)
+        assert_array_equal(self.A.istitle(), [[False, False], [False, False], [False, False]])
+
+    def test_isupper(self):
+        assert issubclass(self.A.isupper().dtype.type, np.bool_)
+        assert_array_equal(self.A.isupper(), [[False, False], [False, False], [False, True]])
+
+    def test_rfind(self):
+        assert issubclass(self.A.rfind('a').dtype.type, np.integer)
+        assert_array_equal(self.A.rfind('a'), [[1, -1], [-1, 6], [-1, -1]])
+        assert_array_equal(self.A.rfind('3'), [[-1, -1], [2, -1], [6, -1]])
+        assert_array_equal(self.A.rfind('a', 0, 2), [[1, -1], [-1, -1], [-1, -1]])
+        assert_array_equal(self.A.rfind(['1', 'P']), [[-1, -1], [0, -1], [0, 2]])
+
+    def test_rindex(self):
+        def fail():
+            self.A.rindex('a')
+        self.failUnlessRaises(ValueError, fail)
+        assert np.char.rindex('abcba', 'b') == 3
+        assert issubclass(np.char.rindex('abcba', 'b').dtype.type, np.integer)
+
+    def test_startswith(self):
+        assert issubclass(self.A.startswith('').dtype.type, np.bool_)
+        assert_array_equal(self.A.startswith(' '), [[1, 0], [0, 0], [0, 0]])
+        assert_array_equal(self.A.startswith('1', 0, 3), [[0, 0], [1, 0], [1, 0]])
+        def fail():
+            self.A.startswith('3', 'fdjk')
+        self.failUnlessRaises(TypeError, fail)
+
+
+class TestMethods(TestCase):
+    def setUp(self):
+        self.A = np.array([[' abc ', ''],
+                           ['12345', 'MixedCase'],
+                           ['123 \t 345 \0 ', 'UPPER']]).view(np.chararray)
+        self.B = np.array([[u' \u03a3 ', u''],
+                           [u'12345', u'MixedCase'],
+                           [u'123 \t 345 \0 ', u'UPPER']]).view(np.chararray)
+
+    def test_capitalize(self):
+        assert issubclass(self.A.capitalize().dtype.type, np.string_)
+        assert_array_equal(self.A.capitalize(), [
+                [' abc ', ''],
+                ['12345', 'Mixedcase'],
+                ['123 \t 345 \0 ', 'Upper']])
+        assert issubclass(self.B.capitalize().dtype.type, np.unicode_)
+        assert_array_equal(self.B.capitalize(), [
+                [u' \u03c3 ', ''],
+                ['12345', 'Mixedcase'],
+                ['123 \t 345 \0 ', 'Upper']])
+
+    def test_center(self):
+        assert issubclass(self.A.center(10).dtype.type, np.string_)
+        widths = np.array([[10, 20]])
+        C = self.A.center([10, 20])
+        assert_array_equal(np.char.str_len(C), [[10, 20], [10, 20], [12, 20]])
+        C = self.A.center(20, '#')
+        assert np.all(C.startswith('#'))
+        assert np.all(C.endswith('#'))
+        C = np.char.center('FOO', [[10, 20], [15, 8]])
+        assert issubclass(C.dtype.type, np.string_)
+        assert_array_equal(C, [
+                ['   FOO    ', '        FOO         '],
+                ['      FOO      ', '  FOO   ']])
+
+    def test_decode(self):
+        A = np.char.array(['736563726574206d657373616765'])
+        assert A.decode('hex_codec')[0] == 'secret message'
+
+    def test_encode(self):
+        B = self.B.encode('unicode_escape')
+        print B[0][0]
+        assert B[0][0] == r' \u03a3 '
+
+    def test_expandtabs(self):
+        T = self.A.expandtabs()
+        print T
+        assert T[2][0] == '123      345'
+
+    def test_join(self):
+        A = np.char.join([',', '#'], self.A)
+        assert issubclass(A.dtype.type, np.string_)
+        assert_array_equal(np.char.join([',', '#'], self.A), [
+                [' ,a,b,c, ', ''],
+                ['1,2,3,4,5', 'M#i#x#e#d#C#a#s#e'],
+                ['1,2,3, ,\t, ,3,4,5, ,\x00, ', 'U#P#P#E#R']])
+
+    def test_ljust(self):
+        assert issubclass(self.A.ljust(10).dtype.type, np.string_)
+        widths = np.array([[10, 20]])
+        C = self.A.ljust([10, 20])
+        assert_array_equal(np.char.str_len(C), [[10, 20], [10, 20], [12, 20]])
+        C = self.A.ljust(20, '#')
+        assert_array_equal(C.startswith('#'), [
+                [False, True], [False, False], [False, False]])
+        assert np.all(C.endswith('#'))
+        C = np.char.ljust('FOO', [[10, 20], [15, 8]])
+        assert issubclass(C.dtype.type, np.string_)
+        assert_array_equal(C, [
+                ['FOO       ', 'FOO                 '],
+                ['FOO            ', 'FOO     ']])
+
+    def test_lower(self):
+        assert issubclass(self.A.lower().dtype.type, np.string_)
+        assert_array_equal(self.A.lower(), [
+                [' abc ', ''],
+                ['12345', 'mixedcase'],
+                ['123 \t 345 \0 ', 'upper']])
+        assert issubclass(self.B.lower().dtype.type, np.unicode_)
+        assert_array_equal(self.B.lower(), [
+                [u' \u03c3 ', u''],
+                [u'12345', u'mixedcase'],
+                [u'123 \t 345 \0 ', u'upper']])
+
+    def test_lstrip(self):
+        assert issubclass(self.A.lstrip().dtype.type, np.string_)
+        assert_array_equal(self.A.lstrip(), [
+                ['abc ', ''],
+                ['12345', 'MixedCase'],
+                ['123 \t 345 \0 ', 'UPPER']])
+        assert_array_equal(self.A.lstrip(['1', 'M']), [
+                [' abc', ''],
+                ['2345', 'ixedCase'],
+                ['23 \t 345 \x00', 'UPPER']])
+        assert issubclass(self.B.lstrip().dtype.type, np.unicode_)
+        assert_array_equal(self.B.lstrip(), [
+                [u'\u03a3 ', ''],
+                ['12345', 'MixedCase'],
+                ['123 \t 345 \0 ', 'UPPER']])
+
+    def test_partition(self):
+        if sys.version_info >= (2, 5):
+            P = self.A.partition(['3', 'M'])
+            assert issubclass(P.dtype.type, np.string_)
+            assert_array_equal(P, [
+                    [(' abc ', '', ''), ('', '', '')],
+                    [('12', '3', '45'), ('', 'M', 'ixedCase')],
+                    [('12', '3', ' \t 345 \0 '), ('UPPER', '', '')]])
+
+    def test_replace(self):
+        R = self.A.replace(['3', 'a'], ['##########', '@'])
+        assert issubclass(R.dtype.type, np.string_)
+        assert_array_equal(R, [
+                [' abc ', ''],
+                ['12##########45', 'MixedC@se'],
+                ['12########## \t ##########45 \x00', 'UPPER']])
+        R = self.A.replace('a', u'\u03a3')
+        assert issubclass(R.dtype.type, np.unicode_)
+        assert_array_equal(R, [
+                [u' \u03a3bc ', ''],
+                ['12345', u'MixedC\u03a3se'],
+                ['123 \t 345 \x00', 'UPPER']])
+
+    def test_rjust(self):
+        assert issubclass(self.A.rjust(10).dtype.type, np.string_)
+        widths = np.array([[10, 20]])
+        C = self.A.rjust([10, 20])
+        assert_array_equal(np.char.str_len(C), [[10, 20], [10, 20], [12, 20]])
+        C = self.A.rjust(20, '#')
+        assert np.all(C.startswith('#'))
+        assert_array_equal(C.endswith('#'), [[False, True], [False, False], [False, False]])
+        C = np.char.rjust('FOO', [[10, 20], [15, 8]])
+        assert issubclass(C.dtype.type, np.string_)
+        assert_array_equal(C, [
+                ['       FOO', '                 FOO'],
+                ['            FOO', '     FOO']])
+
+    def test_rpartition(self):
+        if sys.version_info >= (2, 5):
+            P = self.A.rpartition(['3', 'M'])
+            assert issubclass(P.dtype.type, np.string_)
+            assert_array_equal(P, [
+                    [('', '', ' abc '), ('', '', '')],
+                    [('12', '3', '45'), ('', 'M', 'ixedCase')],
+                    [('123 \t ', '3', '45 \0 '), ('', '', 'UPPER')]])
+
+    def test_rsplit(self):
+        A = self.A.rsplit('3')
+        assert issubclass(A.dtype.type, np.object_)
+        assert_equal(A.tolist(), [
+                [[' abc '], ['']],
+                [['12', '45'], ['MixedCase']],
+                [['12', ' \t ', '45 \x00 '], ['UPPER']]])
+
+    def test_rstrip(self):
+        assert issubclass(self.A.rstrip().dtype.type, np.string_)
+        assert_array_equal(self.A.rstrip(), [
+                [' abc', ''],
+                ['12345', 'MixedCase'],
+                ['123 \t 345', 'UPPER']])
+        assert_array_equal(self.A.rstrip(['5', 'ER']), [
+                [' abc ', ''],
+                ['1234', 'MixedCase'],
+                ['123 \t 345 \x00', 'UPP']])
+        assert issubclass(self.B.rstrip().dtype.type, np.unicode_)
+        assert_array_equal(self.B.rstrip(), [
+                [u' \u03a3', ''],
+                ['12345', 'MixedCase'],
+                ['123 \t 345', 'UPPER']])
+
+    def test_strip(self):
+        assert issubclass(self.A.strip().dtype.type, np.string_)
+        assert_array_equal(self.A.strip(), [
+                ['abc', ''],
+                ['12345', 'MixedCase'],
+                ['123 \t 345', 'UPPER']])
+        assert_array_equal(self.A.strip(['15', 'EReM']), [
+                [' abc ', ''],
+                ['234', 'ixedCas'],
+                ['23 \t 345 \x00', 'UPP']])
+        assert issubclass(self.B.strip().dtype.type, np.unicode_)
+        assert_array_equal(self.B.strip(), [
+                [u'\u03a3', ''],
+                ['12345', 'MixedCase'],
+                ['123 \t 345', 'UPPER']])
+
+    def test_split(self):
+        A = self.A.split('3')
+        assert issubclass(A.dtype.type, np.object_)
+        assert_equal(A.tolist(), [
+                [[' abc '], ['']],
+                [['12', '45'], ['MixedCase']],
+                [['12', ' \t ', '45 \x00 '], ['UPPER']]])
+
+    def test_splitlines(self):
+        A = np.char.array(['abc\nfds\nwer']).splitlines()
+        assert issubclass(A.dtype.type, np.object_)
+        assert A.shape == (1,)
+        assert len(A[0]) == 3
+
+    def test_swapcase(self):
+        assert issubclass(self.A.swapcase().dtype.type, np.string_)
+        assert_array_equal(self.A.swapcase(), [
+                [' ABC ', ''],
+                ['12345', 'mIXEDcASE'],
+                ['123 \t 345 \0 ', 'upper']])
+        assert issubclass(self.B.swapcase().dtype.type, np.unicode_)
+        assert_array_equal(self.B.swapcase(), [
+                [u' \u03c3 ', u''],
+                [u'12345', u'mIXEDcASE'],
+                [u'123 \t 345 \0 ', u'upper']])
+
+    def test_title(self):
+        assert issubclass(self.A.title().dtype.type, np.string_)
+        assert_array_equal(self.A.title(), [
+                [' Abc ', ''],
+                ['12345', 'Mixedcase'],
+                ['123 \t 345 \0 ', 'Upper']])
+        assert issubclass(self.B.title().dtype.type, np.unicode_)
+        assert_array_equal(self.B.title(), [
+                [u' \u03a3 ', u''],
+                [u'12345', u'Mixedcase'],
+                [u'123 \t 345 \0 ', u'Upper']])
+
+    def test_upper(self):
+        assert issubclass(self.A.upper().dtype.type, np.string_)
+        assert_array_equal(self.A.upper(), [
+                [' ABC ', ''],
+                ['12345', 'MIXEDCASE'],
+                ['123 \t 345 \0 ', 'UPPER']])
+        assert issubclass(self.B.upper().dtype.type, np.unicode_)
+        assert_array_equal(self.B.upper(), [
+                [u' \u03a3 ', u''],
+                [u'12345', u'MIXEDCASE'],
+                [u'123 \t 345 \0 ', u'UPPER']])
+
+    def test_isnumeric(self):
+        def fail():
+            self.A.isnumeric()
+        self.failUnlessRaises(TypeError, fail)
+        assert issubclass(self.B.isnumeric().dtype.type, np.bool_)
+        assert_array_equal(self.B.isnumeric(), [
+                [False, False], [True, False], [False, False]])
+
+    def test_isdecimal(self):
+        def fail():
+            self.A.isdecimal()
+        self.failUnlessRaises(TypeError, fail)
+        assert issubclass(self.B.isdecimal().dtype.type, np.bool_)
+        assert_array_equal(self.B.isdecimal(), [
+                [False, False], [True, False], [False, False]])
 
 
 class TestOperations(TestCase):
@@ -42,20 +517,21 @@ class TestOperations(TestCase):
     def test_add(self):
         AB = np.array([['abcefg', '123456'],
                        ['789051', 'xyztuv']]).view(np.chararray)
-        assert all(AB == (self.A + self.B))
+        assert_array_equal(AB, (self.A + self.B))
+        assert len((self.A + self.B)[0][0]) == 6
 
     def test_radd(self):
         QA = np.array([['qabc', 'q123'],
                        ['q789', 'qxyz']]).view(np.chararray)
-        assert all(QA == ('q' + self.A))
+        assert_array_equal(QA, ('q' + self.A))
 
     def test_mul(self):
         A = self.A
-#        for r in (2,3,5,7,197):
-#            Ar = np.array([[A[0,0]*r, A[0,1]*r],
-#                           [A[1,0]*r, A[1,1]*r]]).view(np.chararray)
-#
-#            assert all(Ar == (self.A * r))
+        for r in (2,3,5,7,197):
+            Ar = np.array([[A[0,0]*r, A[0,1]*r],
+                           [A[1,0]*r, A[1,1]*r]]).view(np.chararray)
+
+            assert_array_equal(Ar, (self.A * r))
 
         for ob in [object(), 'qrs']:
             try:
@@ -67,11 +543,10 @@ class TestOperations(TestCase):
 
     def test_rmul(self):
         A = self.A
-#        for r in (2,3,5,7,197):
-#            Ar = np.array([[A[0,0]*r, A[0,1]*r],
-#                           [A[1,0]*r, A[1,1]*r]]).view(np.chararray)
-#
-#            assert all(Ar == (r * self.A))
+        for r in (2,3,5,7,197):
+            Ar = np.array([[A[0,0]*r, A[0,1]*r],
+                           [A[1,0]*r, A[1,1]*r]]).view(np.chararray)
+            assert_array_equal(Ar, (r * self.A))
 
         for ob in [object(), 'qrs']:
             try:
@@ -82,7 +557,19 @@ class TestOperations(TestCase):
                 self.fail("chararray can only be multiplied by integers")
 
     def test_mod(self):
-        pass
+        # From Alan McIntyre's bug #856
+        F = np.array([['%d', '%f'],['%s','%r']]).view(np.chararray)
+        C = np.array([[3,7],[19,1]])
+        FC = np.array([['3', '7.000000'],
+                       ['19', '1']]).view(np.chararray)
+        assert_array_equal(FC, F % C)
+
+        A = np.array([['%.3f','%d'],['%s','%r']]).view(np.chararray)
+        A1 = np.array([['1.000','1'],['1','1']]).view(np.chararray)
+        assert_array_equal(A1, (A % 1))
+
+        A2 = np.array([['1.000','2'],['3','4']]).view(np.chararray)
+        assert_array_equal(A2, (A % [[1,2],[3,4]]))
 
     def test_rmod(self):
         assert ("%s" % self.A) == str(self.A)
@@ -98,5 +585,6 @@ class TestOperations(TestCase):
                           "non-string objects")
 
 
+
 if __name__ == "__main__":
     run_module_suite()
diff --git a/numpy/core/tests/test_regression.py b/numpy/core/tests/test_regression.py
index f638558d1..01f9ea58e 100644
--- a/numpy/core/tests/test_regression.py
+++ b/numpy/core/tests/test_regression.py
@@ -1118,5 +1118,37 @@ class TestRegression(TestCase):
         i = np.lexsort((a[::-1], b))
         assert_equal(i, np.arange(100, dtype=np.int))
 
+    def test_object_array_to_fixed_string(self):
+        """Ticket #1235."""
+        a = np.array(['abcdefgh', 'ijklmnop'], dtype=np.object_)
+        b = np.array(a, dtype=(np.string_, 8))
+        assert_equal(a, b)
+        c = np.array(a, dtype=(np.string_, 5))
+        assert_equal(c, np.array(['abcde', 'ijklm']))
+        d = np.array(a, dtype=(np.string_, 12))
+        assert_equal(a, d)
+        e = np.empty((2, ), dtype=(np.string_, 8))
+        e[:] = a[:]
+        assert_equal(a, e)
+
+    def test_unicode_to_string_cast(self):
+        """Ticket #1240."""
+        a = np.array([[u'abc', u'\u03a3'], [u'asdf', u'erw']], dtype='U')
+        def fail():
+            b = np.array(a, 'S4')
+        self.failUnlessRaises(UnicodeEncodeError, fail)
+
+    def test_mixed_string_unicode_array_creation(self):
+        a = np.array(['1234', u'123'])
+        assert a.itemsize == 16
+        a = np.array([u'123', '1234'])
+        assert a.itemsize == 16
+        a = np.array(['1234', u'123', '12345'])
+        assert a.itemsize == 20
+        a = np.array([u'123', '1234', u'12345'])
+        assert a.itemsize == 20
+        a = np.array([u'123', '1234', u'1234'])
+        assert a.itemsize == 16
+
 if __name__ == "__main__":
     run_module_suite()