def test_empty(self):
     a = np.array([[[]]])
     b = np.array([[], []])
     c = tile(b, 2).shape
     d = tile(a, (3, 2, 5)).shape
     assert_equal(c, (2, 0))
     assert_equal(d, (3, 2, 0))

    def __init__(self, L, N):
        self.deltaX = float(L / float(N))
        self.N = int(N + 1)
        self.M = self.N
        self.L = float(L)
        self.X = []
        # TODO !!! move this part to __call__ method

        self.A = array(zeros([self.M, self.M]))



        #self.filtera = array(self.A +1, dtype=bool)
        self.filtera = self.A == self.A         # COOL ! :)
        self.DOF = array(tile(True, (self.M)), dtype=bool)
        for i in range(self.M):         # assuming DX=Constant
            self.X.append(round(self.deltaX*i, 15))   # To avoid  stupid 0.199

        self.B = array(zeros([self.M, 1]))
        self.T = array(tile(nan, (self.M,)))

        # TODO for solve method
        self.bcConduction = array(tile(False, (self.M, )), dtype=bool)
        self.bcConvection = array(tile(False, (self.M, )), dtype=bool)
        self.bcT = array(tile(True, (self.M, )), dtype=bool)
        #self.bcRadiation = array(tile(False, (self.M, 1)), dtype=bool)

        internalNodes = array([1., -2., 1.])
#
        for i in range(1, int(self.M-1)):
#            self.A[i, range(i-1, i+2)] = internalNodes
            self.B[i] *= self.deltaX**2

    def test_kroncompare(self):
        from numpy.random import randint

        reps = [(2,), (1, 2), (2, 1), (2, 2), (2, 3, 2), (3, 2)]
        shape = [(3,), (2, 3), (3, 4, 3), (3, 2, 3), (4, 3, 2, 4), (2, 2)]
        for s in shape:
            b = randint(0, 10, size=s)
            for r in reps:
                a = np.ones(r, b.dtype)
                large = tile(b, r)
                klarge = kron(a, b)
                assert_equal(large, klarge)

 def test_basic(self):
     a = np.array([0, 1, 2])
     b = [[1, 2], [3, 4]]
     assert_equal(tile(a, 2), [0, 1, 2, 0, 1, 2])
     assert_equal(tile(a, (2, 2)), [[0, 1, 2, 0, 1, 2], [0, 1, 2, 0, 1, 2]])
     assert_equal(tile(a, (1, 2)), [[0, 1, 2, 0, 1, 2]])
     assert_equal(tile(b, 2), [[1, 2, 1, 2], [3, 4, 3, 4]])
     assert_equal(tile(b, (2, 1)), [[1, 2], [3, 4], [1, 2], [3, 4]])
     assert_equal(tile(b, (2, 2)), [[1, 2, 1, 2], [3, 4, 3, 4], [1, 2, 1, 2], [3, 4, 3, 4]])

def classify(inX,dataSet,labels,k):
    dataSetSize = dataSet.shape[0]
    diffMat = tile(inX,(dataSetSize,1)) -dataSet    #   算距离
    print(diffMat)
    sqDiffMat = diffMat**2      
    sqDistances = sqDiffMat.sum(axis=1)             #
    distances = sqDistances**0.5                    #
    print(sqDistances)
    sortedDistIndicies = distances.argsort()
    classCount = {}
    for i in range(k):                              # 距离最小的k个点 
        voteIlabel = labels[sortedDistIndicies[i]]
        classCount[voteIlabel] = classCount.get(voteIlabel,0) + 1
    sortedClassCount = sorted(classCount.items(),key=operator.itemgetter(1),reverse=True)   # 排序
    print(sortedClassCount)
    return sortedClassCount[0][0]

 def test_tile_one_repetition_on_array_gh4679(self):
     a = np.arange(5)
     b = tile(a, 1)
     b += 2
     assert_equal(a, np.arange(5))

 def test_empty(self):
     a = np.array([[[]]])
     d = tile(a, (3, 2, 5)).shape
     assert_equal(d, (3, 2, 0))