def __init__(self, filename, string): self.filename = filename self.string = string msg = "Syntax error at: {filename}\n{string}".format(filename=filename, string=string) super().__init__(msg)
def __init__(self, *args, **kwargs): if 'bulk_form_attrs' in kwargs: bulk_form_attrs = kwargs['bulk_form_attrs'] del kwargs['bulk_form_attrs'] else: bulk_form_attrs = None super(BulkParticipantDeleteForm, self).__init__(*args, **kwargs) if bulk_form_attrs is not None: # setup first_uid widget constraints self.fields["first_uid"].widget.attrs.update( dict(min=bulk_form_attrs["update_delete_first_uid_min_value"], max=bulk_form_attrs["update_delete_first_uid_max_value"], required=True)) # setup first_uid fld validation self.fields["first_uid"].min_value = \ bulk_form_attrs["update_delete_first_uid_min_value"] self.fields["first_uid"].max_value = \ bulk_form_attrs["update_delete_first_uid_max_value"] # setup last_uid widget constraints self.fields["last_uid"].widget.attrs.update( dict(min=bulk_form_attrs["update_delete_last_uid_min_value"], max=bulk_form_attrs["update_delete_last_uid_max_value"], required=True)) # setup last_uid fld validation self.fields["last_uid"].min_value = \ bulk_form_attrs["update_delete_last_uid_min_value"] self.fields["last_uid"].max_value = \ bulk_form_attrs["update_delete_last_uid_max_value"]
def writeRoutineEndCode(self, buff): # some shortcuts name = self.params['name'] if len(self.exp.flow._loopList): currLoop = self.exp.flow._loopList[-1] # last (outer-most) loop else: currLoop = self.exp._expHandler # write the actual code buff.writeIndented("# %(name)s stop & responses\n" % self.params) buff.writeIndented("%s.stop() # sometimes helpful\n" % self.params['name']) buff.writeIndented("if not %(name)s.savedFile:\n" % self.params) buff.writeIndented(" %(name)s.savedFile = None\n" % self.params) buff.writeIndented("# store data for %s (%s)\n" % (currLoop.params['name'], currLoop.type)) # always add saved file name buff.writeIndented("%s.addData('%s.filename', %s.savedFile)\n" % (currLoop.params['name'], name, name)) # get parent to write code too (e.g. store onset/offset times) super().writeRoutineEndCode(buff) if currLoop.params['name'].val == self.exp._expHandler.name: buff.writeIndented("%s.nextEntry()\n" % self.exp._expHandler.name)
def __init__(self, op, scalar, tmp=None): """Initialize a new `OperatorLeftScalarMult` instance. Parameters ---------- op : `Operator` The domain of ``op`` must be a `LinearSpace` or `Field`. scalar : ``op.range.field`` element A real or complex number, depending on the field of the operator domain. tmp : domain element, optional Used to avoid the creation of a temporary when applying the operator. """ if not isinstance(op.domain, (LinearSpace, Field)): raise TypeError('domain {!r} not a `LinearSpace` or `Field` ' 'instance.'.format(op.domain)) if scalar not in op.domain.field: raise TypeError('scalar {!r} not in the field {!r} of the ' 'operator domain {!r}.' ''.format(scalar, op.domain.field, op.domain)) if tmp is not None and tmp not in op.domain: raise TypeError('temporary {!r} not an element of the ' 'operator domain {!r}.'.format(tmp, op.domain)) super().__init__(op.domain, op.range, op.is_linear) self._op = op self._scalar = scalar self._tmp = tmp
def learn(self, s, p_actions, a, r, ns, np_actions, na, terminal): """Iterative learning method for the agent. Args: s (ndarray): The current state features p_actions (ndarray): The actions available in state s a (int): The action taken by the agent in state s r (float): The reward received by the agent for taking action a in state s ns (ndarray): The next state features np_actions (ndarray): The actions available in state ns na (int): The action taken by the agent in state ns terminal (bool): Whether or not ns is a terminal state """ self.LSPI.process(s, a, r, ns, na, terminal) if self.LSPI.samples_count + 1 % self.LSPI.steps_between_LSPI == 0: self.LSPI.representationExpansionLSPI() if terminal: self.episodeTerminated() else: super( LSPI_SARSA, self).learn(s, p_actions, a, r, ns, np_actions, na, terminal)
def __init__(self, part, axes): """Initialize a new instance. Parameters ---------- part : 1-dim. `RectPartition` Partition of the parameter interval, corresponding to the pixels axes : 2-tuple of `array-like` (shape ``(3,)``) Principal axes of the detector, e.g. ``[(0, 1, 0), (0, 0, 1)]`` """ super().__init__(part) if self.ndim != 2: raise ValueError('expected partition to have 2 dimensions, ' 'got {}.'.format(self.ndim)) for i, a in enumerate(axes): if np.linalg.norm(a) <= 1e-10: raise ValueError('axis vector {} {} too close to zero.' ''.format(i, axes[i])) if np.shape(a) != (3,): raise ValueError('axis vector {} has shape {}. expected (3,).' ''.format(i, np.shape(a))) self._axes = tuple(np.asarray(a) / np.linalg.norm(a) for a in axes) self._normal = np.cross(self.axes[0], self.axes[1]) if np.linalg.norm(self.normal) <= 1e-4: raise ValueError('axes are almost parallel (norm of normal = ' '{})'.format(np.linalg.norm(self.normal)))
def __init__(self, exp, parentName, name='mic_1', startType='time (s)', startVal=0.0, stopType='duration (s)', stopVal=2.0, startEstim='', durationEstim='', stereo=False, channel=0): super(MicrophoneComponent, self).__init__( exp, parentName, name=name, startType=startType, startVal=startVal, stopType=stopType, stopVal=stopVal, startEstim=startEstim, durationEstim=durationEstim) self.type = 'Microphone' self.url = "http://www.psychopy.org/builder/components/microphone.html" self.exp.requirePsychopyLibs(['microphone']) # params msg = _translate( "Record two channels (stereo) or one (mono, smaller file)") self.params['stereo'] = Param( stereo, valType='bool', hint=msg, label=_localized['stereo']) self.params['stopType'].allowedVals = ['duration (s)'] msg = _translate( 'The duration of the recording in seconds; blank = 0 sec') self.params['stopType'].hint = msg msg = _translate("Enter a channel number. Default value is 0. If unsure, run 'sound.backend.get_input_devices()' to locate the system's selected device/channel.") self.params['channel'] = Param(channel, valType='int', hint=msg, label=_localized['channel'])
def setUp(self): super().setUp() input_dir = os.path.join(util.file.get_test_input_path(), 'TestMetagenomicsViralMix') self.kraken_db_viral_mix = tempfile.mkdtemp('-kraken_db_viral_mix') cmd = ['tar', '-C', self.kraken_db_viral_mix, '-xzf', os.path.join(input_dir, 'kraken_db.tar.gz')] subprocess.check_call(cmd) self.kraken = tools.kraken.Kraken()
def __init__(self, space, energies, spectrum): self.energies = np.array(energies) self.spectrum = np.array(spectrum) self.spectrum = self.spectrum / self.spectrum.sum() super().__init__(odl.ProductSpace(space, 2), space, False)
def __init__(self, file, header_fields=None): """Initialize a new instance. Parameters ---------- file : file-like or str Stream or filename from which to read the data. The stream is allowed to be already opened in ``'rb'`` mode. header_fields : sequence of dicts, optional Definition of the fields in the header (per row), each containing key-value pairs for the following keys: - ``'name'`` : Label for the field. - ``'offset'`` : Start of the field in bytes. - ``'size'`` : Size of the field in bytes. - ``'dtype'`` : Data type in Numpy- or Numpy-readable format. - ``'dshape'`` (optional) : The array of values is reshaped to this shape. - ``'description'`` (optional) : A human-readable description of the field. For the default ``None``, the MRC2014 format is used, see `print_mrc2014_spec`. """ if header_fields is None: header_fields = header_fields_from_table( spec_table=MRC_2014_SPEC_TABLE, keys=MRC_SPEC_KEYS, dtype_map=MRC_DTYPE_TO_NPY_DTYPE) super().__init__(file, header_fields)
def __init__(self, kernel, adjkernel=None): self.kernel = kernel self.adjkernel = (adjkernel if adjkernel is not None else kernel.space.element(kernel[::-1].copy())) self.space = kernel.space self.norm = float(np.sum(np.abs(self.kernel.ntuple))) super().__init__(self.space, self.space, linear=True)
def setup_display(self, time_axis, attributes): """Create a report for this dispatch, usually done at init Arguments --------- time_axis : string Name of attribute representing time eg. iterations, epoch, etc attributes : list List of strings representing attributes to plot eg. loss, accuracy, learning rate, etc. If time_axis attribute is present it will be ignored. Returns ------- result : requests.Response Result of the report creation request """ super().setup_display(time_axis, attributes) report_json = self._new_report() if 'id' in report_json: self.report_id = report_json['id'] elif 'data' in report_json: # This is for unit testing self.report_id = '' return self._format_report()
def __init__(this, mbus, base_addr, writeback=False, \ log_level = logging.WARN): ''' note: base_addr will need to be updated every time ''' super( RegFile, this).__init__(mbus) this.base_addr = base_addr this.log = m3_logging.getLogger( type(this).__name__) this.log.setLevel(log_level) # specific ordering matching on-board gdb code this.names = [ 'isr_lr', 'sp', 'r8', 'r9', 'r10', 'r11', 'r4', 'r5', 'r6', 'r7', 'r0', 'r1', 'r2', 'r3', 'r12', 'lr', 'pc', 'xpsr', ] this.trans_names = { 'r13': 'sp', 'r14':'lr', 'r15':'pc'} # The M0 does not include floating-point registers this.warn_names = [ 'f0', 'f1', 'f2', 'f3', 'f4', 'f5', 'f6', 'f7', 'fps', ] this.warn_trans_names = { 'cpsr':'xpsr' } this.offsets = dict( zip(this.names, range(0, 4* len(this.names), 4)) ) this.writeback = writeback this.local = {}
def __init__(self, inner, dist_using_inner=True): """Initialize a new instance. Parameters ---------- inner : `callable` The inner product implementation. It must accept two `FnVector` arguments, return an element from their space's field (real or complex number) and satisfy the following conditions for all vectors ``x, y, z`` and scalars ``s``: - ``<x, y> = conj(<y, x>)`` - ``<s*x + y, z> = s * <x, z> + <y, z>`` - ``<x, x> = 0`` if and only if ``x = 0`` dist_using_inner : `bool`, optional Calculate ``dist`` using the following formula:: ||x - y||^2 = ||x||^2 + ||y||^2 - 2 * Re <x, y> This avoids the creation of new arrays and is thus faster for large arrays. On the downside, it will not evaluate to exactly zero for equal (but not identical) ``x`` and ``y``. """ super().__init__(inner, impl='cuda', dist_using_inner=dist_using_inner)
def __init__(self, controls): # Call the component super class, loading the player's sprite and the on-screen dimensions of the player super().__init__("player.png", component_texture_colourkey = WHITE, component_texture_rect = (0, 0, 24, 40), component_bounding_rect_dimensions = (24, 14), component_bounding_rect_position = (0, 26)) # Player variables # Name must be set self.name = "" # Player starts off not running self.running = False # The player's speed self.speed = 2 # The amount of time the player has left to run through a room self.time = 11 # The number of rooms the player has run through self.rooms_run = 0 # The level the player is currently in self.current_level = 1 # The player's light and dark scores self.light_count = 0 self.dark_count = 0 # The set of controls used to move the player self.controls = controls # Load a new room by initialising a new, random, room object self.current_room = Room(random.randint(6, 13), random.randint(4, 7), self.current_level) # Set the postion of the player in the initial room self.sprite_data.set_position(((BOARD_WIDTH - self.sprite_data.bounding_rect.width) / 2, (BOARD_HEIGHT - self.sprite_data.bounding_rect.height) / 2))
def __init__(self, space, axis=0, dx=1.0, edge_order=2, zero_padding=False): """Initialize an operator instance. Parameters ---------- space : `DiscreteLp` The space of elements which the operator is acting on axis : `int`, optional The axis along which the partial derivative is evaluated. Default: 0 dx : `float`, optional Scalars specifying the sampling distances in dimension ``axis``. Default distance: 1.0 edge_order : {1, 2}, optional First-order accurate differences can be used at the boundaries if no zero padding is used. Default edge order: 2 zero_padding : `bool`, optional Implicit zero padding. Assumes values outside the domain of ``f`` to be zero. Default: `False` """ if not isinstance(space, DiscreteLp): raise TypeError('space {!r} is not a `DiscreteLp` ' 'instance.'.format(space)) super().__init__(domain=space, range=space, linear=True) self.axis = axis self.dx = dx self.edge_order = edge_order self.zero_padding = zero_padding
def __init__(self, apart, dpart, src_radius, det_radius, axis=[0, 0, 1], **kwargs): """Initialize a new instance. Parameters ---------- apart : 1-dim. `RectPartition` Partition of the angle interval dpart : 2-dim. `RectPartition` Partition of the detector parameter rectangle src_radius : nonnegative float Radius of the source circle det_radius : nonnegative float Radius of the detector circle axis : array-like, shape ``(3,)``, optional Fixed rotation axis, the symmetry axis of the helix src_to_det_init : array-like, shape ``(2,)``, optional Initial state of the vector pointing from source to detector reference point. The zero vector is not allowed. By default, a `perpendicular_vector` to ``axis`` is used. det_init_axes : 2-tuple of `array-like`'s (shape ``(2,)``), optional Initial axes defining the detector orientation. By default, the normalized cross product of ``axis`` and ``src_to_det_init`` is used as first axis and ``axis`` as second. """ kwargs.pop('pitch_offset', None) super().__init__(apart, dpart, src_radius, det_radius, pitch=0, axis=axis, **kwargs)
def __init__(self, history, *args, **kwargs): """Initialize the sequence with our day-to-day history. :param dict history: Dictionary (indexed by day-1) of daily data """ super().__init__(*args, **kwargs) self._history = history
def __init__(self, task_params, img_folder): super().__init__() # Data will be a dictionary of lists self._data = {} self.task_params = task_params self._img_folder = img_folder self._legend_keys = []
def __init__(self, projection, geometry): proj_map = partial(projection, geometry) super().__init__(proj_map) self._projection = projection self._geometry = geometry
def __init__(self, backprojection, geometry): backproj_map = partial(backprojection, geometry) super().__init__(backproj_map) self._backprojection = backprojection self._geometry = geometry
def __init__(self, f_df, theta_init, learning_rate=1e-2, damping=0.1, decay=0.9): """ RMSProp Parameters ---------- df : function x0 : array_like lr : float, optional Learning rate (Default: 1e-2) momentum : float, optional Momentum (Default: 0) decay : float, optional Decay of the learning rate (Default: 0) """ self.lr = learning_rate self.damping = damping self.decay = decay # initializes objective and gradient self.obj, self.gradient = wrap(f_df, theta_init) super().__init__(theta_init)
def __init__(self, op, vector): """ Initialize an instance. Parameters ---------- vector : `LinearSpaceVector` The vector constant to be returned dom : `LinearSpace`, default : vector.space The domain of the operator. """ if not isinstance(op, Operator): raise TypeError('op {!r} not a Operator instance.' ''.format(op)) if not isinstance(vector, LinearSpaceVector): raise TypeError('space {!r} not a LinearSpaceVector instance.' ''.format(vector)) if vector not in op.range: raise TypeError('space {!r} not in op.range {!r}.' ''.format(vector, op.range)) self.op = op self.vector = vector super().__init__(op.domain, vector.space)
def __init__( self, policy, representation, discount_factor, max_window, steps_between_LSPI, lspi_iterations=5, tol_epsilon=1e-3, re_iterations=100, use_sparse=False): self.steps_between_LSPI = steps_between_LSPI self.tol_epsilon = tol_epsilon self.lspi_iterations = lspi_iterations self.re_iterations = re_iterations self.use_sparse = use_sparse # Make A and r incrementally if the representation can not expand self.fixedRep = not representation.isDynamic if self.fixedRep: f_size = representation.features_num * representation.actions_num self.b = np.zeros((f_size, 1)) self.A = np.zeros((f_size, f_size)) # Cache calculated phi vectors if self.use_sparse: self.all_phi_s = sp.lil_matrix( (max_window, representation.features_num)) self.all_phi_ns = sp.lil_matrix( (max_window, representation.features_num)) self.all_phi_s_a = sp.lil_matrix((max_window, f_size)) self.all_phi_ns_na = sp.lil_matrix((max_window, f_size)) else: self.all_phi_s = np.zeros( (max_window, representation.features_num)) self.all_phi_ns = np.zeros( (max_window, representation.features_num)) self.all_phi_s_a = np.zeros((max_window, f_size)) self.all_phi_ns_na = np.zeros((max_window, f_size)) super(LSPI, self).__init__(policy, representation, discount_factor, max_window)
def show(self): """Display the dialog. """ super().show() if self.OK: for n, thisKey in enumerate(self._keys): self.dictionary[thisKey] = self.data[n]
def __init__(self, op1, op2): """Initialize a new instance. Parameters ---------- op1 : `Operator` The first factor op2 : `Operator` The second factor. Must have the same domain and range as ``op1``. """ if op1.range != op2.range: raise TypeError('operator ranges {!r} and {!r} do not match.' ''.format(op1.range, op2.range)) if not isinstance(op1.range, (LinearSpace, Field)): raise TypeError('range {!r} not a `LinearSpace` or `Field` ' 'instance.'.format(op1.range)) if op1.domain != op2.domain: raise TypeError('operator domains {!r} and {!r} do not match.' ''.format(op1.domain, op2.domain)) super().__init__(op1.domain, op1.range, linear=False) self._op1 = op1 self._op2 = op2
def __init__(self, indexer): super(NzbIndex, self).__init__(indexer) self.module = "NZBIndex" self.supports_queries = True # We can only search using queries self.needs_queries = True self.category_search = False
def __init__(self, f_df, theta_init, learning_rate=1e-3, beta=(0.9, 0.999), epsilon=1e-8): """ ADAM See: http://arxiv.org/abs/1412.6980 Parameters ---------- df : function x0 : array_like maxiter : int lr : float, optional Learning rate (Default: 1e-2) beta : (b1, b2), optional Exponential decay rates for the moment estimates epsilon : float, optional Damping factor """ self.lr = learning_rate self.beta = beta self.epsilon = epsilon # initializes objective and gradient self.obj, self.gradient = wrap(f_df, theta_init) super().__init__(theta_init)
def __init__(self, left, right, tmp=None): """Initialize a new `OperatorComp` instance. Parameters ---------- left : `Operator` The left ("outer") operator right : `Operator` The right ("inner") operator. Its range must coincide with the domain of ``left``. tmp : element of the range of ``right``, optional Used to avoid the creation of a temporary when applying the operator. """ if right.range != left.domain: raise TypeError('range {!r} of the right operator {!r} not equal ' 'to the domain {!r} of the left operator {!r}.' ''.format(right.range, right, left.domain, left)) if tmp is not None and tmp not in left.domain: raise TypeError('temporary {!r} not an element of the left ' 'operator domain {!r}.'.format(tmp, left.domain)) super().__init__(right.domain, left.range, linear=left.is_linear and right.is_linear) self._left = left self._right = right self._tmp = tmp
def __init__(self, vol_gfun, proj_grid, dist, wavenum, rotation=None, **kwargs): # The grid warp is a rotation warp = lambda vec_arr, rot: vec_arr * rot rotate = partial(warp, rot=rotation) if rotation is not None else None # Feed the reciprocal projection grid into the frequency geometry proj_gr_recip = proj_grid.reciprocal() freq_geom = FreqGeomGraphWarp(proj_gr_recip.coord, halfsph_k, rotate) # post-processing is a multiplication by a (phase) factor def diffr_factor(x, y, k, d): sq = np.sqrt(k**2 - x**2 - y**2) # TODO: check factors and sign return -1j * np.sqrt(np.pi / 2) * np.exp(1j * d * sq) / sq diffr_factor_k_d = partial(diffr_factor, k=wavenum, d=dist) super().__init__(freq_geom, preproc=None) self.vol_gfun = vol_gfun self.proj_grid = proj_grid self.postproc = lambda x, y, f: f * diffr_factor_k_d(x, y)
def __init__(self, callback, reinject=-1, slat_id=0, data=None): super().__init__(callback, slat_id, data) self._reinject = reinject
def __init__(self, exp, parentName, name='bbox', active="(0,1,2,3,4,5,6,7)", store='first button', forceEndRoutine=True, storeCorrect=False, correctAns="0", discardPrev=True, lights=True, lightsOff=False, startType='time (s)', startVal=0.0, stopType='duration (s)', stopVal=1.0, startEstim='', durationEstim=''): super(ioLabsButtonBoxComponent, self).__init__(exp, parentName, name=name, store=store, discardPrev=discardPrev, correctAns=correctAns, forceEndRoutine=forceEndRoutine, storeCorrect=storeCorrect, startType=startType, startVal=startVal, stopType=stopType, stopVal=stopVal, startEstim=startEstim, durationEstim=durationEstim) self.type = 'ioLabsButtonBox' self.url = "http://www.psychopy.org/builder/components/ioLabs.html" self.exp.requirePsychopyLibs(['hardware']) del self.params['allowedKeys'] # NB name and timing params always come 1st self.order = [ 'forceEndRoutine', 'active', 'lights', 'store', 'storeCorrect', 'correctAns' ] msg = _translate( "What is the 'correct' response? NB, buttons are labelled 0 to " "7 on a 8-button box. Enter 'None' (no quotes) if withholding " "a response is correct. Might be helpful to add a correctAns " "column and use $correctAns to compare to the key press.") self.params['correctAns'].hint = msg self.params['store'].allowedVals = [ 'last button', 'first button', 'all buttons', 'nothing' ] msg = _translate( 'Choose which (if any) responses to store at end of a trial') self.params['store'].hint = msg msg = _translate("Active buttons, such as '1,6', '(1,2,5,6)' or '0' " "(without quotes)") self.params['active'] = Param( active, valType='code', allowedTypes=[], updates='constant', allowedUpdates=['constant', 'set every repeat'], hint=msg, label=_localized['active']) self.params['lights'] = Param( lights, valType='bool', allowedTypes=[], updates='constant', allowedUpdates=[], hint=_translate("Turn ON the lights for the active buttons?"), label=_localized['lights']) self.params['lights off'] = Param( lightsOff, valType='bool', allowedTypes=[], updates='constant', allowedUpdates=[], hint=_translate("Turn OFF all lights at the end of each routine?"), label=_localized['lights off'])
def tearDownClass(cls): super().tearDownClass() cls.after_feature(cls.feature)
def setUpClass(cls): super().setUpClass() cls.feature.testclass = cls cls.before_feature(cls.feature)
def __init__(self, *args, **kwargs): """Initialize the step status.""" self.failed = None self.passed = None super().__init__(*args, **kwargs)
def __init__(self, exp, parentName, name='p_port', startType='time (s)', startVal=0.0, stopType='duration (s)', stopVal=1.0, startEstim='', durationEstim='', address=None, startData="1", stopData="0", syncScreen=True): super(ParallelOutComponent, self).__init__(exp, parentName, name, startType=startType, startVal=startVal, stopType=stopType, stopVal=stopVal, startEstim=startEstim, durationEstim=durationEstim) self.type = 'ParallelOut' self.url = "http://www.psychopy.org/builder/components/parallelout.html" self.categories = ['I/O'] self.exp.requirePsychopyLibs(['parallel']) # params self.order = ['address', 'startData', 'stopData'] # main parameters addressOptions = prefs.hardware['parallelPorts'] + [u'LabJack U3' ] + [u'USB2TTL8'] if not address: address = addressOptions[0] msg = _translate("Parallel port to be used (you can change these " "options in preferences>general)") self.params['address'] = Param(address, valType='str', inputType="choice", allowedVals=addressOptions, categ='Hardware', hint=msg, label=_localized['address']) self.params['startData'] = Param( startData, valType='code', inputType="single", allowedTypes=[], categ='Data', hint=_translate("Data to be sent at 'start'"), label=_localized['startData']) self.params['stopData'] = Param( stopData, valType='code', inputType="single", allowedTypes=[], categ='Data', hint=_translate("Data to be sent at 'end'"), label=_localized['stopData']) msg = _translate("If the parallel port data relates to visual " "stimuli then sync its pulse to the screen refresh") self.params['syncScreen'] = Param(syncScreen, valType='bool', inputType="bool", categ='Data', allowedVals=[True, False], updates='constant', allowedUpdates=[], hint=msg, label=_localized['syncScreen'])
def to_cffi(self): super().to_cffi() self._cffi_event.debug_event.reinject = self._reinject return self._cffi_event
def to_cffi(self): super().to_cffi() self._cffi_event.interrupt_event.intr = self.intr.value self._cffi_event.interrupt_event.reinject = self._reinject return self._cffi_event
def to_cffi(self): super().to_cffi() self._cffi_event.ss_event.vcpus = self.vcpus self._cffi_event.ss_event.enable = int(self.enable) return self._cffi_event
def to_dict(self): d = super().to_dict() d['intr'] = self.intr.name d['reinject'] = self._reinject return d
def __init__(self, adjoint, vfspace, vecfield, weighting=None): """Initialize a new instance. All parameters are given according to the specifics of the "usual" operator. The ``adjoint`` parameter is used to control conversions for the inverse transform. Parameters ---------- adjoint : bool ``True`` if the operator should be the adjoint, ``False`` otherwise. vfspace : `ProductSpace` Space of vector fields on which the operator acts. It has to be a product space of identical spaces, i.e. a power space. vecfield : ``vfspace`` `element-like` Vector field with which to calculate the point-wise inner product of an input vector field weighting : `array-like` or float, optional Weighting array or constant for the norm. If an array is given, its length must be equal to ``domain.size``. By default, the weights are is taken from ``domain.weighting``. Note that this excludes unusual weightings with custom inner product, norm or dist. """ if not isinstance(vfspace, ProductSpace): raise TypeError('`vfsoace` {!r} is not a ProductSpace ' 'instance'.format(vfspace)) if adjoint: super().__init__(domain=vfspace[0], range=vfspace, base_space=vfspace[0], linear=True) else: super().__init__(domain=vfspace, range=vfspace[0], base_space=vfspace[0], linear=True) # Bail out if the space is complex but we cannot take the complex # conjugate. if (vfspace.field == ComplexNumbers() and not hasattr(self.base_space.element_type, 'conj')): raise NotImplementedError( 'base space element type {!r} does not implement conj() ' 'method required for complex inner products' ''.format(self.base_space.element_type)) self._vecfield = vfspace.element(vecfield) # Handle weighting, including sanity checks if weighting is None: if hasattr(vfspace.weighting, 'array'): self.__weights = vfspace.weighting.array elif hasattr(vfspace.weighting, 'const'): self.__weights = (vfspace.weighting.const * np.ones(len(vfspace))) else: raise ValueError('weighting scheme {!r} of the domain does ' 'not define a weighting array or constant' ''.format(vfspace.weighting)) elif np.isscalar(weighting): self.__weights = float(weighting) * np.ones(vfspace.size) else: self.__weights = np.asarray(weighting, dtype='float64') self.__is_weighted = not np.array_equiv(self.weights, 1.0)
def to_cffi(self): super().to_cffi() self._cffi_event.reg_event.reg = self.register.value self._cffi_event.reg_event.in_access = self.in_access.value self._cffi_event.reg_event.equal = self.equal return self._cffi_event
def __init__(self, input): super().__init__() self.input = input self.context = Context.instance()
def __init__(self, matrix, domain=None, range=None): """Initialize a new instance. Parameters ---------- matrix : `array-like` or `scipy.sparse.base.spmatrix` 2-dimensional array representing the linear operator. domain : `FnBase`, optional Space of elements on which the operator can act. Its ``dtype`` must be castable to ``range.dtype``. For the default ``None``, a `NumpyFn` space with size ``matrix.shape[1]`` is used, together with the matrix' data type. range : `FnBase`, optional Space of elements on to which the operator maps. Its ``shape`` and ``dtype`` attributes must match the ones of the result of the multiplication. For the default ``None``, the range is inferred from ``matrix`` and ``domain``. Examples -------- By default, ``domain`` and ``range`` are `NumpyFn` type spaces: >>> matrix = np.ones((3, 4)) >>> op = MatrixOperator(matrix) >>> op MatrixOperator( [[ 1., 1., 1., 1.], [ 1., 1., 1., 1.], [ 1., 1., 1., 1.]] ) >>> op.domain rn(4) >>> op.range rn(3) >>> op([1, 2, 3, 4]) rn(3).element([10.0, 10.0, 10.0]) They can also be provided explicitly, for example with `uniform_discr` spaces: >>> dom = odl.uniform_discr(0, 1, 4) >>> ran = odl.uniform_discr(0, 1, 3) >>> op = MatrixOperator(matrix, domain=dom, range=ran) >>> op(dom.one()) uniform_discr(0.0, 1.0, 3).element([4.0, 4.0, 4.0]) For storage efficiency, SciPy sparse matrices can be used: >>> import scipy >>> row_idcs = np.array([0, 3, 1, 0]) >>> col_idcs = np.array([0, 3, 1, 2]) >>> values = np.array([4.0, 5.0, 7.0, 9.0]) >>> matrix = scipy.sparse.coo_matrix((values, (row_idcs, col_idcs)), ... shape=(4, 4)) >>> matrix.toarray() array([[ 4., 0., 9., 0.], [ 0., 7., 0., 0.], [ 0., 0., 0., 0.], [ 0., 0., 0., 5.]]) >>> op = MatrixOperator(matrix) >>> op(op.domain.one()) rn(4).element([13.0, 7.0, 0.0, 5.0]) """ # TODO: fix dead link `scipy.sparse.spmatrix` if scipy.sparse.isspmatrix(matrix): self.__matrix = matrix else: self.__matrix = np.asarray(matrix) if self.matrix.ndim != 2: raise ValueError('matrix {} has {} axes instead of 2' ''.format(matrix, self.matrix.ndim)) # Infer domain and range from matrix if necessary if domain is None: domain = fn(self.matrix.shape[1], dtype=self.matrix.dtype) elif not isinstance(domain, FnBase): raise TypeError('`domain` {!r} is not an `FnBase` instance' ''.format(domain)) if range is None: range = fn(self.matrix.shape[0], dtype=self.matrix.dtype) elif not isinstance(range, FnBase): raise TypeError('`range` {!r} is not an `FnBase` instance' ''.format(range)) # Check compatibility of matrix with domain and range if self.matrix.shape != (range.size, domain.size): raise ValueError('matrix shape {} does not match the required ' 'shape {} of a matrix {} --> {}' ''.format(self.matrix.shape, (range.size, domain.size), domain, range)) if not np.can_cast(domain.dtype, range.dtype): raise TypeError('domain data type {!r} cannot be safely cast to ' 'range data type {!r}' ''.format(domain.dtype, range.dtype)) if not np.can_cast(self.matrix.dtype, range.dtype): raise TypeError('matrix data type {!r} cannot be safely cast to ' 'range data type {!r}.' ''.format(matrix.dtype, range.dtype)) super().__init__(domain, range, linear=True)
def __init__(self, *a, **kw): super(TimeZone, self).__init__(*a, **kw)
def __init__(self, vfspace, exponent=None, weighting=None): """Initialize a new instance. Parameters ---------- vfspace : `ProductSpace` Space of vector fields on which the operator acts. It has to be a product space of identical spaces, i.e. a power space. exponent : non-zero float, optional Exponent of the norm in each point. Values between 0 and 1 are currently not supported due to numerical instability. Default: ``vfspace.exponent`` weighting : `array-like` or positive float, optional Weighting array or constant for the norm. If an array is given, its length must be equal to ``domain.size``, and all entries must be positive. By default, the weights are is taken from ``domain.weighting``. Note that this excludes unusual weightings with custom inner product, norm or dist. Examples -------- We make a tiny vector field space in 2D and create the standard point-wise norm operator on that space. The operator maps a vector field to a scalar function: >>> spc = odl.uniform_discr([-1, -1], [1, 1], (1, 2)) >>> vfspace = odl.ProductSpace(spc, 2) >>> pw_norm = PointwiseNorm(vfspace) >>> pw_norm.range == spc True Now we can calculate the 2-norm in each point: >>> x = vfspace.element([[[1, -4]], ... [[0, 3]]]) >>> print(pw_norm(x)) [[1.0, 5.0]] We can change the exponent either in the vector field space or in the operator directly: >>> vfspace = odl.ProductSpace(spc, 2, exponent=1) >>> pw_norm = PointwiseNorm(vfspace) >>> print(pw_norm(x)) [[1.0, 7.0]] >>> vfspace = odl.ProductSpace(spc, 2) >>> pw_norm = PointwiseNorm(vfspace, exponent=1) >>> print(pw_norm(x)) [[1.0, 7.0]] """ if not isinstance(vfspace, ProductSpace): raise TypeError('`vfspace` {!r} is not a ProductSpace ' 'instance'.format(vfspace)) super().__init__(domain=vfspace, range=vfspace[0], base_space=vfspace[0], linear=False) # Need to check for product space shape once higher order tensors # are implemented if exponent is None: if self.domain.exponent is None: raise ValueError('cannot determine `exponent` from {}' ''.format(self.domain)) self._exponent = self.domain.exponent elif exponent < 1: raise ValueError('`exponent` smaller than 1 not allowed') else: self._exponent = float(exponent) # Handle weighting, including sanity checks if weighting is None: # TODO: find a more robust way of getting the weights as an array if hasattr(self.domain.weighting, 'array'): self.__weights = self.domain.weighting.array elif hasattr(self.domain.weighting, 'const'): self.__weights = (self.domain.weighting.const * np.ones(len(self.domain))) else: raise ValueError('weighting scheme {!r} of the domain does ' 'not define a weighting array or constant' ''.format(self.domain.weighting)) elif np.isscalar(weighting): if weighting <= 0: raise ValueError('weighting constant must be positive, got ' '{}'.format(weighting)) self.__weights = float(weighting) * np.ones(self.domain.size) else: self.__weights = np.asarray(weighting, dtype='float64') if (not np.all(self.weights > 0) or not np.all(np.isfinite(self.weights))): raise ValueError('weighting array {} contains invalid ' 'entries'.format(weighting)) self.__is_weighted = not np.array_equiv(self.weights, 1.0)
def __init__(self, exc, *args, **kwargs): self.__exc = exc super().__init__(*args, **kwargs)
def __init__(self, *a, **kw): super(GlobalPosition, self).__init__(*a, **kw)
def set_cell(self, cell, scale_atoms=False): self._reset_structure() super().set_cell(cell, scale_atoms)
def save(self, *args, **kwargs): if self.type in [ Question.RADIO, Question.SELECT, Question.SELECT_MULTIPLE ]: validate_choices(self.choices) super(Question, self).save(*args, **kwargs)
def set_scaled_positions(self, scaled): self._reset_structure() super().set_scaled_positions(scaled)
def __setattr__(self, key, value): if key in ('_queries', '_parameters', '_data'): return object.__setattr__(self, key, value) return super().__setattr__(key, value)
def tearDown(self): self.stop_request.set() super().tearDown() self.context.destroy(0)
def set_pbc(self, pbc): self._reset_structure() super().set_pbc(pbc)
def __init__( self, _client=None, account_id=None, completed_at=None, created_at=None, errors_count=None, errors_report_file=None, full_report_file=None, id=None, processed_count=None, status=None, total_count=None, ): """Creates a local `DeviceEnrollmentBulkDelete` instance Parameters can be supplied on creation of the instance or given by setting the properties on the instance after creation. Parameters marked as `required` must be set for one or more operations on the entity. For details on when they are required please see the documentation for the setter method. :param account_id: ID :type account_id: str :param completed_at: The time the bulk creation task was completed. Null when creating bulk upload or delete. :type completed_at: datetime :param created_at: The time of receiving the bulk creation task. :type created_at: datetime :param errors_count: The number of enrollment identities with failed processing. :type errors_count: int :param errors_report_file: Link to error report file. Null when creating bulk upload or delete. :type errors_report_file: str :param full_report_file: Link to full report file. Null when creating bulk upload or delete. :type full_report_file: str :param id: (Required) Bulk ID :type id: str :param processed_count: The number of enrollment identities processed until now. :type processed_count: int :param status: The state of the process is 'new' at the time of creation. If creation is still in progress, the state shows as 'processing'. When the request is fully processed, the state changes to 'completed'. :type status: str :param total_count: Total number of enrollment identities found in the input CSV. :type total_count: int """ super().__init__(_client=_client) # inline imports for avoiding circular references and bulk imports # fields self._account_id = fields.StringField(value=account_id) self._completed_at = fields.DateTimeField(value=completed_at) self._created_at = fields.DateTimeField(value=created_at) self._errors_count = fields.IntegerField(value=errors_count) self._errors_report_file = fields.StringField(value=errors_report_file) self._full_report_file = fields.StringField(value=full_report_file) self._id = fields.StringField(value=id) self._processed_count = fields.IntegerField(value=processed_count) self._status = fields.StringField(value=status, enum=enums.DeviceEnrollmentBulkDeleteStatusEnum) self._total_count = fields.IntegerField(value=total_count)
def set_positions(self, newpositions, apply_constraint=True): self._reset_structure() super().set_positions(newpositions, apply_constraint)
def __init__(self, pi_point): super().__init__() self.pi_point = pi_point self.tag = pi_point.Name self.__attributes_loaded = False self.__raw_attributes = {}
def __init__(self, parent): super(self.__class__, self).__init__(parent) self.initUi() self.initConnection()
def __repr__(self): return "{}: {}".format(self.__class__.__name__, super().__repr__())
def __init__(self, requests_session, url_base): super().__init__(requests_session, url_base)