def visual(self,vtype=None):
		if vtype==None:
			print(self)
		elif vtype=="syn":
			tempmat=np.matrix(np.zeros((self._M,self._W)))
			synvec=[]
			for i in range(0,self._M):
				synvec.append(len(self.get_known_words(i)))
				for j in range(0,self._W):
					tempmat[i,j]=(self._W-synvec[i]+1)*self._content[i,j]
			plt.title("Synonymy")
			plt.xlabel("Words")
			plt.ylabel("Meanings")
			plt.gca().invert_yaxis()
			plt.pcolor(np.array(tempmat),vmin=0,vmax=self._W)
		elif vtype=="hom":
			tempmat=np.matrix(np.zeros((self._M,self._W)))
			homvec=[]
			for j in range(0,self._W):
				homvec.append(len(self.get_known_meanings(j)))
				for i in range(0,self._M):
					tempmat[i,j]=(self._M-homvec[j]+1)*self._content[i,j]
			plt.title("Homonymy")
			plt.xlabel("Words")
			plt.ylabel("Meanings")
			plt.gca().invert_yaxis()
			plt.pcolor(np.array(tempmat),vmin=0,vmax=self._M)

def create_subheatmap(intensity, job, host, n, num_hosts):
    """
    Creates a heatmap in a subplot.

    Arguments:
    intensity -- the values of the intensity being plotted. Must be same length as job.times
    job -- the current job being plotted
    host -- the host  being charted
    n -- the subplot number of the specific host
    num_hosts -- the total number of hosts to be plotted
    """
    length = job.times.size
    end = job.end_time
    start = job.start_time

    x = NP.linspace(0, (end - start) / 3600.0, length * 1)

    intensity = NP.array([intensity]*2, dtype=NP.float64)

    PLT.subplot(num_hosts+1, 1, n)
    PLT.pcolor(x, NP.array([0, 1]), intensity, cmap=matplotlib.cm.Reds, vmin = 0, vmax = math.ceil(NP.max(intensity)), edgecolors='none')

    if (n != num_hosts):
        PLT.xticks([])
    else:
        PLT.xlabel('Hours From Job Beginning')
    PLT.yticks([])

    #PLT.autoscale(enable=True,axis='both',tight=True)

    host_name = host.replace('.tacc.utexas.edu', '')
    PLT.ylabel(host_name, fontsize ='small', rotation='horizontal')

    def image(self, point_grid=None, cmap='hot'):
        """
        makes an image of the (2-dimensional) x and predicted y
        Input:
            point_grid:
                a grid constructed with mgrid[...]
                tuple (max_x0, max_x1) specifying the grid mgrid[0:max_x0:100j, 0:max_x1:100j]
                defaults to mgrid[0:max(x[:,0]):100j, 0:max(x[:,1]):100j]
        """
        if point_grid is None:
            point_grid = self.mk_grid('minmax')
        elif isinstance(point_grid, tuple):
            point_grid = self.mk_grid(point_grid)

        n_xgrid = shape(point_grid)[1]
        n_ygrid = shape(point_grid)[2]

        positions = vstack(map(ravel, point_grid)).transpose()
        plt.pcolor(positions[:, 0].reshape(n_xgrid, n_ygrid),
                   positions[:, 1].reshape(n_xgrid, n_ygrid),
                   self.predict_proba(positions)[:, 1]
                       .reshape(n_xgrid, n_ygrid), cmap=cmap)
        plt.tight_layout()
        plt.colorbar()
        plt.xlabel(self.x_name[0])
        plt.ylabel(self.x_name[1])
        plt.title(self.y_prob_name)

def test_complete():
    fig = plt.figure('Figure with a label?', figsize=(10, 6))

    plt.suptitle('Can you fit any more in a figure?')

    # make some arbitrary data
    x, y = np.arange(8), np.arange(10)
    data = u = v = np.linspace(0, 10, 80).reshape(10, 8)
    v = np.sin(v * -0.6)

    plt.subplot(3, 3, 1)
    plt.plot(list(xrange(10)))

    plt.subplot(3, 3, 2)
    plt.contourf(data, hatches=['//', 'ooo'])
    plt.colorbar()

    plt.subplot(3, 3, 3)
    plt.pcolormesh(data)

    plt.subplot(3, 3, 4)
    plt.imshow(data)

    plt.subplot(3, 3, 5)
    plt.pcolor(data)

    plt.subplot(3, 3, 6)
    plt.streamplot(x, y, u, v)

    plt.subplot(3, 3, 7)
    plt.quiver(x, y, u, v)

    plt.subplot(3, 3, 8)
    plt.scatter(x, x**2, label='$x^2$')
    plt.legend(loc='upper left')

    plt.subplot(3, 3, 9)
    plt.errorbar(x, x * -0.5, xerr=0.2, yerr=0.4)

    ###### plotting is done, now test its pickle-ability #########

    # Uncomment to debug any unpicklable objects. This is slow (~200 seconds).
#    recursive_pickle(fig)

    result_fh = BytesIO()
    pickle.dump(fig, result_fh, pickle.HIGHEST_PROTOCOL)

    plt.close('all')

    # make doubly sure that there are no figures left
    assert_equal(plt._pylab_helpers.Gcf.figs, {})

    # wind back the fh and load in the figure
    result_fh.seek(0)
    fig = pickle.load(result_fh)

    # make sure there is now a figure manager
    assert_not_equal(plt._pylab_helpers.Gcf.figs, {})

    assert_equal(fig.get_label(), 'Figure with a label?')

def plot_array(array, title):
    '''Part 1: Plot an array using pcolor and title it'''
    plt.ylim(0, array.shape[0])
    plt.xlim(0, array.shape[1])
    plt.pcolor(array, vmin=0, vmax=1)   # 1/up=red, 0/down=blue
    plt.title(title)
    plt.show()

def sorted_heatmap(weights):
    """Create a sorted heatmap.

    Plot a matrix such that the biggest row/col values are in the upper left
    of the heatmap.

    Args:
      weights - a 2d numpy array of floats

    Returns:
      A plot that can be saved to a file via plt.savefig('file')
    """
    weights = weights.reshape(weights.shape[:2])
    row_order = np.array(sorted(weights, key=lambda row: np.sum(row)))
    col_order = np.array(sorted(row_order.T, key=lambda row: -np.sum(row))).T
    cMap = plt.get_cmap("Blues")

    fig1 = plt.figure(1)
    fig1.add_subplot(1, 1, 1)
    heatmap = plt.pcolor(col_order[:200, :200], cmap=cMap)
    plt.colorbar(heatmap)
    plt.title("Reviewer-Paper Affinities")
    plt.xlabel("Paper")
    plt.ylabel("Reviewer")

    fig2 = plt.figure(2)
    fig2.add_subplot(1, 1, 1)
    heatmap = plt.pcolor(col_order[-200:, -200:], cmap=cMap)
    plt.colorbar(heatmap)
    plt.title("Reviewer-Paper Affinities")
    plt.xlabel("Paper")
    plt.ylabel("Reviewer")
    return fig1, fig2

def _colormap_plot_array_response(cmaps):
    """
    Plot for illustrating colormaps: array response.

    :param cmaps: list of :class:`~matplotlib.colors.Colormap`
    :rtype: None
    """
    import matplotlib.pyplot as plt
    from obspy.signal.array_analysis import array_transff_wavenumber
    # generate array coordinates
    coords = np.array([[10., 60., 0.], [200., 50., 0.], [-120., 170., 0.],
                       [-100., -150., 0.], [30., -220., 0.]])
    # coordinates in km
    coords /= 1000.
    # set limits for wavenumber differences to analyze
    klim = 40.
    kxmin = -klim
    kxmax = klim
    kymin = -klim
    kymax = klim
    kstep = klim / 100.
    # compute transfer function as a function of wavenumber difference
    transff = array_transff_wavenumber(coords, klim, kstep, coordsys='xy')
    # plot
    for cmap in cmaps:
        plt.figure()
        plt.pcolor(np.arange(kxmin, kxmax + kstep * 1.1, kstep) - kstep / 2.,
                   np.arange(kymin, kymax + kstep * 1.1, kstep) - kstep / 2.,
                   transff.T, cmap=cmap)
        plt.colorbar()
        plt.clim(vmin=0., vmax=1.)
        plt.xlim(kxmin, kxmax)
        plt.ylim(kymin, kymax)
    plt.show()

 def show_heatmap(self, component):
     """ prints a quick simple heads up heatmap of input component of the mean_set attribute"""
     fig, ax = plt.subplots()
     plt.pcolor(self[component])    # see __getitem__
     plt.colorbar()
     plt.title(component)
     plt.show()

