In [1]:

    

import numpy
import codecs


    

In [2]:

    

class Parameters(object):
    def __init__(self):
        self.n_in = 8
        self.m = 20
        self.n_out = 8
        self.k = 4
        self.h = 0.007


    

In [3]:

    

parameters = Parameters()


    

In [4]:

    

mu = numpy.sqrt(2.0 * parameters.h)
print mu
print 1.0 - (parameters.k - 1) * mu


    

    




0.118321595662
0.645035213014

In [5]:

    

def dependent_equal(parameters):
    pattern = numpy.zeros(shape=(parameters.n_out, parameters.n_in))
    mu = 1.0 / parameters.k
    pattern[:parameters.k,] = mu
    return pattern


    

In [6]:

    

def dependent_unequal(parameters):
    pattern = numpy.zeros(shape=(parameters.n_out, parameters.n_in))
    mu = numpy.sqrt(2.0 * parameters.h)
    rest = 1.0 - (parameters.k - 1) * mu
    pattern[0,] = rest
    pattern[1:parameters.k,] = mu
    return pattern


    

In [7]:

    

def independent_equal(parameters):
    pattern = numpy.zeros(shape=(parameters.n_out, parameters.n_in))
    mu = 1.0 / parameters.k
    start = 0
    for j in range(parameters.n_in):
        for i in range(parameters.k):
            index = (start + i) % parameters.n_out
            pattern[index, j] = mu
        start += 1
    return pattern


    

In [8]:

    

def independent_unequal(parameters):
    pattern = numpy.zeros(shape=(parameters.n_out, parameters.n_in))
    mu = numpy.sqrt(2.0 * parameters.h)
    rest = 1.0 - (parameters.k - 1) * mu
    start = 0
    for j in range(parameters.n_in):
        pattern[start % parameters.n_out, j] = rest
        for i in range(1, parameters.k):
            index = (start + i) % parameters.n_out
            pattern[index, j] = mu
        start += 1
    return pattern


    

In [9]:

    

def plot_pattern(matrix):
    plt.matshow(matrix, cmap=plt.cm.gray_r, vmin=0.0, vmax=1.0)
    plt.colorbar()
    plt.show()


    

In [10]:

    

pattern_de = dependent_equal(parameters)
plot_pattern(pattern_de)


    

In [11]:

    

numpy.linalg.matrix_rank(pattern_de)


    

    
Out[11]:





1

In [12]:

    

pattern_du = dependent_unequal(parameters)
plot_pattern(pattern_du)


    

In [13]:

    

numpy.linalg.matrix_rank(pattern_du)


    

    
Out[13]:





1

In [14]:

    

pattern_ie = independent_equal(parameters)
plot_pattern(pattern_ie)


    

In [15]:

    

numpy.linalg.matrix_rank(pattern_ie)


    

    
Out[15]:





5

In [16]:

    

pattern_iu = independent_unequal(parameters)
plot_pattern(pattern_iu)


    

In [17]:

    

numpy.linalg.matrix_rank(pattern_iu)


    

    
Out[17]:





8

In [18]:

    

def write_pattern(file_h, pattern, label):
    for i in range(pattern.shape[0]):
        for j in range(pattern.shape[1]):
            file_h.write("%d,%d,%f,%s\n" % (i + 1, j + 1, pattern[i, j], label))


    

In [19]:

    

filename = "output_patterns.csv"
with codecs.open(filename, mode="wb", encoding="utf-8") as file_h:
    file_h.write("i,j,value,setup\n")
    write_pattern(file_h, pattern_de, "Dependent & Equal")
    write_pattern(file_h, pattern_du, "Dependent & Unequal")
    write_pattern(file_h, pattern_ie, "Independent & Equal")
    write_pattern(file_h, pattern_iu, "Independent & Unequal")