def find_direction(self, grad_diffs, steps, grad, hessian_diag, idxs):
        grad = grad.copy()  # We will change this.
        n_current_factors = len(idxs)

        # TODO: find a good name for this variable.
        rho = scipy.empty(n_current_factors)

        # TODO: vectorize this function
        for i in idxs:
            rho[i] = 1 / scipy.inner(grad_diffs[i], steps[i])

        # TODO: find a good name for this variable as well.
        alpha = scipy.empty(n_current_factors)

        for i in idxs[::-1]:
            alpha[i] = rho[i] * scipy.inner(steps[i], grad)
            grad -= alpha[i] * grad_diffs[i]
        z = hessian_diag * grad

        # TODO: find a good name for this variable (surprise!)
        beta = scipy.empty(n_current_factors)

        for i in idxs:
            beta[i] = rho[i] * scipy.inner(grad_diffs[i], z)
            z += steps[i] * (alpha[i] - beta[i])

        return z, {}

 def corelationImage1Image2(imageArray1, imageArray2):
     image1 = scipy.inner(numpy.asarray(imageArray1), [299, 587, 114]) / 1000.0
     image2 = scipy.inner(numpy.asarray(imageArray2), [299, 587, 114]) / 1000.0
     
     image1 = (image1 - image1.mean())/ image1.std()
     image2 = (image2 - image2.mean())/ image2.std()
     
     corelationimage1Withimage2 = c2d(image1, image2, mode = 'same')
     return corelationimage1Withimage2.max()

def convert_to_grayscale(img):
	shape = img.shape(img)
	if len(shape) == 1:
		return img
	elif len(shape) == 3:
		return sp.inner(img, [299, 587, 114]) / 1000
	elif len(shape) == 4:
		return sp.inner(img, [299, 587, 114, 0] / 1000)
	elif len(shape) == 2:
		return sp.inner(img, [1, 0])
	else:
		raise ValueError("The image has a non-standard bit-depth which is not supported.")

def get(i):
    # get JPG image as Scipy array, RGB (3 layer)
    data = imread('/Users/kalaivanikubendran/Documents/Sideprojects/kalai-kaggle-code/train_sm/set175_%s.jpeg' % i)
    # convert to grey-scale using W3C luminance calc
    data = sp.inner(data, [299, 587, 114]) / 1000.0
    # normalize per http://en.wikipedia.org/wiki/Cross-correlation
    return (data - data.mean()) / data.std()

    def grad_f1(self, a):
        "Define the gradient for each convex inequality."

        # Initialize the output vector
        out = sp.zeros((self.M, self.Na))

        # Preliminary calculation
        _xx = sp.einsum('mi,mj->mij', self.xarray, self.xarray)

        # Compute the four terms
        _Da = sp.tensordot(self.D, a, axes=[(0,), (0,)])
        _DDa = sp.tensordot(self.D, _Da, axes=[(1,), (0,)])
        xxDDa = sp.tensordot(_xx.reshape(self.M, self.ndim**2),
                             _DDa.reshape(self.Na, self.ndim**2),
                             axes=[(-1,), (-1,)])

        _BDa = sp.dot(self.B, _Da)
        xBDa = sp.inner(self.xarray, _BDa)

        _Ba = sp.dot(a, self.B)
        _DBa = sp.dot(_Ba, self.D)
        xDBa = sp.tensordot(self.xarray,
                            _DBa, axes=[(-1,), (-1,)])

        BBa = sp.dot(self.B, _Ba)
        
        # compute the gradient by summing the four terms
        out[:, :] = 2.0 * (xxDDa + xBDa + xDBa + BBa)

        return out

def norm(x):
    """2-norm of x
    """

    y = ravel(x)
    p = sqrt(inner(y, y))
    return p

 def stateActionValue(self, feature):
     r = self.tao(self.r) * self.r
     if self.enableOnlyEssentialFeatureInCritic:
         feature = self.module.decodeFeature(feature,
                                             self.essentialFeature)
     assert len(r) == self.criticdim, 'Wrong dimension of r'
     return scipy.inner(r, feature)

def get(i):
   # get JPG image as Scipy array, RGB (3 layer)
  data = imread(i)
  # convert to grey-scale using W3C luminance calc
  data = sp.inner(data, [299, 587, 114]) / 1000.0
  # normalize per http://en.wikipedia.org/wiki/Cross-correlation
  return (data - data.mean()) / data.std()

def prepare_image_for_correlation(im):
    letterArray = fromimage(im.convert('RGB'))
    # Black and white
    letterArray = scipy.inner(letterArray, [299, 587, 114]) / 1000.0
    # Normalize
    letterArray = (letterArray - letterArray.mean()) / letterArray.std()
    return letterArray

def normalize(x):
    n = scipy.sqrt(scipy.inner(x,x))
    #n = sl.norm(x, scipy.inf)
    if n > 0:
        return x/n
    else:
        return x

def get_resized_data(origdata, size):
	'''Resize image data'''
	tmp = imresize(origdata, (size, size), interp="bilinear", mode=None)
	# convert to grey-scale using W3C luminance calc
	lum = [299, 587, 114]
	tmp = sp.inner(tmp, lum) / 1000.0
	# normalize per http://en.wikipedia.org/wiki/Cross-correlation
	return ((tmp - tmp.mean()) / tmp.std())

 def f(self, x):
     self.net['mdrnn'].params[:] = x
     error = 0
     for (inpt, target) in self.trainds:
         output = self.net.activate(inpt)
         indic = output.reshape(self.width * self.height, 10).sum(axis=0)
         diff = indic - target
         error += scipy.inner(diff, diff)
     return error / len(self.trainds)

