In [1]:

    

from functools import lru_cache
from itertools import count
import random
import time

import ophis

intervals = [*ophis.Interval.instances]
r_s = random.randrange(100)


    

In [2]:

    

class QI_plain:
    
    total_QIs = 0
    
    def __init__(self, interval, octave):
        self.interval = interval
        self.octave = octave
        self.__class__.total_QIs = self.__class__.total_QIs + 1
        
    # naive implementations of methods for testing    
    
    def augmented(self, distance):
        return QI_plain(self.interval.augmented(distance), self.octave)
    
    def diminished(self, distance):
        return QI_plain(self.interval.diminished(distance), self.octave)
    
    def inverted(self):
        return QI_plain(self.interval.inverted(), self.octave)
    
    def octv(self, octaves=0):
        return QI_plain(self.interval, (self.octave + octaves))


    

In [3]:

    

x = QI_plain(ophis.M7, 2)
y = QI_plain(ophis.M7, 2)
z = QI_plain(ophis.M7, 2)

x is y


    

    
Out[3]:





False

In [4]:

    

QI_plain.total_QIs


    

    
Out[4]:





3

In [5]:

    

random.seed(r_s) # that's the spirit

start_plain_test = time.time()

plain_set = set()

for i in range(1000000):
    interval = random.choice(intervals)
    octaves = random.randrange(10)
    plain_set.add(QI_plain(interval, octaves))
    
for x in [*plain_set]:
    plain_set.add(x.augmented(random.randrange(5)))
    plain_set.add(x.diminished(random.randrange(5)))
    plain_set.add(x.inverted())
    plain_set.add(x.octv(random.randrange(5)))
    
    
plain_time = time.time() - start_plain_test

print( str(len(plain_set)) + " instances created in " + str(plain_time) + " seconds." )


    

    




5000000 instances created in 118.94781589508057 seconds.

In [6]:

    

@lru_cache(maxsize=None, typed=False)
class QI_cache:
    
    total_QIs = 0
    
    def __init__(self, interval, octave):
        self.interval = interval
        self.octave = octave
        self.__class__.total_QIs = self.__class__.total_QIs + 1
        
    # naive implementations of methods for testing    
    
    def augmented(self, distance):
        return QI_cache(self.interval.augmented(distance), self.octave)
    
    def diminished(self, distance):
        return QI_cache(self.interval.diminished(distance), self.octave)
    
    def inverted(self):
        return QI_cache(self.interval.inverted(), self.octave)
    
    def octv(self, octaves=0):
        return QI_cache(self.interval, (self.octave + octaves))


    

In [8]:

    

x = QI_cache(ophis.M7, 2)
y = QI_cache(ophis.M7, 2)
z = QI_cache(ophis.M7, 2)

x is y


    

    
Out[8]:





True

In [11]:

    

random.seed(r_s) # that's the spirit

start_cache_test = time.time()

cache_set = set()

for i in range(1000000):
    interval = random.choice(intervals)
    octaves = random.randrange(10)
    cache_set.add(QI_cache(interval, octaves))
    
for x in [*cache_set]:
    plain_set.add(x.augmented(random.randrange(5)))
    plain_set.add(x.diminished(random.randrange(5)))
    plain_set.add(x.inverted())
    plain_set.add(x.octv(random.randrange(5)))
    
    
cache_time = time.time() - start_cache_test

print( str(len(cache_set)) + " instances created in " + str(cache_time) + " seconds." )


    

    




440 instances created in 4.87639307975769 seconds.

In [19]:

    

magnitude = plain_time/cache_time
print("OMG, it took " + str(magnitude) + " times as long.")


    

    




OMG, it took 24.392581555585163 times as long.

In [17]:

    

big_start = time.time()
for i in range(1000000):
    x = i
big_time = time.time() - big_start

small_start = time.time()
for i in range(500):
    x = i
small_time = time.time() - small_start

magnitude = big_time/small_time

print("OMG, it would take " + str(magnitude) + " times as long to do simple things!")


    

    




OMG, it would take 802.1686143572621 times as long to do simple things!

In [ ]:

    




    

In [ ]:

    




    

In [ ]:

    




    

In [ ]:

    




    

In [ ]:

    




    

In [13]:

    




    

    




0.0002028942108154297

In [ ]:

    




    

In [ ]:

    




    

In [ ]:

    




    

In [ ]:

    




    

In [ ]:

    




    

In [ ]:

    




    

In [ ]:

    




    

In [ ]:

    




    

In [ ]:

    




    

In [ ]:

    




    

In [ ]:

    




    

In [ ]:

    




    

In [ ]:

    




    

In [ ]:

    




    

In [ ]:

    




    

In [ ]:

    




    

In [ ]:

    




    

In [ ]:

    




    

In [ ]:

    




    

In [ ]:

    




    

In [ ]: