Petro Verkhogliad @ Experiment Room 4

# std library imports
import random

from operator import attrgetter
from collections import defaultdict

# matplotlib imports
import matplotlib.pyplot as plt
from matplotlib.font_manager import fontManager, FontProperties
from mpl_toolkits.mplot3d import Axes3D
from matplotlib import rc
font= FontProperties(size='x-small');

# numpy/scipy imports
import numpy as np
from scipy import *
from scipy.linalg import *

DIMENIONS = 2


mu1 = np.array([3,6])
mu2 = np.array([3, -2])
covar1 = np.array([[0.5, 0], 
                   [0,   2]])
covar2 = np.array([[2, 0],
                   [0, 2]])

def random_vectors(mu1, m2, covar1, covar2, num=200, dim=DIMENSIONS):
    """
    Generate a given number of randoms of the specified dimension 
    given the means and the covariance matrices for the two classes.

    @param mu1: Mean for class omega1
    @type mu1: np.array
    @param mu2: Mean for class omega2
    @type mu2: np.array
    @param covar1: Covariance matrix for class omega1
    @type covar1: np.array
    @param covar2: Covariance matrix for class omega2
    @type covar2: np.array
    @rtype: tuple
    @return: A 2-tuple. The list of vectors for the first mean and covariance is
             at the first index. The list of vectors for the second mean 
             and covariance is at the second index.
    """
    def gauss():
        return (sum([random.random() for i in xrange(12)]) - 6)

    # store the vectors here
    result1 = list()
    result2 = list()

    # get the eigenvalues and eigenvectors for each of the covariance matrices
    evals1, evec1 = eig(covar1)
    evals2, evec2 = eig(covar2)

    evals1 = np.diag([np.power(val.real,0.5) for val in evals1])
    evals2 = np.diag([np.power(val.real,0.5) for val in evals2])

    for i in xrange(num):
        vec1 = np.array([gauss() for i in range(dim)])
        vec2 = np.array([gauss() for i in range(dim)])

        vec1 = mu1 + dot(dot(evec1, evals1), vec1)
        vec2 = mu2 + dot(dot(evec2, evals2), vec2)

        result1.append(vec1)
        result2.append(vec2)
    return result1, result2

o1, o2 = random_vectors(mu1, mu2, covar1, covar2)

def boundary_parameters(mu1, mu2, covar1, covar2):
    """
    Calculate A, B and C parameters for the discriminant boundary function.
    @param mu1: The mean of the first distribution
    @type mu1:  numpy.array
    @param mu2: The mean of the second distribution
    @type mu2: numpy.array
    @param covar1: The covariance matrix for the first distribution
    @param covar2: The covariance matrix for the second distribution
    @return: Tuple of parameters where the first parameter is the matrix A, the 
             second parameter is the matrix B, and the third parameter is a
             scalar value C.
    @rtype: tuple
    
    """

    a1 = 0.5*(inv(covar2) - inv(covar1))
    b1 = (dot(mu1.T,inv(covar1)) - dot(mu2.T,inv(covar2)))
    c1 = 0.5*(dot(dot(mu2.T,inv(covar2)), mu2) - dot(dot(mu1.T, inv(covar1)), mu1)) + np.log(p1/p2) + np.log(det(covar2) / det(covar1))
    return a1,b1,c1

a,b,c = boundary_parameters(mu1, mu2, covar1, covar2)

x = list()
y = list()
for v in xrange(-5,12, 1):
    val = boundary(v, a, b, c)
    x.append(v)
    y.append(val)

f = lambda x: 3.514 - 1.125*x + 0.187*(x**2)

fig = plt.figure(figsize=(10,7))
ax = fig.add_subplot(111)
ax.scatter(*zip(*o1), color='r')
ax.scatter(*zip(*o2), color='g')
# the line that we plotted by solving the quadratics 
ax.plot(x,y)
# the true line
ax.plot(np.arange(-5,12),[f(x) for x in np.arange(-5,12)], color='c')
ax.grid(True)
plt.show()

import sys
from PyQt4 import QtGui

from matplotlib.figure import Figure
from matplotlib.backends.backend_qt4agg import FigureCanvasQTAgg as FigureCanvas

import numpy as np


class Monitor(FigureCanvas):
    def __init__(self):
        self.fig = Figure()
        self.ax = self.fig.add_subplot(111)

        FigureCanvas.__init__(self, self.fig)

        # the file is 5 float values separated by spaces on every line, like this:
        #0.28 0.18 0.18 0.18 0.18
        #0.352 0.162 0.162 0.162 0.162
        #0.4168 0.1458 0.1458 0.1458 0.1458
        #0.37512 0.23122 0.13122 0.13122 0.13122
        self.data = [np.array(map(float, line.strip().split())) for line in open('data.txt').readlines()]
        self.counter = 1
        
        # the width of the bars
        self.width = 0.8

        # the locations of the bars
        self.locs = np.arange(len(self.data[0]))

        # the first set of bars
        self.bars = self.ax.bar(self.locs, self.data[0], self.width, color='#6a7ea6')

        # set up the lables for the bars
        self.ax.set_xticks(self.locs+0.5)
        self.ax.set_xticklabels(['Red', 'Green', 'Black', 'Orange', 'Yellow'])

        # set the limit for the x and y
        self.ax.set_xlim(0., len(self.data[0]))
        self.ax.set_ylim(0., 1.,)

        # draw the canvas
        self.fig.canvas.draw()

        # start the timer
        self.timer = self.startTimer(1000)


    def timerEvent(self, evt):
        # update the height of the bars, one liner is easier
        [bar.set_height(self.data[self.counter][i]) for i,bar in enumerate(self.bars)]

        # force the redraw of the canvas
        self.fig.canvas.draw()

        # update the data row counter
        self.counter += 1

