def __init__(self, infoRun, data = ''): self.infoRun = infoRun self.SetEnvironment(self.infoRun) self.data = data counter = 0 # Apply selection cut for bck in self.backgrounds: self.listOfSelectors.append(Selector(bck, self.savepath)) counter += 1 if (self.data != ''): self.dataSelector = Selector(self.data, self.savepath) # == Draw histograms # Parse selectors and other parameters to the Plotter class p = Plotter(self.listOfSelectors, self.dataSelector, self.Histos, self.colors) p.SetSavePath(self.savepath) p.SetAnnotations(self.Annotations) p.DrawHistos() # ===== Compute the cross-section # == Set attributes and parameters and compute the final result self.SetParameters('MuonPt') self.PrintXsection('MuonPt') return
def __init__(self, core_file_name): super(Listener, self).__init__() self.core_file_name = core_file_name self.setup_ui() self.setup_timers() port = SERIAL_PORT self.serial = serial.Serial(port, BAUDE_RATE, timeout=0) self.incoming_data = [] self.imu = IMU(PLATFORM_SPECIFIC_QUOTIENTS['stm']) self.stroke = Stroke() self.selector = Selector(self.core_file_name) self.acceleration_filter = AperiodicFilter(ACCELERATION_TIME_CONST) self.stroke.widget = self.display self.stroke.on_done = self.get_stroke self.previous_time = None self.data_buffer = '' self.init_selector()
def __init__(self, body, url='', meta=None, status=-1): self._status = int(status) self._url = url self._body = body self._selector = Selector(body) self._meta = meta or {} self._id = -1
def test_RunsForever(self): """main - Run with no messages, keeps running""" S = Selector() S.activate() for i in xrange(1,100): try: S.next() except StopIteration: self.fail("Component should run until told to stop. Failed on iteration: "+str(i))
def test_list(self): event = Event(0) event.the_list = range(10) cfg_ana = cfg.Analyzer(Selector, output='filtered', input_objects='the_list', filter_func=lambda x: x % 2 == 0) cfg_comp = cfg.Component('test', files=[]) filter = Selector(cfg_ana, cfg_comp, self.outdir) filter.process(event) self.assertItemsEqual(event.filtered, [0, 2, 4, 6, 8])
def test_dict(self): event = Event(0) event.the_dict = dict([(x, x**2) for x in range(10)]) cfg_ana = cfg.Analyzer(Selector, output='filtered', input_objects='the_dict', filter_func=lambda x: x == 9) cfg_comp = cfg.Component('test', files=[]) filter = Selector(cfg_ana, cfg_comp, self.outdir) filter.process(event) self.assertDictEqual(event.filtered, {3: 9})
def start(self): self.input_controller.fault_tolerance_request() self.input_controller.initial_groups_request() self.input_controller.blocked_vector_request() tested_faults = len(max(self.input_controller.initial_groups, key=len)) processors = Processors(self.input_controller.initial_groups) generator = FormulasGenerator(processors, self.input_controller.fault_tolerance) selector = Selector(self.input_controller.blocked_vectors) tester = PrTester(processors) blocker = Blocker(self.input_controller.blocked_vectors, tester, selector, processors) ''' For original formulas ''' generator.generate(self.input_controller.initial_groups, self.original_formulas_file) optimizer_original = Optimizer(self.input_controller.fault_tolerance, processors, self.optimized_original_file) optimizer_original.optimize(generator.origin_formulas_arr) blocking_original_formulas = blocker.block_original( selector.select_group(optimizer_original.result_formulas)) tester.test(self.result_of_testing_original_file, blocking_original_formulas, tested_faults, self.input_controller.fault_tolerance) ''' For researched formulas ''' self.input_controller.researched_way_request() if self.input_controller.researched_way: generator.generate( processors.form_groups_according_to_blocked_vector( self.input_controller.blocked_vectors), self.researched_formulas_file) optimizer_researched = Optimizer( self.input_controller.fault_tolerance, processors, self.optimized_researched_file) optimizer_researched.optimize(generator.origin_formulas_arr) #selector.select_group(optimizer_researched.result_formulas) blocking_researched_formulas = blocker.block_researched( selector.select_group(optimizer_researched.result_formulas)) tester.test(self.result_of_testing_researched_file, blocking_researched_formulas, tested_faults, self.input_controller.fault_tolerance) self.input_controller.repeat_request() return self.input_controller.repeat
def __init__(self, processes, hist_list, colors): ''' Initialize a new plotter... give a list with all names of MC samples and the name of the data sample ''' #self.ResetVariables() for p in processes: if processes[p] == "data": self.data = Selector(hist_list, processes[p]) elif "+" in processes[p]: self.signal = Selector(hist_list, processes[p]) else: self.backgrounds.append(Selector(hist_list, processes[p])) return
class Response(object): def __init__(self, body, url='', meta=None, status=-1): self._status = int(status) self._url = url self._body = body self._selector = Selector(body) self._meta = meta or {} self._id = -1 @property def url(self): return self._url @property def body(self): return self._body @property def meta(self): return self._meta @property def status(self): return self._status def dumps(self): return cPickle.dumps( dict(url=self.url, status=self.status, body=self.body, meta=self.meta)) @classmethod def loads(cls, s): if isinstance(s, unicode): s = s.encode('utf-8') dct = cPickle.loads(s) return cls(**dct) def xpath(self, query, **kwargs): return self._selector.xpath(query, **kwargs) def re(self, regex): return self._selector.re(regex) def re_first(self, regex): try: return self._selector.re(regex)[0] except: return ''
def test_list(self): event = Event(0) event.the_list = range(10) cfg_ana = cfg.Analyzer( Selector, output = 'filtered', input_objects = 'the_list', filter_func = lambda x : x%2 == 0 ) cfg_comp = cfg.Component( 'test', files = [] ) filter = Selector(cfg_ana, cfg_comp, self.outdir) filter.process(event) self.assertItemsEqual(event.filtered, [0,2,4,6,8])
def test_dict(self): event = Event(0) event.the_dict = dict( [ (x, x**2) for x in range(10) ] ) cfg_ana = cfg.Analyzer( Selector, output = 'filtered', input_objects = 'the_dict', filter_func = lambda x : x == 9 ) cfg_comp = cfg.Component( 'test', files = [] ) filter = Selector(cfg_ana, cfg_comp, self.outdir) filter.process(event) self.assertDictEqual(event.filtered, {3:9})
def __init__(self, director): Scene.__init__(self, director) self.rueda = Selector(self.director.screen, (WIDTH / 2, HEIGHT / 2)) self.rueda.asociateEvent(0, colorear, self.director.screen, (255, 0, 0)) self.rueda.asociateEvent(1, colorear, self.director.screen, (0, 0, 255)) self.rueda.asociateEvent(2, colorear, self.director.screen, (0, 255, 0)) self.rueda.asociateEvent(3, colorear, self.director.screen, (0, 0, 0)) self.rueda.setIcon(0, "images/icon1.png") self.rueda.setIcon(1, "images/icon2.png") self.rueda.setIcon(2, "images/icon3.png") self.rueda.setIcon(3, "images/icon4.png")
def selector(self, **kwds): from Selector import Selector control = Selector(**kwds) from FormField import FormField field = FormField(control) self.contents.append(field) return control
def setupCSA(self, sock): """\ setupCSA(sock) -> new ConnectedSocketAdapter component Creates a ConnectedSocketAdapter component for the socket, and wires up to it. Also sends the CSA to the "selector" service. """ selectorService, selectorShutdownService, newSelector = Selector.getSelectorServices( self.tracker) if newSelector: self.addChildren(newSelector) CSA = ConnectedSocketAdapter( sock, selectorService, sendTo=self.remote) # self.createConnectedSocket(sock) self.addChildren(CSA) self.link((self, "_selectorSignal"), selectorService) self.link((CSA, "CreatorFeedback"), (self, "_socketFeedback")) self.link((CSA, "outbox"), (self, "outbox"), passthrough=2) self.link((self, "inbox"), (CSA, "inbox"), passthrough=1) self.link((self, "control"), (CSA, "control"), passthrough=1) # propagate shutdown msgs self.send(newReader(CSA, ((CSA, "ReadReady"), sock)), "_selectorSignal") self.send(newWriter(CSA, ((CSA, "SendReady"), sock)), "_selectorSignal") self.CSA = CSA # We need this for shutdown later return self.childComponents()
def setupCSA(self, sock): """\ setupCSA(sock) -> new ConnectedSocketAdapter component Creates a ConnectedSocketAdapter component for the socket, and wires up to it. Also sends the CSA to the "selector" service. """ selectorService, selectorShutdownService, newSelector = Selector.getSelectorServices(self.tracker) if newSelector: self.addChildren(newSelector) CSA = ConnectedSocketAdapter(sock, selectorService, sendTo=self.remote) # self.createConnectedSocket(sock) self.addChildren(CSA) self.link((self, "_selectorSignal"),selectorService) self.link((CSA, "CreatorFeedback"),(self,"_socketFeedback")) self.link((CSA, "outbox"), (self, "outbox"), passthrough=2) self.link((self, "inbox"), (CSA, "inbox"), passthrough=1) self.link((self, "control"), (CSA, "control"), passthrough=1) # propagate shutdown msgs self.send(newReader(CSA, ((CSA, "ReadReady"), sock)), "_selectorSignal") self.send(newWriter(CSA, ((CSA, "SendReady"), sock)), "_selectorSignal") self.CSA = CSA # We need this for shutdown later return self.childComponents()
def Selector1(): selector = Selector() dataProcessor = DataProcessor() #abil = selector.getAbilityWithId(3) passed = selector.runSelector() print(passed) selector.setCharacterStats(15, 15) passed = selector.runSelector() print(passed) print(selector.HP) print(selector.getAuraWithId(selector.getAbilityWithId(2)['auraOne']))
def __init__(self, parent=None, name='', f=0): QWidget.__init__(self, parent, name, f) self.setFixedWidth(1024) self.setFixedHeight(768) ## UPPER PANEL self.upperPanel = QFrame(self) self.upperPanel.setFixedWidth(self.width()) self.upperPanel.setFixedHeight(self.height() / 2) UpperLayout = QHBoxLayout(self.upperPanel) # Main SampleGroup self.mainSampleGroup = SampleGroup(self.upperPanel) self.mainSampleGroup.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding) UpperLayout.addWidget(self.mainSampleGroup) ## LOWER PANEL self.lowerPanel = QFrame(self) self.lowerPanel.setGeometry(0, self.height() / 2, self.width(), self.height() / 2) LowerLayout = QHBoxLayout(self.lowerPanel) # WidgetStack self.widgetStack = Widgets.WidgetStack(self.lowerPanel) self.widgetStack.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding) LowerLayout.addWidget(self.widgetStack) for i in range(NUM_SAMPLE_GROUPS): group = SampleGroup(None) self.widgetStack.addWidget(group) # Selector self.selector = Selector(self.lowerPanel) self.selector.addPath(os.path.join(os.environ['HOME'], 'wav')) self.selector.setFixedWidth(SELECTOR_WIDTH) self.selector.setFixedHeight(SELECTOR_HEIGHT) self.selector.move(self.width()-SELECTOR_WIDTH, self.height()-SELECTOR_HEIGHT) self.selector.openAll() QObject.connect(self.selector, PYSIGNAL('selected'), self.slotSelected) LowerLayout.addWidget(self.selector) ## SAMPLES self.freeSamples = Queue.Queue() self.busySamples = [] for i in range(CACHED_SAMPLES): self.newSample()
def test_SendingAReadableMessageResultsInItBeingSelectedAgainst(self): "main - If we send a newReader message to the notify inbox, it results in the selectable reader being selected on in the readers set" MOCKSELECTORMODULE = MockSelect() SELECTORMODULE.select = MOCKSELECTORMODULE S = Selector() S.activate() for i in xrange(100): S.next() dummyservice = (Axon.Component.component(), "inbox") S._deliver(newReader(S, (dummyservice, "LOOKINGFORTHIS")), "notify") for i in xrange(100): S.next() func, args = MOCKSELECTORMODULE.log[0] self.assertEqual("select", func, "select was called in the main loop") self.assertEqual(["LOOKINGFORTHIS"], args[0], "The selectable was added to the list of readables") self.assertEqual([], args[1], "Writable set should be empty") self.assertEqual([], args[2], "Exception set should be empty") self.assertEqual(0, args[3], "The select should be non-blocking")
def start(self): self.input_controller.fault_tolerance_request() self.input_controller.initial_groups_request() self.input_controller.blocked_vector_request() tested_faults = len(max(self.input_controller.initial_groups, key=len)) processors = Processors(self.input_controller.initial_groups) generator = FormulasGenerator(processors, self.input_controller.fault_tolerance) selector = Selector(self.input_controller.blocked_vectors) tester = PrTester(processors) blocker = Blocker(self.input_controller.blocked_vectors, tester, selector, processors) ''' For original formulas ''' generator.generate(self.input_controller.initial_groups, self.original_formulas_file) optimizer_original = Optimizer(self.input_controller.fault_tolerance, processors, self.optimized_original_file) optimizer_original.optimize(generator.origin_formulas_arr) blocking_original_formulas = blocker.block_original(selector.select_group(optimizer_original.result_formulas)) tester.test(self.result_of_testing_original_file, blocking_original_formulas, tested_faults, self.input_controller.fault_tolerance) ''' For researched formulas ''' self.input_controller.researched_way_request() if self.input_controller.researched_way: generator.generate(processors.form_groups_according_to_blocked_vector(self.input_controller.blocked_vectors), self.researched_formulas_file) optimizer_researched = Optimizer(self.input_controller.fault_tolerance, processors, self.optimized_researched_file) optimizer_researched.optimize(generator.origin_formulas_arr) #selector.select_group(optimizer_researched.result_formulas) blocking_researched_formulas = blocker.block_researched(selector.select_group(optimizer_researched.result_formulas)) tester.test(self.result_of_testing_researched_file,blocking_researched_formulas, tested_faults, self.input_controller.fault_tolerance) self.input_controller.repeat_request() return self.input_controller.repeat
def test_SendingAReadableMessageResultsInItBeingSelectedAgainst(self): "main - If we send a newReader message to the notify inbox, it results in the selectable reader being selected on in the readers set" MOCKSELECTORMODULE = MockSelect() SELECTORMODULE.select = MOCKSELECTORMODULE S = Selector() S.activate() for i in xrange(100): S.next() dummyservice = (Axon.Component.component(), "inbox") S._deliver(newReader(S,( dummyservice, "LOOKINGFORTHIS")),"notify") for i in xrange(100): S.next() func, args = MOCKSELECTORMODULE.log[0] self.assertEqual("select", func, "select was called in the main loop") self.assertEqual(["LOOKINGFORTHIS"], args[0], "The selectable was added to the list of readables") self.assertEqual([], args[1], "Writable set should be empty") self.assertEqual([], args[2], "Exception set should be empty") self.assertEqual(0, args[3], "The select should be non-blocking")
def test_WeSendTheSelectorAServiceAndSelectableOnlySelectsTheSelectable(self): "main - When we send the newReader message, it also includes a service upon which the selector can talk back to us. The selector only selects on the selectable part of the newReader message" MOCKSELECTORMODULE = MockSelect() SELECTORMODULE.select = MOCKSELECTORMODULE S = Selector() S.activate() for i in xrange(100): S.next() dummyservice = (Axon.Component.component(), "inbox") S._deliver(newReader(S,( dummyservice, "LOOKINGFORTHIS") ),"notify") for i in xrange(100): S.next() func, args = MOCKSELECTORMODULE.log[0] self.assertEqual("select", func, "select was called in the main loop") self.assertEqual(["LOOKINGFORTHIS"], args[0])#, "The selectable was added to the list of readables") self.assertEqual([], args[1], "Writable set should be empty") self.assertEqual([], args[2], "Exception set should be empty") self.assertEqual(0, args[3], "The select should be non-blocking")
def __init__(self, editor): GObject.__init__(self) from Selector import Selector Selector(self, editor) from TextInserter import Inserter Inserter(self, editor) from CaseProcessor import Processor Processor(self, editor) from TextExtractor import Extractor Extractor(self, editor) from Marker import Marker Marker(self, editor)
def test_WeSendTheSelectorAServiceAndSelectableOnlySelectsTheSelectable( self): "main - When we send the newReader message, it also includes a service upon which the selector can talk back to us. The selector only selects on the selectable part of the newReader message" MOCKSELECTORMODULE = MockSelect() SELECTORMODULE.select = MOCKSELECTORMODULE S = Selector() S.activate() for i in xrange(100): S.next() dummyservice = (Axon.Component.component(), "inbox") S._deliver(newReader(S, (dummyservice, "LOOKINGFORTHIS")), "notify") for i in xrange(100): S.next() func, args = MOCKSELECTORMODULE.log[0] self.assertEqual("select", func, "select was called in the main loop") self.assertEqual( ["LOOKINGFORTHIS"], args[0]) #, "The selectable was added to the list of readables") self.assertEqual([], args[1], "Writable set should be empty") self.assertEqual([], args[2], "Exception set should be empty") self.assertEqual(0, args[3], "The select should be non-blocking")
def gui(): global inpt global active global stdscr global inptwin global dirwin global selector if active: selector = Selector( [Item('num1'), Item('num2'), Item('num3'), Item('num4')]) selector.updateSelectorDisplay(dirwin) #dirwin.addstr(selector.getDisplayString()) dirwin.refresh() inptwin.addstr('x>') inptwin.refresh() start()
def test_shutdownMessageCausesShutdown(self): """main - If the component recieves a shutdown() message, the component shuts down""" S = Selector() S.activate() S._deliver(shutdown(), "control") componentExit = False for i in xrange(2000): try: S.next() except StopIteration: componentExit = True break if not componentExit: self.fail( "When sent a shutdown message, the component should shutdown")
def test_ActivityOnReaderResultsInMessageOnReadersService(self): "main - Activity on the selectable results in a message appearing in the service provided to the selector" MOCKSELECTORMODULE = MockSelect() SELECTORMODULE.select = MOCKSELECTORMODULE S = Selector() S.activate() for i in xrange(100): S.next() D = Axon.Component.component() dummyservice = (D, "inbox") S._deliver(newReader(S, (dummyservice, "LOOKINGFORTHIS")), "notify") for i in xrange(100): S.next() try: S.postoffice.next() except: pass self.assert_(not (D.inboxes["inbox"] == [])) selectable = D.recv("inbox") self.assertEqual( selectable, "LOOKINGFORTHIS" ) #, "The value returned should be the selectable we originally asked for")
def __init__(self): self.state = 0 self.elements = { 0: [ Button("Start Game", 1, ["centered", 300]), Button("Quit", "quit", ["centered", 450]) ], 1: [ Button("Step By Step", "any", ["centered", 300]), Button("Any Level", 2, ["centered", 450]), Button("Back", 0, ["centered", 600]) ], 2: [Selector(), Button("Back", 1, ["centered", 800])] }
def test_ActivityOnReaderResultsInMessageOnReadersService(self): "main - Activity on the selectable results in a message appearing in the service provided to the selector" MOCKSELECTORMODULE = MockSelect() SELECTORMODULE.select = MOCKSELECTORMODULE S = Selector() S.activate() for i in xrange(100): S.next() D = Axon.Component.component() dummyservice = (D, "inbox") S._deliver(newReader(S,( dummyservice, "LOOKINGFORTHIS") ),"notify") for i in xrange(100): S.next(); try: S.postoffice.next() except: pass self.assert_(not ( D.inboxes["inbox"] == [] ) ) selectable = D.recv("inbox") self.assertEqual(selectable,"LOOKINGFORTHIS")#, "The value returned should be the selectable we originally asked for")
def test_RunsForever(self): """main - Run with no messages, keeps running""" S = Selector() S.activate() for i in xrange(1, 100): try: S.next() except StopIteration: self.fail( "Component should run until told to stop. Failed on iteration: " + str(i))
def test_shutdownMessageCausesShutdown(self): """main - If the component recieves a shutdown() message, the component shuts down""" S = Selector() S.activate() S._deliver(shutdown(),"control") componentExit = False for i in xrange(2000): try: S.next() except StopIteration: componentExit = True break if not componentExit: self.fail("When sent a shutdown message, the component should shutdown")
def __init__(self, editor): Signal.__init__(self) from Feedback import Feedback Feedback(self, editor) from UndoManager import Manager Manager(self, editor) from Selector import Selector Selector(self, editor) from QuoteCharacterMatcher import Matcher Matcher(self, editor) from RangeChecker import Checker Checker(self, editor) from PairCharacterMatcher import Matcher Matcher(self, editor) from OpenCharacterSearcher import Searcher Searcher(self, editor) from SelectionChecker import Checker Checker(self, editor)
def __init__(self): _ = Colour.BLACK W = Colour.WHITE self.board = [ [_, _, W, _, _, W, _, _], [_, _, W, _, _, W, _, _], [W, W, W, W, W, W, W, W], [_, _, W, _, _, W, _, _], [_, _, W, _, _, W, _, _], [W, W, W, W, W, W, W, W], [_, _, W, _, _, W, _, _], [_, _, W, _, _, W, _, _], ] self.state = State() self.selector = Selector()
def __init__(self, editor): GObject.__init__(self) from Selector import Selector Selector(self, editor) from TextInserter import Inserter Inserter(self, editor) from SelectionProcessor import Processor Processor(self, editor) from IndentationProcessor import Processor Processor(self, editor) from IndentationCharacter import Character Character(self, editor) from TextExtractor import Extractor Extractor(self, editor) from Marker import Marker Marker(self, editor) from OffsetExtractor import Extractor Extractor(self, editor) from Refresher import Refresher Refresher(self, editor)
def test_ActivityOnAnyExceptionalResultsInMessageOnThatExceptionalsService(self): "main - Activity on a selectable results in a message appearing in the service provided to the selector for that selectable" MOCKSELECTORMODULE = MockSelect(results=[ ([],[],["LOOKINGFORTHIS"]), ([],[],["THENFORTHIS"]), ([],[],["ANDTHENFORTHIS"]) ]) SELECTORMODULE.select = MOCKSELECTORMODULE S = Selector() S.activate() for i in xrange(5): S.next() D = Axon.Component.component() E = Axon.Component.component() F = Axon.Component.component() dummyservice1 = (D, "inbox") S._deliver(newExceptional(S,( dummyservice1, "LOOKINGFORTHIS") ),"notify") dummyservice2 = (E, "inbox") S._deliver(newExceptional(S,( dummyservice2, "THENFORTHIS") ),"notify") dummyservice3 = (F, "inbox") S._deliver(newExceptional(S,( dummyservice3, "ANDTHENFORTHIS") ),"notify") for i in xrange(5): S.next(); try: S.postoffice.next() except: pass selectable = D.recv("inbox") self.assertEqual(selectable,"LOOKINGFORTHIS")#, "The value returned should be the selectable we originally asked for") selectable = E.recv("inbox") self.assertEqual(selectable,"THENFORTHIS")#, "The value returned should be the selectable we originally asked for") selectable = F.recv("inbox") self.assertEqual(selectable,"ANDTHENFORTHIS")#, "The value returned should be the selectable we originally asked for")
def test_SendingMultipleReadersResultsInAllSelected(self): "main - Sending multiple newReader messages results in all being select()ed" MOCKSELECTORMODULE = MockSelect() SELECTORMODULE.select = MOCKSELECTORMODULE S = Selector() S.activate() for i in xrange(100): S.next() dummyservice = (Axon.Component.component(), "inbox") S._deliver(newReader(S,( dummyservice, "LOOKINGFORTHIS") ),"notify") S._deliver(newReader(S,( dummyservice, "LOOKINGFORTHISTOO") ),"notify") S._deliver(newReader(S,( dummyservice, "LOOKINGFORANDTHIS") ),"notify") for i in xrange(100): S.next() lastfunc, lastargs = None, None i = 0 func, args = MOCKSELECTORMODULE.log[i] while not( (lastfunc, lastargs) == (func, args)): # Search for quiescent state i = i + 1 lastfunc, lastargs = func, args func, args = MOCKSELECTORMODULE.log[i] self.assertEqual("select", func, "select was called in the main loop") self.assertEqual(["LOOKINGFORTHIS","LOOKINGFORTHISTOO","LOOKINGFORANDTHIS"], args[0])#, "The selectable was added to the list of readables")
def __init__(self, editor): GObject.__init__(self) from Selector import Selector Selector(self, editor)
def visualize(DE, iterations, title='Differential Evolution'): results, time = DE.run(iterations) fig, ax = plt.subplots(figsize=(8, 8)) for x in range(10): plt.plot(results[:, x], label='Vector' + str(x)) ax.ticklabel_format(style='plain') plt.ylabel("Profit/Fitness") plt.xlabel("Iteration") print('Time needed:', time) plt.legend() plt.show() # Parameter: np = 10 #Populationsize problemnumber = 1 F = 0.5 #Scale Factor Cr = 0.3 #Crossover probability ppp = PPP(problemnumber) initializer = Initializer(ppp, np) donorgenerator = DonorGenerator(F) trialgenerator = TrialGenerator(Cr, problemnumber) selector = Selector(ppp) de = DE DifferentialEvolution = de(ppp, initializer, donorgenerator, trialgenerator, selector) visualize(DifferentialEvolution, 500)
def generate_selector(self, number, basis): selector = Selector(number, basis) return selector
def selector(): from Selector import Selector return Selector()
def addPreProcess(self): steps = [] for preProcessMethod in self.preProcessingList: # MRMR args : # feature_correlations is the precomputed correlation matrix between the features, can't grid search on it # => set it once and for all # target_correlations is the precomputed correlation matrix between the features and the target, # can't grid search on it => set it once and for all # n_components, number of components with highest correlation with target, default to 20 # thresh, the threshold for the correlation above which we have to remove one feature, default to 1.0 if preProcessMethod == 'mrmr': feature_corr = self.feature_correlations.copy() target_corr = self.target_correlations.copy() steps.append(('mrmr', MRMR(feature_corr, target_corr, self.keys))) elif preProcessMethod == 'select_corr': steps.append(('select_corr', Selector(score_func=np.corrcoef, labels=self.keys, info_vector=self.target_correlations, random_state=self.seed))) # MutualInfoSelection args : # n_components, the number of components with the highest mutual info to keep, default to 20 elif preProcessMethod == 'select_mut': steps.append(('select_mut', Selector(score_func=mutual_info_regression, labels=self.keys, info_vector=self.target_muInf, random_state=self.seed))) # Whitening is equivalent to applying PCA on all the variables and scaling the variables to unit variance # Whitening args : # n_components, number of components to identify with PCA, default to all components elif preProcessMethod == 'whitening': steps.append( ('whitening', PCA(whiten=True, random_state=self.seed))) # No args elif preProcessMethod == 'standardization': steps.append(('standardization', StandardScaler())) # PCA args : # n_components, number of components to identify with PCA, default to all components elif preProcessMethod == 'PCA': steps.append(('PCA', PCA(random_state=self.seed))) # No args elif preProcessMethod == 'outliers': steps.append( ('outliers', FunctionSampler(func=remove_outliers))) # No args elif preProcessMethod == 'upsample': steps.append( ('upsampling', UpSampling(random_state=self.seed))) # No args elif preProcessMethod == 'downsample': steps.append( ('downsampling', DownSampling(random_state=self.seed))) # other pre-processing steps ? else: continue steps.append(('regression', self.model)) self.model = Pipeline(steps=steps)
def Selector2(): selector = Selector() dataProcessor = DataProcessor() selector.auraTick(dataProcessor.getAuraWithId(2))
def test_PausesUntilFirstMessage(self): """main - Before we recieve any messages telling us what to watch for, the system should pause and yield""" S = Selector() S.activate() V = S.next() self.assert_(S._isRunnable() is not True)
def selector(**kwds): from Selector import Selector return Selector(**kwds)
def test_RemoveExceptional_ResultsInExceptionalNoLongerBeingSelectedOrWiredIn(self): "main - Sending a remove exceptional message unwires/links a component, and also removes it's selectable from the exceptionals list" MOCKSELECTORMODULE = MockSelect(results=[ ([], [], [] )]) SELECTORMODULE.select = MOCKSELECTORMODULE S = Selector() S.activate() for i in xrange(100): S.next() D = Axon.Component.component() dummyservice = (D, "inbox") S._deliver(newExceptional(S,( dummyservice, "LOOKINGFORTHIS") ),"notify") S._deliver(removeExceptional(S,"LOOKINGFORTHIS"),"notify") for i in xrange(100): S.next(); try: S.postoffice.next() except: pass self.assert_( D.inboxes["inbox"] == [] )