def nearest(galaxies):

    midRA = 334.37
    midDec = 0.2425
    peakLimit = 3.077

    #put the positions of all galaxies into one array
    positions = np.array([])
    for gal in galaxies:
        galaxy = galaxies[gal]
        x = cmToMpc*DC(galaxy.z)*(galaxy.RA-midRA)*(np.pi/180.)
        y = cmToMpc*DC(galaxy.z)*(galaxy.dec-midDec)*(np.pi/180.)
        z = (cmToMpc*DC(galaxy.z)-cmToMpc*(DC(peakLimit)))
        positions = np.append(positions, [x, y, z])
    positions = np.reshape(positions, (-1, 3))
    #create the map to save the data
    nx = 100
    ny = 100

    xs = np.linspace(-8, 8, nx)
    yx = np.linspace(-8, 8, ny)
    map = np.zeros((nx, ny))

    #loop through each of the positions in the map
    for ix in range(nx):
        for iy in range(ny):
            xpositions = positions[:,0]
            ypositions = positions[:,1]
            zpositions = positions[:,2]
            distances = np.sqrt((xpositions-xs[ix])**2+(ypositions-yx[iy])**2+(zpositions-peakLimit)**2)
            print(min(distances)) 
           
            map[ix,iy] = 1/(min(distances)+10)
    plt.pcolor(map)
    plt.show()

def heatmap(df, cmap="OrRd", figsize=(10, 10)):
    """draw heatmap of df"""

    plt.figure(figsize=figsize)
    plt.xticks(np.arange(0.5, len(df.columns), 1), df.columns)
    plt.yticks(np.arange(0.5, len(df.index), 1), df.index)
    plt.pcolor(df, cmap=cmap)

def solve(m, computeRhs, bcs, plot = False, filename = ''):
    h = (1.0 - 0.0) / (m + 1.0)
    x = np.linspace(0, 1, m + 2)
    y = np.linspace(0, 1, m + 2)
    X, Y = np.meshgrid(x, y)
    matrix = getMatrix(m)
    f = computeRhs(X[1:-1, 1:-1], Y[1:-1, 1:-1], bcs, h)

    u = linalg.spsolve(matrix, f)
    u=u.reshape([m,m])
    sol = np.zeros((m+2, m+2))
    sol[1:-1, 1:-1] = u

    # Add boundary conditions values to solution.
    sol[:, 0] = bcs['left'](y)
    sol[:, -1] = bcs['right'](y)
    sol[0, :] = bcs['bottom'](x)
    sol[-1, :] = bcs['top'](x)

    # Plot solution.
    if plot:
        import matplotlib.pyplot as plt
        plt.clf()
        plt.pcolor(X,Y,sol)
        plt.colorbar()
        plt.xlabel(r'$x$')
        plt.ylabel(r'$y$')
        if filename:
            plt.savefig(filename)
        plt.show()

    return sol, X, Y

    def test_2d_iterp(self):

        import numpy as np
        from scipy.interpolate import Rbf
        import matplotlib.pyplot as plt
        from matplotlib import cm

        # 2-d tests - setup scattered data
        x = np.random.rand(3) * 4.0 - 2.0
        y = np.random.rand(3) * 4.0 - 2.0
        z = x * np.exp(-x ** 2 - y ** 2)
        ti = np.linspace(-2.0, 2.0, 100)
        XI, YI = np.meshgrid(ti, ti)

        # use RBF
        rbf = Rbf(x, y, z, epsilon=2)
        ZI = rbf(XI, YI)

        # plot the result
        n = plt.Normalize(-2.0, 2.0)
        plt.subplot(1, 1, 1)
        plt.pcolor(XI, YI, ZI, cmap=cm.jet)
        plt.scatter(x, y, 100, z, cmap=cm.jet)
        plt.title("RBF interpolation - multiquadrics")
        plt.xlim(-2, 2)
        plt.ylim(-2, 2)
        plt.colorbar()

        plt.show()

 def toImage(self,func):
     # do log
     print func
     func[func>self.para[1]] = np.log10(func[func>self.para[1]])
     plt.pcolor(func,cmap = cm.cool)
     plt.colorbar()
     plt.show()

def plot_zvsz(z_phot, z_true, binning, z_min, z_max):
	
	plt.figure(figsize=(13, 7))
	
	plt.subplot(121)	
	plt.plot(z_true, z_phot, 'o', markersize = 1)
	plt.plot([z_min, z_max], [z_min, z_max], linewidth = 1, color = 'red')
	plt.axis('scaled')
	plt.xlim(xmin = z_min, xmax = z_max)
	plt.ylim(ymin = z_min, ymax = z_max)
	plt.xlabel("z(true)")
	plt.ylabel("z(phot)")
	
	plt.subplot(122)
	H = tool.migration_matrix(z_phot, z_true, binning)
	H = H.T
	plt.pcolor(binning, binning, H)
	plt.axis('scaled')
	plt.xlim(xmin = z_min, xmax = z_max)
	plt.ylim(ymin = z_min, ymax = z_max)
	plt.ylabel("z(phot)")
	plt.xlabel("z(true)")
	plt.title("Transition Matrix z(true)$\\rightarrow$z(phot)")
	#plt.colorbar(aspect = 30, orientation = 'horitzontal', fraction = 0.03).set_label("Probability")
	plt.colorbar(aspect = 30, fraction = 0.03).set_label("Probability")
	
	plt.savefig(plot_folder + "zvsz.png", bbox_inches='tight')
	#plt.savefig(plot_folder + "zvsz.pdf", bbox_inches='tight')
	plt.close()

    def draw(self):

        filename = self.filename
        file = open(os.getcwd() + "\\" + filename, 'r')
        lines = csv.reader(file)
        #
        data = []
        x = []
        y = []
        z = []
        for line in lines:
            try:
                data.append(line)
            except Exception as e:
                print e
                pass
        # print data
        for i in range(1, len(data)):
            try:
                x.append(float(data[i][0]))
                y.append(float(data[i][1]))
                z.append(float(data[i][3]))
            finally:
                pass

        xx = np.array(x)
        yy = np.array(y)
        zz = np.array(z)
        # print np.min(xx)

        tx = np.linspace(np.min(xx), np.max(xx), 100)
        ty = np.linspace(np.min(yy), np.max(yy), 100)

        XI, YI = np.meshgrid(tx, ty)

        rbf = interpolate.Rbf(xx, yy, zz, epsilon=2)
        ZI = rbf(XI, YI)

        #

        plt.gca().set_aspect(1.0)

        font = font_manager.FontProperties(family='times new roman', style='italic', size=16)

        cs = plt.contour(XI, YI, ZI, colors="black")
        plt.clabel(cs, cs.levels, inline=True, fontsize=10, prop=font)

        plt.subplot(1, 1, 1)
        plt.pcolor(XI, YI, ZI, cmap=cm.jet)
        plt.scatter(xx, yy, 100, zz, cmap=cm.jet)


        plt.title('interpolation example')
        plt.xlim(int(xx.min()), int(xx.max()))
        plt.ylim(int(yy.min()), int(yy.max()))
        plt.colorbar()
        plt.savefig("interpolation.jpg")
        #plt.show()

        return ZI, XI, YI

def produce_heatmap(model, every = True, save = False):
    col_label = range(28)
    row_label = range(28)
    if every:
        for i in range(10):
            plt.pcolor(np.flipud(model[i]))
            plt.xticks(col_label)
            plt.yticks(row_label)
            plt.axis('off')
            plt.title("HeatMap for %d" % (i))
            cb = plt.colorbar()
            cb.set_label("Frequency")
            if save:
                plt.savefig('imgs/%d.png' % (i), bbox_inches='tight')
            else:
                plt.show()
            plt.close()
    else:
        plt.pcolor(np.flipud(model))
        plt.xticks(col_label)
        plt.yticks(row_label)
        plt.axis('off')
        cb = plt.colorbar()
        cb.set_label("Frequency")
        if save:
            plt.savefig('imgs/temp.png', bbox_inches='tight')
        else:
            plt.show()
        plt.close()

