In [1]:

    

import bidict


    

In [6]:

    

interval_quality_map = {
    True: {-2:'dd', -1:'d', 0:'p', 1:'a', 2:'da'},
    False: {-2:'d', -1:'min', 0:'maj', 1:'a', 2:'da'}
}


    

In [56]:

    

primary_map = [
(0,  1, "unison",  "C", True),  #0
(2,  2, "second",  "D", False), #1
(4,  3, "third",   "E", False), #2
(5,  4, "fourth",  "F", True),  #3
(7,  5, "fifth",   "G", True),  #4
(9,  6, "sixth",   "A", False), #5
(11, 7, "seventh", "B", False)  #6
]

hs_map = bidict.bidict({x:item[0] for x, item in enumerate(primary_map)})
interval_map = bidict.bidict({x:item[1] for x, item in enumerate(primary_map)})
interval_name_map = bidict.bidict({x:item[2] for x, item in enumerate(primary_map)})
name_map = bidict.bidict({x:item[3] for x, item in enumerate(primary_map)})
quality_map = {x:item[4] for x, item in enumerate(primary_map)}


    

In [ ]:

    

qualities = {
    'd'
}
intervals = {
    0 : 
}


    

In [47]:

    

name_map


    

    
Out[47]:





bidict({0: 'C', 1: 'D', 2: 'E', 3: 'F', 4: 'G', 5: 'A', 6: 'B'})

In [ ]:

    




    

In [ ]:

    




    

In [27]:

    

modifiers = bidict.bidict({
    -2 : 'doubleflat',
    -1 : 'flat',
    0 : 'natural',
    1 : 'sharp', 
    2 : 'doublesharp'
})


    

In [41]:

    

def chroma(x):
    name = primary_map[x[0]][3]
    modifier = modifiers[x[1] - primary_map[x[0]][0]]
    return name, modifier


    

In [29]:

    

chroma((1,1))


    

    
Out[29]:





('D', 'flat')

In [ ]:

    

def interval(x):
    name = primary_map[x[0]][2]
    quality_modifier = x[1] - primary_map[x[0]][0]


    

In [31]:

    

def add_tup(x, y):
    return tuple(map(sum,zip(x,y)))


    

In [32]:

    

chroma(add_tup((1,1), (2, 4)))


    

    
Out[32]:





('F', 'natural')

In [34]:

    

%timeit chroma(add_tup((1, 2),(4, 7)))


    

    




3.27 µs ± 52.6 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each)

In [35]:

    

import ophis


    

In [38]:

    

%timeit ophis.D + ophis.Perfect(5)


    

    




108 µs ± 1.42 µs per loop (mean ± std. dev. of 7 runs, 10000 loops each)

In [39]:

    

%timeit chroma(add_tup((0,0),(1, 2)))


    

    




3.64 µs ± 579 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each)

In [40]:

    

%timeit ophis.C.augment()


    

    




95.8 µs ± 587 ns per loop (mean ± std. dev. of 7 runs, 10000 loops each)

In [52]:

    

def chroma_from_name(name,modifier):
    x = name_map.inv[name]
    y = modifiers.inv[modifier]
    return x,y


    

In [54]:

    

chroma_from_name('C', 'sharp')


    

    
Out[54]:





(0, 1)

In [ ]:

    

def interval_from_name(q, n):
    x = n - 1
    q_diff = hs_map.inv[x]


    

In [ ]:

    




    

In [ ]:

    




    

In [ ]:

    




    

In [ ]:

    




    

In [ ]: