print('MDP Testing')

from mvpa.datasets import Dataset

from mvpa.datasets.masked import MaskedDataset

#2d only

data=Dataset(samples=sp.randn(10,5),labels=1)

print('labels',data.labels)

print('chunks',data.chunks)

print('samples',data.samples)

#nd

mdata = MaskedDataset(samples=sp.random.normal(size=(5,3,4)),labels=[1,2,3,4,5])

print('labels',mdata.labels)

print('nfeatures',mdata.nfeatures)

print('samples',mdata.samples)

print('mapforward',mdata.mapForward(sp.arange(12).reshape(3,4)))

#from FuncDesigner import *

a, b, c = fd.oovars('a', 'b', 'c')

f1, f2 = fd.sin(a) + fd.cos(b) - fd.log2(c) + fd.sqrt(b), fd.sum(c) + c * fd.cosh(b) / fd.arctan(a) + c[0] * c[1] + c[-1] / (a * c.size)

f3 = f1*f2 + 2*a + fd.sin(b) * (1+2*c.size + 3*f2.size)

f = 2*a*b*c + f1*f2 + f3 + fd.dot(a+c, b+c)

point = {a:1, b:2, c:[3, 4, 5]} # however, you'd better use numpy arrays instead of Python lists

print(f(point))

print(f.D(point))

print(f.D(point, a))

print(f.D(point, [b]))

#use scipy.spatial

#and read info here http://folk.uio.no/sturlamo/python/multiprocessing-tutorial.pdf

#and http://www.scipy.org/Cookbook/KDTree

#read also the wikipedia article

#we could use a kdtree or the birch algorithm to initialize k-means

data=sp.rand(100,4)

cid,e,n=pcl.kcluster(data)

centroids,cmask=pcl.clustercentroids(D,clusterid=cid)

print data

'''

g++ maxflow.cpp graph.cpp Fast_PD.cpp -o Fast_PD.so -shared -fPIC

'''

import ctypes as ct

import scipy as sp

import form

#name and directory of the shared lib

lib = sp.ctypeslib.load_library('Fast_PD.so', '/home/eg01/Devel/Discrete_Optimization/FastPD/FastPD_ElfVersion')

lib.test.argtypes = [ct.c_void_p]

lib.test.restype= ct.c_void_p

'''

Vassilis Implementation +

http://xin.cz3.nus.edu.sg/group/personal/cx/modules/DM/birch.ppt

http://people.cs.ubc.ca/~rap/teaching/504/2005/slides/Birch.pdf

'''

#void birch_py(double *data,int mrows, int DIMENSION, int K_, int B_, int L_, double wp, double wd, double T_, double *codeBook, double *codeIndices)

'''

compile with gcc -o birch.so -shared birch.c -fPIC

run: [codeBook, codeIndices] = birch(reflectionCoefficients, numCodeVectors, B, L, wp, wd, T); */

B, L: design parameters for the data structure give B = 10, L = 10 */

wp, wd: mixing parameters give wp = 5, wd = 0.2 */

T: threshold give 0 or a small value specific to the problem */

'''

import ctypes as ct

import scipy as sp

import form

#name and directory of the shared lib

lib = sp.ctypeslib.load_library('birch.so', '/home/eg01/Devel/BirchLGB/birch_py')

#A=100*sp.rand(200,3)

R=form.loadmat('ref.mat')

A=R['reflectionCoefficients']

rows=A.shape[0]

cols=A.shape[1]

A=sp.arange(rows*cols).reshape((rows,cols))

print A

#return

A=sp.asarray(A,dtype=sp.double)

Mat=sp.empty_like(A)

lib.birch_py.argtypes = [sp.ctypeslib.ndpointer(dtype = sp.double),

ct.c_int, ct.c_int, ct.c_int, ct.c_int, ct.c_int,

ct.c_double,ct.c_double,ct.c_double,

sp.ctypeslib.ndpointer(dtype = sp.double),

sp.ctypeslib.ndpointer(dtype = sp.intc)]

lib.birch_py.restype= ct.c_void_p

#K,B,L,wp,wd,T=3,10,10,5,0.2,0

K,B,L,wp,wd,T=128,10,10,5,0.2,0.01

codeBook=sp.zeros(cols*K)

codeIndices=sp.ones(rows)

codeBook=sp.asarray(codeBook,dtype=sp.double)

codeIndices=sp.asarray(codeIndices,dtype=sp.intc)

#lib.birch_py(A,int(rows),int(cols),int(K),int(B),int(L),wp,wd,T,codeBook,codeIndices)

lib.birch_py(A,int(rows),int(cols),int(K),int(B),int(L),float(wp),float(wd),float(T),codeBook,codeIndices)

