def test_vq_large_nfeat(self):
        X = np.random.rand(20, 20)
        code_book = np.random.rand(3, 20)

        codes0, dis0 = _vq.vq(X, code_book)
        codes1, dis1 = py_vq(X, code_book)
        assert_allclose(dis0, dis1, 1e-5)
        assert_array_equal(codes0, codes1)

        X = X.astype(np.float32)
        code_book = code_book.astype(np.float32)

        codes0, dis0 = _vq.vq(X, code_book)
        codes1, dis1 = py_vq(X, code_book)
        assert_allclose(dis0, dis1, 1e-5)
        assert_array_equal(codes0, codes1)

 def test_vq(self):
     initc = np.concatenate(([[X[0]], [X[1]], [X[2]]]))
     if TESTC:
         label1, dist = _vq.vq(X, initc)
         assert_array_equal(label1, LABEL1)
         tlabel1, tdist = vq(X, initc)
     else:
         print("== not testing C imp of vq ==")

 def test_vq_1d(self):
     """Test special rank 1 vq algo, python implementation."""
     data = X[:, 0]
     initc = data[:3]
     a, b = _vq.vq(data, initc)
     ta, tb = py_vq(data[:, np.newaxis], initc[:, np.newaxis])
     assert_array_equal(a, ta)
     assert_array_equal(b, tb)

    def test_vq_large_features(self):
        X = np.random.rand(10, 5) * 1000000
        code_book = np.random.rand(2, 5) * 1000000

        codes0, dis0 = _vq.vq(X, code_book)
        codes1, dis1 = py_vq(X, code_book)
        assert_allclose(dis0, dis1, 1e-5)
        assert_array_equal(codes0, codes1)

 def test_vq_1d(self):
     """Test special rank 1 vq algo, python implementation."""
     data = X[:, 0]
     initc = data[:3]
     if TESTC:
         a, b = _vq.vq(data, initc)
         ta, tb = py_vq(data[:, np.newaxis], initc[:, np.newaxis])
         assert_array_equal(a, ta)
         assert_array_equal(b, tb)
     else:
         print("== not testing C imp of vq (rank 1) ==")

 def test_vq(self):
     initc = np.concatenate(([[X[0]], [X[1]], [X[2]]]))
     label1, dist = _vq.vq(X, initc)
     assert_array_equal(label1, LABEL1)
     tlabel1, tdist = vq(X, initc)

 def test_vq(self):
     initc = np.concatenate(([[X[0]], [X[1]], [X[2]]]))
     for tp in np.array, np.matrix:
         label1, dist = _vq.vq(tp(X), tp(initc))
         assert_array_equal(label1, LABEL1)
         tlabel1, tdist = vq(tp(X), tp(initc))

def vq(obs, code_book, check_finite=True):
    """
    Assign codes from a code book to observations.

    Assigns a code from a code book to each observation. Each
    observation vector in the 'M' by 'N' `obs` array is compared with the
    centroids in the code book and assigned the code of the closest
    centroid.

    The features in `obs` should have unit variance, which can be
    achieved by passing them through the whiten function.  The code
    book can be created with the k-means algorithm or a different
    encoding algorithm.

    Parameters
    ----------
    obs : ndarray
        Each row of the 'M' x 'N' array is an observation.  The columns are
        the "features" seen during each observation. The features must be
        whitened first using the whiten function or something equivalent.
    code_book : ndarray
        The code book is usually generated using the k-means algorithm.
        Each row of the array holds a different code, and the columns are
        the features of the code.

         >>> #              f0    f1    f2   f3
         >>> code_book = [
         ...             [  1.,   2.,   3.,   4.],  #c0
         ...             [  1.,   2.,   3.,   4.],  #c1
         ...             [  1.,   2.,   3.,   4.]]  #c2

    check_finite : bool, optional
        Whether to check that the input matrices contain only finite numbers.
        Disabling may give a performance gain, but may result in problems
        (crashes, non-termination) if the inputs do contain infinities or NaNs.
        Default: True

    Returns
    -------
    code : ndarray
        A length M array holding the code book index for each observation.
    dist : ndarray
        The distortion (distance) between the observation and its nearest
        code.

    Examples
    --------
    >>> from numpy import array
    >>> from scipy.cluster.vq import vq
    >>> code_book = array([[1.,1.,1.],
    ...                    [2.,2.,2.]])
    >>> features  = array([[  1.9,2.3,1.7],
    ...                    [  1.5,2.5,2.2],
    ...                    [  0.8,0.6,1.7]])
    >>> vq(features,code_book)
    (array([1, 1, 0],'i'), array([ 0.43588989,  0.73484692,  0.83066239]))

    """
    obs = _asarray_validated(obs, check_finite=check_finite)
    code_book = _asarray_validated(code_book, check_finite=check_finite)
    ct = common_type(obs, code_book)

    # avoid copying when dtype is the same
    # should be replaced with c_obs = astype(ct, copy=False)
    # when we get to numpy 1.7.0
    if obs.dtype != ct:
        c_obs = obs.astype(ct)
    else:
        c_obs = obs

    if code_book.dtype != ct:
        c_code_book = code_book.astype(ct)
    else:
        c_code_book = code_book

    if ct in (single, double):
        results = _vq.vq(c_obs, c_code_book)
    else:
        results = py_vq(obs, code_book)
    return results