if __name__ == "__main__":
    app = QtGui.QApplication(sys.argv)
    w = Monitor()
    w.setWindowTitle("Convergence")
    w.show()
    sys.exit(app.exec_())

import sys
import random
from PyQt4 import QtGui

from matplotlib.figure import Figure
from matplotlib.backends.backend_qt4agg \
        import FigureCanvasQTAgg as FigureCanvas

class Monitor(FigureCanvas):
    def __init__(self):
        self.fig = Figure()
        self.ax = self.fig.add_subplot(111)

        # initialize the figure canvas
        FigureCanvas.__init__(self, self.fig)

        # set up the display limits for the figure
        self.ax.set_xlim(0,30)
        self.ax.set_ylim(0,100)

        # turn off autoscaling
        self.ax.set_autoscale_on(False)

        # this is the value that will be updated
        self.value = []
        # this is the line that will be animated
        self.line_value, = self.ax.plot([], self.value, label="Values")

        # shwo the legend
        self.ax.legend()
        self.fig.canvas.draw()

        # start the Qt timer
        self.timerEvent(None)
        self.timer = self.startTimer(1000)


    def timerEvent(self, evt):
        """
        This code will be executed on every timer tick.
        """
        # get the new data value
        self.value.append(random.randrange(0,30))
        # update the line with the new values
        self.line_value.set_data(range(len(self.value)), self.value)

        # force the redraw of the canvas
        self.fig.canvas.draw()

        
if __name__ == "__main__":
    # set up the qt application
    app = QtGui.QApplication(sys.argv)
    # initialize the widget
    w = Monitor()
    # set the title of the window
    w.setWindowTitle('Updating in real time')
    # show the widged on the screen
    w.show()
    # start the main application loop
    sys.exit(app.exec_())

set editing-mode vi
set keymap vi

# turn off the stupid bell
set bell-style none

$if mode=vi
    set keymap vi-command
    "gg": beginning-of-history
    "G": end-of-history

    set keymap vi-insert
    "\C-w": backward-kill-word
    "\C-p": history-search-backward
$endif

def hello(varname):
    """
    varname -- <{}>
    """

def hello(varname):
    """
    @param varname: <{}>
    @type varname: <{}>
    """

let docvars = map(split(text), 'v:val." -- ".st.et')

let docvars = map(split(text), '"\@param ".v:val."\: ".st.et."\n".indent."@type ".v:val."\: ".st.et')

:version

:python import sys; print sys.version

/opt/local/Library/Frameworks/Python.framework/Versions/Current/lib/python2.6/site-packages/IPython/Extensions

import vim
import socket

def runner(content):
    s = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
    try:
        # make sure to chage the directory here
        s.connect("/YOUR/HOME/DIR/.ipython/IPYS")
        s.send(content)
        s.close()
    except:
        print "Error: could not connect to iPython server."

# --- Functions for running code in iPython --------------------------------- #

def run_current_line():
    runner(vim.current.line)

def run_selection():
    runner("\n".join(vim.current.range))

def run_buffer():
    runner("\n".join(vim.current.buffer))

# --- Clean up function

def remove_sockets():
    import os
    import sys
    os.remove("/Users/petrov/.ipython/IPYS")

$HOME/.ipython/IPYS

$HOME/.vim/plugin

import ipy_textmateserver
# create the server
s = ipy_textmateserver.TextMateServer()
# start the server
s.start()
# to stop the server do: s.stop()

:map ,el :python run_current_line()<cr>

import sys
from time import sleep

from PyQt4.QtCore import *
from PyQt4.QtGui import *


LOADING_MESSAGE = "Loading stuff"
# set this to point to .png file somewhere on your disk. For example
# SPLASH_IMAGE = "/Users/username/Desktop/image.png"
SPLASH_IMAGE_PATH = ""

class Box(QDialog):
    def __init__(self, parent=None):
        super(Box, self).__init__(parent)


if __name__ == "__main__":
    qapp = QApplication(sys.argv)

    splash = QSplashScreen(QPixmap(SPLASH_IMAGE_PATH))
    splash.showMessage(LOADING_MESSAGE)
    splash.show()

    qapp.processEvents()

    for i in xrange(10):
        sleep(1)
        print i

    box = Box()
    box.show()
    splash.finish(box)
    sys.exit(qapp.exec_())

res = dict([(item_list.count(r), r) for r in list(set(item_list))])
print {max(res.keys()): res[max(res.keys())]}