def unsigned_volume(pts):
    """Unsigned volume of a simplex    
    
    Computes the unsigned volume of an M-simplex embedded in N-dimensional 
    space. The points are stored row-wise in an array with shape (M+1,N).
    
    Parameters
    ----------
    pts : array
        Array with shape (M+1,N) containing the coordinates
        of the (M+1) vertices of the M-simplex.

    Returns
    -------
    volume : scalar
        Unsigned volume of the simplex

    Notes
    -----
    Zero-dimensional simplices (points) are assigned unit volumes.
        

    Examples
    --------
    >>> # 0-simplex point 
    >>> unsigned_volume( [[0,0]] )
    1.0
    >>> # 1-simplex line segment
    >>> unsigned_volume( [[0,0],[1,0]] )             
    1.0
    >>> # 2-simplex triangle 
    >>> unsigned_volume( [[0,0,0],[0,1,0],[1,0,0]] ) 
    0.5


    References
    ----------
    [1] http://www.math.niu.edu/~rusin/known-math/97/volumes.polyh

    """       
    
    pts = asarray(pts)
    
    M,N = pts.shape
    M -= 1

    if M < 0 or M > N:
        raise ValueError('array has invalid shape')
    
    if M == 0:
        return 1.0 
        
    A = pts[1:] - pts[0]
    return sqrt(det(inner(A,A)))/factorial(M)

def barycentric_gradients(pts):
    """
    Compute the gradients of the barycentric basis functions over a given simplex
    """            
    V = asarray(pts[1:] - pts[0])
    
    ##all gradients except the first are computed
    grads = dot(inv(inner(V,V)),V) #safer, but slower: grads = scipy.linalg.pinv2(V).T 
    
    ##since sum of all gradients is zero, simply compute the first from the others        
    return vstack((atleast_2d(-numpy.sum(grads,axis=0)),grads))

def get(pics,i):
    #global pics
    # get JPG image as Scipy array, RGB (3 layer)
    data = imread('%s%d.jpeg' %(pics,i))
    data = imresize(data,0.4)   
    #im2 = imresize(im22,0.5)
    #im3 = imresize(im33,0.5)
    # convert to grey-scale using W3C luminance calc
    data = sp.inner(data, [299, 587, 114]) / 1000.0
    # normalize as in http://en.wikipedia.org/wiki/Cross-correlation
    return (data - data.mean()) / data.std()

 def get_data(self, str_name):
     try:
         self.image_data=numpy.array(str_name)
         self.image_data=sp.inner(self.image_data, [299, 587, 114])/1000.0
         std_deviation=self.image_data.std()
         if std_deviation==0.0:
             return 103
         return ((self.image_data-self.image_data.mean())/std_deviation)
     except Exception, e:
         flash("failed:"+str(e))
         return 104

 def get_data(self, str_name):
     try:
         self.image_data=numpy.array(str_name)
         self.image_data=sp.inner(self.image_data, [299, 587, 114])/1000.0
         std_deviation=self.image_data.std()
         if std_deviation==0.0:
             print "\nImage error! Please retry!\n"
             exit()
         return ((self.image_data-self.image_data.mean())/std_deviation)
     except:
         print "\nAwwh, somethings not right! Try again\n"
         exit()

def onMouseFrameViewer(event, _x, _y, flags, param):
    x = _x/SHOW_IMAGE_SCALE
    y = _y/SHOW_IMAGE_SCALE    
    
    if event == cv2.EVENT_MOUSEMOVE:
        return
    if event == cv2.EVENT_RBUTTONDOWN:
        return
    if event == cv2.EVENT_LBUTTONDOWN:
        #print "clicked point : " + str(x) + "," + str(y)
        global curKeypoint2DLists
        global curKeypointIdLists
        if len(curKeypoint2DLists)>0:
            query = np.array([x,y])
            nearestIndex = scipy.argmin([scipy.inner(query-point,query-point) for point in curKeypoint2DLists])
            nearest = curKeypoint2DLists[nearestIndex]
            if (math.sqrt(scipy.inner(query-nearest,query-nearest)) < THRESHOLD_FIND_CLICKED_KEYPOINT):
                #print "selected point index : " + str(nearestIndex)
                #print "selected point id : " + str(curKeypointIdLists[nearestIndex])
                #print "selected point : " + str(nearest[0]) + "," + str(nearest[1])
                showPointViewer(curKeypointIdLists[nearestIndex])
        return

def get(file_name):
	
	# get JPG image as Scipy array, RGB (3 layer)
	data = Image.open(file_name + '.png')
	data.save(file_name + '.jpg')

	data = imread(file_name + '.jpg')

	# convert to grey-scale using W3C luminance calc
	data = scipy.inner(data, [299, 587, 114]) / 1000.0

	# normalize per http://en.wikipedia.org/wiki/Cross-correlation
	return (data - data.mean()) / data.std()

def collectX(X, K):
    C = [X[0]]
    for k in range(1, K):
        D2 = scipy.array([min([scipy.inner(c-x,c-x) for c in C]) for x in X])
        probs = D2/D2.sum()
        cumprobs = probs.cumsum()
        r = scipy.rand()
        for j,p in enumerate(cumprobs):
            if r < p:
                i = j
                break
        C.append(X[i])
    return C