def plotOmittedFromGraph(graph, reference_slice, l = "not specified"):



    omitted = nodesOmitted(graph, reference_slice)
    omitted[reference_slice] = -1
    reshape_parameter = int(ceil(sqrt(len(omitted))))
    magic_number = reshape_parameter / 2.
    padding = ones(reshape_parameter ** 2 - len(omitted)) * .5
    to_plot = concatenate([omitted, padding]).reshape((reshape_parameter,
                                                reshape_parameter)) * -1

    ##setting variables for text annotations
    x = np.linspace(8./reshape_parameter,
                reshape_parameter - 8./reshape_parameter, reshape_parameter)

    y = np.linspace(10./reshape_parameter,
                reshape_parameter - 8./reshape_parameter, reshape_parameter)

    plt.figure()
    plt.title(str(l))
    ax = plt.gca()
    ax.invert_yaxis()
    plt.pcolor(to_plot,cmap='PiYG')
    for i in range(reshape_parameter):
        for j in range(reshape_parameter):
            plt.text(x[i], y[j], str(i+j*reshape_parameter), color="white",
                                    horizontalalignment='center')
    plt.colorbar()

def run_model(G, group, filename, picturename):
	dynamics=[]
	initial = [group[i].unification for i in range (11)]
	dynamics.append(initial)
	for t in range(10):
		uni=[]
		for i in range(11):
			Idx =  G.neighbors(i)
			connections = {group[i] for i in Idx}
			x = group[i].influence(connections)
			if (np.absolute(x)>= group[i].unification) and (np.sign(x)-group[i].unification != 0):
				group[i].unification = np.sign(x)
			uni.append(group[i].unification)
		dynamics.append(uni)

	ar = np.array(dynamics)
	import csv
	fl = open(filename, 'w')

	writer = csv.writer(fl)
	for values in ar:
	    writer.writerow(values)
	fl.close()

	plt.pcolor(ar)
	plt.savefig(picturename)

def dispPlot( org, bn, count, potential,
                mx = 0.1, mn = -0.1, title = '',
                xlab = r'$X \AA$', ylab = r'$Y \, (\AA)$',
                lege = '', outFile = None ):
    """Plots the colormap of potential plot, 2D"""
    fig = plt.figure(1, figsize = (3.5, 3.))
    ax = fig.add_subplot(1,1,1)

    nbins = len(potential[0])

    X = np.arange(org[0], org[0]+ nbins*bn[0], bn[0])
    Y = np.arange(org[1], org[1]+ nbins*bn[1], bn[1])
    big = max( abs(mn)-abs(0.1*mn), abs(mx)+abs(mx)*0.1)
    plt.pcolor(X, Y, potential, cmap = 'seismic_r',
                    vmin=-big, vmax=big)
    plt.colorbar()

    ax.set_xlim([X[0], X[-1]])
    ax.set_ylim([Y[0], Y[-1]])

    ax.xaxis.labelpad = -1.4
    ax.yaxis.labelpad = -1.4

    plt.title(title, fontsize = 13);
    ax.set_ylabel(ylab, fontsize = 12);
    ax.set_xlabel(xlab, fontsize = 12)

    for tick in ax.xaxis.get_major_ticks():
        tick.label.set_fontsize(10)
    for tick in ax.yaxis.get_major_ticks():
        tick.label.set_fontsize(10)
    if outFile != None:
        plt.savefig(outFile,bbox_inches='tight', dpi = 300)
    plt.close()

def main(grid_size, discount):
    """
    Run linear programming inverse reinforcement learning on the gridworld MDP.

    Plots the reward function.

    grid_size: Grid size. int.
    discount: MDP discount factor. float.
    """

    wind = 0.3
    trajectory_length = 3*grid_size

    gw = gridworld.Gridworld(grid_size, wind, discount)

    ground_r = np.array([gw.reward(s) for s in range(gw.n_states)])
    policy = [gw.optimal_policy_deterministic(s) for s in range(gw.n_states)]
    r = linear_irl.irl(gw.n_states, gw.n_actions, gw.transition_probability,
            policy, gw.discount, 1, 5)

    plt.subplot(1, 2, 1)
    plt.pcolor(ground_r.reshape((grid_size, grid_size)))
    plt.colorbar()
    plt.title("Groundtruth reward")
    plt.subplot(1, 2, 2)
    plt.pcolor(r.reshape((grid_size, grid_size)))
    plt.colorbar()
    plt.title("Recovered reward")
    plt.show()