#print 'A:',A

print 'codeBook',codeBook.reshape(K,cols)

'''

We have this simple graph

A -> B, A -> C, B -> C, B -> D, C -> D, D -> C, E -> F, F -> C

We are going to use dict to create this graph

'''

graph={'A':['B','C'],'B':['C','D'],'C':['D'],'D':['C'],'E':['F'],'F':['C']}

def find_path(graph,start,end, path=[]):

path=path+[start]

if start == end:

return path

if not graph.has_key(start):

return None

for node in graph[start]:

if node not in path:

newpath=find_path(graph,node,end,path)

if newpath:

return newpath

return None

def find_all_paths(graph, start, end, path=[]):

path = path + [start]

if start == end:

return [path]

if not graph.has_key(start):

return []

paths = []

for node in graph[start]:

if node not in path:

newpaths = find_all_paths(graph, node, end, path)

for newpath in newpaths:

paths.append(newpath)

return paths

def find_shortest_path(graph, start, end, path=[]):

path = path + [start]

if start == end:

return path

if not graph.has_key(start):

return None

shortest = None

for node in graph[start]:

if node not in path:

newpath = find_shortest_path(graph, node, end, path)

if newpath:

if not shortest or len(newpath) < len(shortest):

shortest = newpath

return shortest

print 'Entire graph'

print graph

print 'All root nodes'

for node in graph:

print node

print 'Nodes under A'

for node in graph['A']:

print node

print 'Find Path A->D',find_path(graph,'A','D')

print 'Find Path A->F',find_path(graph,'A','F')

print 'Find all Paths A->D',find_all_paths(graph,'A','D')

print 'Find shortest Path A->D',find_shortest_path(graph, 'A', 'D')

print 'Some tests'

testg={'A':['B',3,'C',4], 'B':['C',3]}

print testg

#Example is from

#http://networkx.lanl.gov/tutorial/tutorial.html

import networkx as nx

G=nx.Graph()

print(G)

G.add_node(1)

print(G)

G.is_directed()

G.add_nodes_from([2,3])

G.add_nodes_from(nx.path_graph(10))

G.add_edge(1,2)

e=(2,3)

G.add_edge(*e)

G.add_edges_from(nx.path_graph(10).edges())

G.number_of_nodes()

G.number_of_edges()

G.nodes()

G.edges()

G.neighbors(1)

H=nx.DiGraph(G)

H.edges()

H2=nx.Graph({0:[1,2,3], 1:[0,3], 2:[0], 3:[0]})

H3=nx.Graph()

H3.add_edge(1,2,color='red')

H3.add_edges_from([(1,3,{'color':'blue'}), (2,0,{'color':'red'}), (0,3)])

H.edges()

H3.nodes()

H3.edges(data=True)

H3.add_edge(0,3,color='green')

H3.edges()

H3.edges(data=True)

H3.nodes()

H3[0]

H3[0][2]

H3[0][3]

H3.add_edge(1,3)

H3[1][3]['color']='blue'

FG=nx.Graph()

FG.add_weighted_edges_from([(1,2,0.125),(1,3,0.75),(2,4,1.2),(3,4,0.375)])

#Fast examination of all edges

for n, nbrs in FG.adjacency_iter():

for nbr, eattr in nbrs.iteritems():

data=eattr['weight']

if data < 0.5: print (n,nbr, data)

FG.adjacency_iter()

FG.adjacency_iter().next()

FG

FG.nodes()

FG.edges()

FG.adjacency_iter().next()

FG[3][4]

FG[3][4]['weight']

DG=nx.DiGraph()

DG.add_weighted_edges_from([(1,2,0.5), (3,1,0.75)])

DG.out_degree(1,weighted=True)

DG.degree(1,weighted=True)

DG.edges()

DG.nodes()

DG.successors(1)

DG.neighbors(1)

DG.neighbors(3)

UG=G.to_undirected()

UG2=nx.Graph(G)

MG=nx.MultiGraph()

MG.add_weighted_edges_from([(1,2,.5), (1,2,.75), (2,3,.5)])

MG.degree(weighted=True, with_labels=True)

GG=nx.Graph()

for n,nbrs in MG.adjacency_iter():

for nbr,edict in nbrs.iteritems():

minvalue=min(edict.values())

GG.add_edge(n,nbr,minvalue)

nx.shortest_path(GG,1,3)

nx.connected_components(G)

sorted(nx.degree(G))

G.nodes()

nx.clustering(G)

import matplotlib.pyplot as plt

nx.draw(G)

plt.show()

nx.draw_random(G)

nx.draw_circular(G)

nx.draw_spectral(G)

nx.draw_spring(G)

nx.draw_spring(G)