def test_float(self):
     vals = nan_to_num(1.0)
     assert_all(vals == 1.0)
     assert_equal(type(vals), np.float_)
     vals = nan_to_num(1.1, nan=10, posinf=20, neginf=30)
     assert_all(vals == 1.1)
     assert_equal(type(vals), np.float_)

 def test_array(self):
     vals = nan_to_num([1])
     assert_array_equal(vals, np.array([1], int))
     assert_equal(type(vals), np.ndarray)
     vals = nan_to_num([1], nan=10, posinf=20, neginf=30)
     assert_array_equal(vals, np.array([1], int))
     assert_equal(type(vals), np.ndarray)

 def test_complex_good(self):
     vals = nan_to_num(1+1j)
     assert_all(vals == 1+1j)
     assert_equal(type(vals), np.complex_)
     vals = nan_to_num(1+1j, nan=10, posinf=20, neginf=30)
     assert_all(vals == 1+1j)
     assert_equal(type(vals), np.complex_)

 def test_integer(self):
     vals = nan_to_num(1)
     assert_all(vals == 1)
     assert_equal(type(vals), np.int_)
     vals = nan_to_num(1, nan=10, posinf=20, neginf=30)
     assert_all(vals == 1)
     assert_equal(type(vals), np.int_)

 def test_complex_bad(self):
     with np.errstate(divide='ignore', invalid='ignore'):
         v = 1 + 1j
         v += np.array(0+1.j)/0.
     vals = nan_to_num(v)
     # !! This is actually (unexpectedly) zero
     assert_all(np.isfinite(vals))

def calcN(classKernels, trainLabels):
    N = zeros((len(trainLabels), len(trainLabels)))
    for i, l in enumerate(unique(trainLabels)):
        numExamplesWithLabel = len(where(trainLabels == l)[0])
        Idiff = identity(numExamplesWithLabel, Float64) - (1.0 / numExamplesWithLabel) * ones(numExamplesWithLabel, Float64)
        firstDot = dot(classKernels[i], Idiff)
        labelTerm = dot(firstDot, transpose(classKernels[i]))
        N += labelTerm
    N = nan_to_num(N)
    #make N more numerically stable
    #if I had more time, I would train this parameter, but I don't
    additionToN = ((mean(diag(N)) + 1) / 100.0) * identity(N.shape[0], Float64) 
    N += additionToN
            
    #make sure N is invertable
    for i in range(1000):
        try:
            inv(N)
        except LinAlgError:
            #doing this to make sure the maxtrix is invertable
            #large value supported by section titled
            #"numerical issues and regularization" in the paper
            N += additionToN

    return N

    def test_generic(self):
        with np.errstate(divide='ignore', invalid='ignore'):
            vals = nan_to_num(np.array((-1., 0, 1))/0.)
        assert_all(vals[0] < -1e10) and assert_all(np.isfinite(vals[0]))
        assert_(vals[1] == 0)
        assert_all(vals[2] > 1e10) and assert_all(np.isfinite(vals[2]))

        # perform the same test but in-place
        with np.errstate(divide='ignore', invalid='ignore'):
            vals = np.array((-1., 0, 1))/0.
        result = nan_to_num(vals, copy=False)

        assert_(result is vals)
        assert_all(vals[0] < -1e10) and assert_all(np.isfinite(vals[0]))
        assert_(vals[1] == 0)
        assert_all(vals[2] > 1e10) and assert_all(np.isfinite(vals[2]))

 def test_complex_bad2(self):
     with np.errstate(divide='ignore', invalid='ignore'):
         v = 1 + 1j
         v += np.array(-1+1.j)/0.
     vals = nan_to_num(v)
     assert_all(np.isfinite(vals))
     assert_equal(type(vals), np.complex_)

 def test_do_not_rewrite_previous_keyword(self):
     # This is done to test that when, for instance, nan=np.inf then these 
     # values are not rewritten by posinf keyword to the posinf value.
     with np.errstate(divide='ignore', invalid='ignore'):
         vals = nan_to_num(np.array((-1., 0, 1))/0., nan=np.inf, posinf=999)
     assert_all(np.isfinite(vals[[0, 2]]))
     assert_all(vals[0] < -1e10)
     assert_equal(vals[[1, 2]], [np.inf, 999])
     assert_equal(type(vals), np.ndarray)

def trainKFD(trainKernel, trainLabels):
    classKernels = getClassKernels(trainKernel, trainLabels)
    M = calcM(classKernels, trainLabels)
    N = calcN(classKernels, trainLabels)
    '''
    print "train kernel:",trainKernel
    print "Class kernels:", classKernels
    print "M",M
    print "N",N
    '''
    try:
        solutionMatrix = dot(inv(N), M)
    except LinAlgError:
        #if we get a singular matrix here, there isn't much we can do about it
        #just skip this configuration
        solutionMatrix = identity(N.shape[0], Float64)
        
    solutionMatrix = nan_to_num(solutionMatrix)
    
    eVals, eVects = eig(solutionMatrix)
    #find the 'leading' term i.e. find the eigenvector with the highest eigenvalue
    alphaVect = eVects[:, absolute(eVals).argmax()].real.astype(Float64)
    trainProjections = dot(trainKernel, alphaVect)
    '''
    print 'alpha = ', alphaVect
    print 'train kernel = ', trainKernel
    print 'train projction = ', trainProjections
    '''     
    #train sigmoid based on evaluation accuracy
    #accuracyError = lambda x: 100.0 - evaluations(trainLabels, classifyKFDValues(trainProjections, *list(x)))[0]
    accuracyError = lambda x: 100.0 - evaluations(trainLabels, classifyKFDValues(trainProjections, *x))[0]
    #get an initial guess by brute force
    #ranges = ((-100, 100, 1), (-100, 100, 1))
    #x0 = brute(accuracyError, ranges)
    
    #popt = minimize(accuracyError, x0.tolist(), method="Powell").x

    rc = LSFAIL
    niter = 0
    i = 0
    while rc in (LSFAIL, INFEASIBLE, CONSTANT, NOPROGRESS, USERABORT, MAXFUN) or niter <= 1:
        if i == 10:
            break
        #get a 'smarter' x0
        #ranges = ((-1000, 1000, 100), (-1000, 1000, 100))
        ranges = ((-10**(i + 1), 10**(i + 1), 10**i),) * 2
        x0 = brute(accuracyError, ranges)
        (popt, niter, rc) = fmin_tnc(accuracyError, x0, approx_grad=True)
        #popt = fmin_tnc(accuracyError, x0.tolist(), approx_grad=True)[0]
        i += 1
    
    return (alphaVect, popt)

    def test_generic(self):
        with np.errstate(divide='ignore', invalid='ignore'):
            vals = nan_to_num(np.array((-1., 0, 1))/0.)
        assert_all(vals[0] < -1e10) and assert_all(np.isfinite(vals[0]))
        assert_(vals[1] == 0)
        assert_all(vals[2] > 1e10) and assert_all(np.isfinite(vals[2]))
        assert_equal(type(vals), np.ndarray)
        
        # perform the same tests but with nan, posinf and neginf keywords
        with np.errstate(divide='ignore', invalid='ignore'):
            vals = nan_to_num(np.array((-1., 0, 1))/0., 
                              nan=10, posinf=20, neginf=30)
        assert_equal(vals, [30, 10, 20])
        assert_all(np.isfinite(vals[[0, 2]]))
        assert_equal(type(vals), np.ndarray)

        # perform the same test but in-place
        with np.errstate(divide='ignore', invalid='ignore'):
            vals = np.array((-1., 0, 1))/0.
        result = nan_to_num(vals, copy=False)

        assert_(result is vals)
        assert_all(vals[0] < -1e10) and assert_all(np.isfinite(vals[0]))
        assert_(vals[1] == 0)
        assert_all(vals[2] > 1e10) and assert_all(np.isfinite(vals[2]))
        assert_equal(type(vals), np.ndarray)
        
        # perform the same test but in-place
        with np.errstate(divide='ignore', invalid='ignore'):
            vals = np.array((-1., 0, 1))/0.
        result = nan_to_num(vals, copy=False, nan=10, posinf=20, neginf=30)

        assert_(result is vals)
        assert_equal(vals, [30, 10, 20])
        assert_all(np.isfinite(vals[[0, 2]]))
        assert_equal(type(vals), np.ndarray)

 def test_complex_good(self):
     vals = nan_to_num(1+1j)
     assert_all(vals == 1+1j)

 def test_integer(self):
     vals = nan_to_num(1)
     assert_all(vals == 1)
     vals = nan_to_num([1])
     assert_array_equal(vals, np.array([1], np.int))

 def test_generic(self):
     with np.errstate(divide='ignore', invalid='ignore'):
         vals = nan_to_num(np.array((-1., 0, 1))/0.)
     assert_all(vals[0] < -1e10) and assert_all(np.isfinite(vals[0]))
     assert_(vals[1] == 0)
     assert_all(vals[2] > 1e10) and assert_all(np.isfinite(vals[2]))

 def test_integer(self):
     vals = nan_to_num(1)
     assert_all(vals == 1)

 def test_complex_bad2(self):
     with np.errstate(divide="ignore", invalid="ignore"):
         v = 1 + 1j
         v += np.array(-1 + 1.0j) / 0.0
     vals = nan_to_num(v)
     assert_all(np.isfinite(vals))

def polyKernel(x,y, gamma, coef, degree):
    if gamma == 0:
        gamma = .01
    ret = (gamma * dot(x, transpose(y)) + coef) ** degree
    ret = nan_to_num(ret)
    return ret

 def test_array(self):
     vals = nan_to_num([1])
     assert_array_equal(vals, np.array([1], int))
     assert_equal(type(vals), np.ndarray)

 def test_integer(self):
     vals = nan_to_num(1)
     assert_all(vals == 1)
     assert_equal(type(vals), np.int_)

 def test_complex_good(self):
     vals = nan_to_num(1+1j)
     assert_all(vals == 1+1j)
     assert_equal(type(vals), np.complex_)