= 0\n config_spec = vim.vm.ConfigSpec()\n shares_alloc = vim.ResourceAllocationInfo()\n shares_alloc.shares = vim.SharesInfo(level=\"custom\", shares=shares)\n config_spec.memoryAllocation = shares_alloc\n return self.vm_obj.ReconfigVM_Task(config_spec)","def __init__(self):\n self.mem = [0] * 256\n self.pc = 0\n self.running = False","def _create_impl(self):","def make(self):\n pass","def set_shared_bitshares_instance(bitshares_instance):\n clear_cache()\n SharedInstance.instance = bitshares_instance","def __init__(self):\n self.write_queue = Manager().Queue()\n\n BaseManager.register('Arduino',Arduino)\n BaseManager.register('Algorithm',Algorithm)\n BaseManager.register('Android',Android)\n BaseManager.register('ImageCV', ImageCV)\n manager = BaseManager()\n manager.start()\n shared_ard = manager.Arduino()\n shared_alg = manager.Algorithm()\n shared_and = manager.Android()\n shared_icv = manager.ImageCV()\n \n p1 = Process(target=self.read_algorithm, args=(shared_alg, shared_icv))\n p1.start()\n p2 = Process(target=self.read_arduino, args=[shared_ard])\n p2.start()\n p3 = Process(target=self.read_android, args=[shared_and])\n p3.start()\n p4 = Process(target=self.read_imagecv, args=[shared_icv])\n p4.start()\n p5 = Process(target=self.write_target, args=(shared_ard, shared_alg, shared_and, shared_icv))\n p5.start()\n p5.join()","def create_builder():\r\n stream = Stream()\r\n return stream.fork()","def test_pool_with_memmap_array_view():\r\n assert_array_equal = np.testing.assert_array_equal\r\n\r\n # Fork the subprocess before allocating the objects to be passed\r\n pool_temp_folder = os.path.join(TEMP_FOLDER, 'pool')\r\n os.makedirs(pool_temp_folder)\r\n p = MemmapingPool(10, max_nbytes=2, temp_folder=pool_temp_folder)\r\n try:\r\n\r\n filename = os.path.join(TEMP_FOLDER, 'test.mmap')\r\n a = np.memmap(filename, dtype=np.float32, shape=(3, 5), mode='w+')\r\n a.fill(1.0)\r\n\r\n # Create an ndarray view on the memmap instance\r\n a_view = np.asarray(a)\r\n assert_false(isinstance(a_view, np.memmap))\r\n assert_true(has_shareable_memory(a_view))\r\n\r\n p.map(double, [(a_view, (i, j), 1.0)\r\n for i in range(a.shape[0])\r\n for j in range(a.shape[1])])\r\n\r\n # Both a and the a_view have been updated\r\n assert_array_equal(a, 2 * np.ones(a.shape))\r\n assert_array_equal(a_view, 2 * np.ones(a.shape))\r\n\r\n # Passing memmap array view to the pool should not trigger the\r\n # creation of new files on the FS\r\n assert_equal(os.listdir(pool_temp_folder), [])\r\n\r\n finally:\r\n p.terminate()\r\n del p","def create(self):\n\t\tself.creating += 1\n\t\ttry:\n\t\t\tself.adopt(self.factory())\n\t\tfinally:\n\t\t\tself.creating -= 1","def create_memory_agent(reactor, pumper, server_protocol):\n # Note, we currently don't actually do any \"resource traversing\"\n # and basically accept any path at all to our websocket resource\n if server_protocol is None:\n server_protocol = WebSocketServerProtocol\n return _TwistedWebMemoryAgent(reactor, pumper, server_protocol)","def __init__(self, *args):\n this = _ida_segment.new_lock_segment(*args)\n try: self.this.append(this)\n except: self.this = this","def shared_mem_zero_initializer(shape, dtype, name): # pylint: disable=unused-argument\n data = empty_shared_mem(name, True, shape, dtype)\n dlpack = data.to_dlpack()\n arr = F.zerocopy_from_dlpack(dlpack)\n arr[:] = 0\n return arr","def ShmemRawArray(type_, size_or_initializer, tag, create=True):\n if tag[0] != \"/\":\n tag = \"/%s\" % (tag,)\n\n if isinstance(size_or_initializer, int):\n type_ = type_ * size_or_initializer\n else:\n type_ = type_ * len(size_or_initializer)\n\n buffer = ShmemBufferWrapper(tag, ctypes.sizeof(type_), create=create)\n obj = type_.from_address(buffer.get_address())\n obj._buffer = buffer\n\n if not isinstance(size_or_initializer, int):\n obj.__init__(*size_or_initializer)\n\n return obj","async def unregister_system_shared_memory(\n self, name: str = ..., headers: dict[str, t.Any] = ...\n ) -> None:","def create_instance(c_instance):\n\treturn 0","def __create__container(self):\n self.__used_containers.append(contenedor.Arena(self.__blocks_size))","def add_array(self, attr_name, data, dtype=None):\n if attr_name in self._shm_attr_names:\n raise ValueError(f'A Shared Memory array with the name {attr_name}\\\n is already in this ShmManager')\n _shm = SharedMemArrayManager(\n data=data, dtype=dtype)\n self._shm_attr_names.append(attr_name)\n setattr(self, attr_name, _shm)","def __init__(self):\n super(MemoryPersistence, self).__init__(descriptor)","def create_mock_medium_topology(\n self,\n spout_parallelism=1,\n bolt1_parallelism=1,\n bolt2_parallelism=1,\n bolt3_parallelism=1):\n topology = protoTopology.Topology()\n topology.id = \"mock_topology_id\"\n topology.name = \"mock_topology_name\"\n\n # Streams\n stream1 = protoTopology.StreamId()\n stream1.id = \"mock_stream1\"\n stream1.component_name = \"mock_spout1\"\n\n stream2 = protoTopology.StreamId()\n stream2.id = \"mock_stream2\"\n stream2.component_name = \"mock_spout1\"\n\n stream3 = protoTopology.StreamId()\n stream3.id = \"mock_stream3\"\n stream3.component_name = \"mock_bolt1\"\n\n stream4 = protoTopology.StreamId()\n stream4.id = \"mock_stream4\"\n stream4.component_name = \"mock_bolt2\"\n\n # Spouts\n spout1 = self.create_mock_spout(\"mock_spout1\",\n [stream1, stream2],\n spout_parallelism)\n topology.spouts.extend([spout1])\n\n # Bolts\n bolt1 = self.create_mock_bolt(\"mock_bolt1\",\n [stream1],\n [stream3],\n bolt1_parallelism)\n bolt2 = self.create_mock_bolt(\"mock_bolt2\",\n [stream2],\n [stream4],\n bolt2_parallelism)\n bolt3 = self.create_mock_bolt(\"mock_bolt3\",\n [stream3, stream4],\n [],\n bolt3_parallelism)\n topology.bolts.extend([bolt1, bolt2, bolt3])\n\n\n return topology","def init_native():\n return Native()","def __fake_data__(self):\n\n # Set directory for configuration files\n self.configFilePath = q.system.fs.joinPaths(q.dirs.varDir, 'tftproot')\n \n # Add some share's\n for i in xrange(3):\n share = NFSShare()\n share.name = 'share-%s' % q.base.idgenerator.generateRandomInt(0, 255)\n self.shares[share.name] = share"],"string":"[\n \"def create_shared_memory_manager(\\n address: typing.Tuple[str, int], authkey: typing.Optional[bytes]\\n) -> SharedMemoryManager:\\n smm = SharedMemoryManager(address=address, authkey=authkey)\\n return smm\",\n \"def __init__(self):\\n\\t\\tself.dataMemory = sysv_ipc.SharedMemory(65)\\n\\t\\tself.statusMemory = sysv_ipc.SharedMemory(88)\\n\\t\\treturn\",\n \"async def register_system_shared_memory(\\n self,\\n name: str,\\n key: str,\\n byte_size: int,\\n offset: int = ...,\\n headers: dict[str, t.Any] = ...,\\n ) -> None:\",\n \"def shared_memory(self, graph_name): # -> None:\\n ...\",\n \"def shared_memory(self, graph_name): # -> None:\\n ...\",\n \"def shared_memory(self, graph_name): # -> None:\\n ...\",\n \"def _setup_shared_list(self):\\n self._manager = Manager().__enter__()\\n self._shared_list = self._manager.list()\\n return self\",\n \"def __init__(self, num_workers, mb=None):\\n self._state = SharedState(mb=mb)\\n self._procs = self._state.make_procs(num_workers)\",\n \"async def register_cuda_shared_memory(\\n self,\\n name: str,\\n raw_handle: bytes,\\n device_id: int,\\n byte_size: int,\\n headers: dict[str, t.Any] = ...,\\n ) -> None:\",\n \"def createCPUSharedArray(solver,arrayBytes):\\n itemsize = int(solver.dtype.itemsize)\\n #Creating MPI Window for shared memory\\n win = MPI.Win.Allocate_shared(arrayBytes, itemsize, comm=solver.nodeComm)\\n sharedBuffer, itemsize = win.Shared_query(0)\\n solver.sharedArray = numpy.ndarray(buffer=sharedBuffer, dtype=solver.dtype.type, shape=solver.sharedShape)\",\n \"def shared_mmp(data=None, file_name=\\\"shm\\\", shape=(0,), dtype=floatX):\\n if not data is None: shape = data.shape\\n path = \\\"/dev/shm/lio/\\\"\\n make_sure_path_exists(path)\\n mmp = np.memmap(path+file_name+\\\".mmp\\\", dtype=dtype, mode='w+', shape=shape)\\n if not data is None: mmp[:] = data\\n return mmp\",\n \"def createSharedNotebook(self, authenticationToken, sharedNotebook):\\r\\n pass\",\n \"def new_shared_array(shape, typecode='d', ismatrix=False):\\n typecode = np.dtype(typecode).char\\n return multiprocessing.Array(typecode, int(np.prod(shape)), lock=False), tuple(shape), typecode, ismatrix\",\n \"def shared_memory(self, graph_name):\\n self._meta = _move_metadata_to_shared_mem(\\n graph_name, self._num_nodes(), self._num_edges(), self._partid,\\n self._num_partitions, F.tensor(self._node_map), F.tensor(self._edge_map), True)\",\n \"def create_shared(out_size, in_size=None, name=None):\\n\\n if in_size is None:\\n return theano.shared(np.zeros((out_size, ),dtype=theano.config.floatX), name=name)\\n else:\\n return theano.shared(np.zeros((out_size, in_size),dtype=theano.config.floatX), name=name)\",\n \"def shared_memory(self, graph_name):\\n self._meta, self._nid2partid, self._eid2partid = _move_metadata_to_shared_mem(\\n graph_name, self._num_nodes(), self._num_edges(), self._part_id, self._num_partitions,\\n self._nid2partid, self._eid2partid, False)\",\n \"def frame_gen_shm():\\n\\n def calc_sleep():\\n return 1 / shr_args.target_fps\\n\\n logging.info(\\\"Generating frames from shared memory! shr_args: {}\\\".format(shr_args))\\n while True:\\n seq = (tf_seq.value - 1) % IMG_BUF_LEN\\n img_seq, img = shr_tf_img[seq]\\n frame = pil_image_to_base64(img)\\n\\n s = calc_sleep()\\n logging.info(\\\"Cur tf_seq {}, calc'd seq {}, got seq from tf {}, sleep time {} \\\".format(tf_seq.value, seq, img_seq, s))\\n time.sleep(s)\\n\\n yield (b'--frame\\\\r\\\\n'\\n b'Content-Type: image/jpeg\\\\r\\\\n\\\\r\\\\n' + frame + b'\\\\r\\\\n')\",\n \"def createSharedNotebook(self, authenticationToken, sharedNotebook):\\r\\n self.send_createSharedNotebook(authenticationToken, sharedNotebook)\\r\\n return self.recv_createSharedNotebook()\",\n \"def __init__(self, TargetResolution = [640, 480]):\\n self._IsPauseOn = False\\n self._TargetResolution = TargetResolution\\n\\n Size = ctypes.sizeof(Data_t)\\n self._SharedMemoryFile = None\\n\\n if os.name == \\\"nt\\\":\\n self._SharedMemory = mmap.mmap(-1, Size, RECORD_MEMORY_NAME)\\n\\n else:\\n Filename = os.path.join(\\\"/\\\", \\\"dev\\\", \\\"shm\\\", RECORD_MEMORY_NAME)\\n self._SharedMemoryFile = open(Filename, \\\"w+b\\\")\\n self._SharedMemoryFile.write(b\\\"\\\\0\\\"*Size)\\n self._SharedMemoryFile.flush();\\n self._SharedMemory = mmap.mmap(self._SharedMemoryFile.fileno(), Size)\\n\\n self._Data = Data_t.from_buffer(self._SharedMemory)\\n self._Image = np.empty(shape=TargetResolution + [self.TARGET_IMAGE_CHANNELS])\\n self._RawImage = np.empty(shape=TargetResolution + [self.TARGET_IMAGE_CHANNELS])\",\n \"def create_share(self):\\n\\t\\treturn handle_to_object(call_sdk_function('PrlVmCfg_CreateShare', self.handle))\",\n \"def __init__(self):\\n self.sharedRef=self\\n #raise NotImplementedError, \\\"This is abstract class. No instance allowed.\\\"\\n # Despite Shared is abstract, its children would inherit the constructor.\",\n \"def __init__(self, shared_list):\\n self.shared_list = shared_list\",\n \"def __init__(self, memory=4000):\\n self.session = boto3.Session()\\n self.batch_client = self.session.client(\\\"batch\\\")\\n self.logs_client = self.session.client(\\\"logs\\\")\\n self.memory = memory\",\n \"def test_multithreading_creation_dict(self):\\n # for sync\\n semaphore = Semaphore()\\n lock = Lock()\\n\\n d = SwapDict(\\n delete_file=True,\\n lock=lock,\\n semaphore=semaphore,\\n )\\n\\n # first process\\n def first():\\n for i in range(10, 21):\\n d[i] = i + 1\\n\\n # second process\\n def second():\\n for i in range(0, 11):\\n d[i] = i + 2\\n\\n # init thread\\n t1 = threading.Thread(target=first)\\n t2 = threading.Thread(target=second)\\n\\n # starting process\\n t1.start()\\n t2.start()\\n\\n # wait for process\\n t1.join()\\n t2.join()\\n\\n self.assertFalse(len(d) != 21, \\\"Error creation dict, check SyncManager\\\")\\n\\n for key in d:\\n self.assertFalse(d[key] - key != 1 and d[key] - key != 2, \\\"multiprocess creation dict error!\\\")\\n del d\",\n \"def new_manager() -> SyncManager:\\n return Manager()\",\n \"def _createMaster(self, *args, **kwds):\\n raise NotImplementedError\",\n \"def shared_bitshares_instance():\\n if not SharedInstance.instance:\\n clear_cache()\\n SharedInstance.instance = bts.BitShares()\\n return SharedInstance.instance\",\n \"def __init__(self, model_names):\\n for name in model_names:\\n model = spacy.load(name)\\n self.pool[name] = SharedModel(name, model)\\n log.debug(\\\"Initialized shared models in pool\\\")\",\n \"def make_objects(self):\\n pass\",\n \"def __init__(self, *args):\\n _snap.TMem_swiginit(self, _snap.new_TMem(*args))\",\n \"def allocate_object(object_to_use, variance):\\n\\thHandle = HANDLE(0)\\n\\tif object_to_use == 'unnamed_mutex':\\n\\t\\thHandle = kernel32.CreateMutexA(None, False, None)\\n\\telif object_to_use == 'named_mutex':\\n\\t\\thHandle = kernel32.CreateMutexA(None, False, \\\"Pool spraying is cool %s\\\" % variance)\\n\\telif object_to_use == 'unnamed_job':\\n\\t\\thHandle = kernel32.CreateJobObjectA(None, None)\\n\\telif object_to_use == 'named_job':\\n\\t\\thHandle = kernel32.CreateJobObjectA(None, \\\"Job %s\\\" % variance)\\n\\telif object_to_use == 'iocompletionport':\\n\\t\\thHandle = kernel32.CreateIoCompletionPort(-1, None, 0, 0)\\n\\telif object_to_use == 'iocompletionreserve':\\n\\t\\tIO_COMPLETION_OBJECT = 1\\n\\t\\tntdll.NtAllocateReserveObject(byref(hHandle), 0x0, IO_COMPLETION_OBJECT)\\n\\t\\thHandle = hHandle.value\\n\\telif object_to_use == 'unnamed_semaphore':\\n\\t\\thHandle = kernel32.CreateSemaphoreA(None, 0, 3, None)\\n\\telif object_to_use == 'named_semaphore':\\n\\t\\thHandle = kernel32.CreateSemaphoreA(None, 0, 3, \\\"My little Semaphore %s\\\" % variance)\\n\\telif object_to_use == 'event':\\n\\t\\thHandle = kernel32.CreateEventA(None, False, False, None)\\n\\tif hHandle == None:\\n\\t\\tprint \\\"[-] Error while creating object: %s\\\" % object_to_use\\n\\t\\treturn -1\\n\\treturn hHandle\",\n \"def test_create_nas_share_by_nas(self):\\n pass\",\n \"def __init__(self):\\r\\n self.__memory = []\",\n \"def __init__(self):\\n self.shared_counter = 0\\n self.queue = list()\\n self.queue_size = 0\",\n \"def init_worker(*shared_args_list):\\n global SHARED_ARGS\\n SHARED_ARGS = shared_args_list\",\n \"def __init__(self):\\n self.__dict__ = self._shared_state\",\n \"def test_inmemory_client_creation(self, mocker):\\n # Setup task mocks\\n def _split_task_init_mock(self, api, storage, period, event):\\n self._task = mocker.Mock()\\n self._api = api\\n self._storage = storage\\n self._period = period\\n self._event = event\\n event.set()\\n mocker.patch('splitio.client.factory.SplitSynchronizationTask.__init__', new=_split_task_init_mock)\\n def _segment_task_init_mock(self, api, storage, split_storage, period, event):\\n self._task = mocker.Mock()\\n self._worker_pool = mocker.Mock()\\n self._api = api\\n self._segment_storage = storage\\n self._split_storage = split_storage\\n self._period = period\\n self._event = event\\n event.set()\\n mocker.patch('splitio.client.factory.SegmentSynchronizationTask.__init__', new=_segment_task_init_mock)\\n\\n # Start factory and make assertions\\n factory = get_factory('some_api_key')\\n assert isinstance(factory._storages['splits'], inmemmory.InMemorySplitStorage)\\n assert isinstance(factory._storages['segments'], inmemmory.InMemorySegmentStorage)\\n assert isinstance(factory._storages['impressions'], inmemmory.InMemoryImpressionStorage)\\n assert factory._storages['impressions']._impressions.maxsize == 10000\\n assert isinstance(factory._storages['events'], inmemmory.InMemoryEventStorage)\\n assert factory._storages['events']._events.maxsize == 10000\\n assert isinstance(factory._storages['telemetry'], inmemmory.InMemoryTelemetryStorage)\\n\\n assert isinstance(factory._apis['splits'], SplitsAPI)\\n assert factory._apis['splits']._client._timeout == 1.5\\n assert isinstance(factory._apis['segments'], SegmentsAPI)\\n assert factory._apis['segments']._client._timeout == 1.5\\n assert isinstance(factory._apis['impressions'], ImpressionsAPI)\\n assert factory._apis['impressions']._client._timeout == 1.5\\n assert isinstance(factory._apis['events'], EventsAPI)\\n assert factory._apis['events']._client._timeout == 1.5\\n assert isinstance(factory._apis['telemetry'], TelemetryAPI)\\n assert factory._apis['telemetry']._client._timeout == 1.5\\n\\n assert isinstance(factory._tasks['splits'], split_sync.SplitSynchronizationTask)\\n assert factory._tasks['splits']._period == DEFAULT_CONFIG['featuresRefreshRate']\\n assert factory._tasks['splits']._storage == factory._storages['splits']\\n assert factory._tasks['splits']._api == factory._apis['splits']\\n assert isinstance(factory._tasks['segments'], segment_sync.SegmentSynchronizationTask)\\n assert factory._tasks['segments']._period == DEFAULT_CONFIG['segmentsRefreshRate']\\n assert factory._tasks['segments']._segment_storage == factory._storages['segments']\\n assert factory._tasks['segments']._split_storage == factory._storages['splits']\\n assert factory._tasks['segments']._api == factory._apis['segments']\\n assert isinstance(factory._tasks['impressions'], impressions_sync.ImpressionsSyncTask)\\n assert factory._tasks['impressions']._period == DEFAULT_CONFIG['impressionsRefreshRate']\\n assert factory._tasks['impressions']._storage == factory._storages['impressions']\\n assert factory._tasks['impressions']._impressions_api == factory._apis['impressions']\\n assert isinstance(factory._tasks['events'], events_sync.EventsSyncTask)\\n assert factory._tasks['events']._period == DEFAULT_CONFIG['eventsPushRate']\\n assert factory._tasks['events']._storage == factory._storages['events']\\n assert factory._tasks['events']._events_api == factory._apis['events']\\n assert isinstance(factory._tasks['telemetry'], telemetry_sync.TelemetrySynchronizationTask)\\n assert factory._tasks['telemetry']._period == DEFAULT_CONFIG['metricsRefreshRate']\\n assert factory._tasks['telemetry']._storage == factory._storages['telemetry']\\n assert factory._tasks['telemetry']._api == factory._apis['telemetry']\\n assert factory._labels_enabled is True\\n factory.block_until_ready()\\n time.sleep(1) # give a chance for the bg thread to set the ready status\\n assert factory.ready\\n factory.destroy()\",\n \"def __init__(self, addr, storage='1', cache_size=20 * MB,\\n name='', wait_timeout=None,\\n disconnect_poll=None,\\n read_only=0, read_only_fallback=0,\\n blob_dir=None, shared_blob_dir=False,\\n blob_cache_size=None, blob_cache_size_check=10,\\n client_label=None,\\n cache=None,\\n ssl=None, ssl_server_hostname=None,\\n # Mostly ignored backward-compatability options\\n client=None, var=None,\\n min_disconnect_poll=1, max_disconnect_poll=None,\\n wait=True,\\n drop_cache_rather_verify=True,\\n credentials=None,\\n server_sync=False,\\n # The ZODB-define ZConfig support may ball these:\\n username=None, password=None, realm=None,\\n # For tests:\\n _client_factory=ZEO.asyncio.client.ClientThread,\\n ):\\n\\n if isinstance(addr, int):\\n addr = ('127.0.0.1', addr)\\n\\n self.__name__ = name or str(addr) # Standard convention for storages\\n\\n if isinstance(addr, str):\\n if WIN:\\n raise ValueError(\\\"Unix sockets are not available on Windows\\\")\\n addr = [addr]\\n elif (isinstance(addr, tuple) and len(addr) == 2 and\\n isinstance(addr[0], str) and\\n isinstance(addr[1], int)):\\n addr = [addr]\\n\\n logger.info(\\n \\\"%s %s (pid=%d) created %s/%s for storage: %r\\\",\\n self.__name__,\\n self.__class__.__name__,\\n os.getpid(),\\n read_only and \\\"RO\\\" or \\\"RW\\\",\\n read_only_fallback and \\\"fallback\\\" or \\\"normal\\\",\\n storage,\\n )\\n\\n self._is_read_only = read_only\\n self._read_only_fallback = read_only_fallback\\n\\n self._addr = addr # For tests\\n\\n self._iterators = weakref.WeakValueDictionary()\\n self._iterator_ids = set()\\n self._storage = storage\\n\\n # _server_addr is used by sortKey()\\n self._server_addr = None\\n\\n self._client_label = client_label\\n\\n self._info = {'length': 0, 'size': 0, 'name': 'ZEO Client',\\n 'supportsUndo': 0, 'interfaces': ()}\\n\\n self._db = None\\n\\n self._oids = [] # List of pre-fetched oids from server\\n\\n cache = self._cache = open_cache(\\n cache, var, client, storage, cache_size)\\n\\n # XXX need to check for POSIX-ness here\\n self.blob_dir = blob_dir\\n self.shared_blob_dir = shared_blob_dir\\n\\n if blob_dir is not None:\\n # Avoid doing this import unless we need it, as it\\n # currently requires pywin32 on Windows.\\n import ZODB.blob\\n if shared_blob_dir:\\n self.fshelper = ZODB.blob.FilesystemHelper(blob_dir)\\n else:\\n if 'zeocache' not in ZODB.blob.LAYOUTS:\\n ZODB.blob.LAYOUTS['zeocache'] = BlobCacheLayout()\\n self.fshelper = ZODB.blob.FilesystemHelper(\\n blob_dir, layout_name='zeocache')\\n self.fshelper.create()\\n else:\\n self.fshelper = None\\n\\n self._blob_cache_size = blob_cache_size\\n self._blob_data_bytes_loaded = 0\\n if blob_cache_size is not None:\\n assert blob_cache_size_check < 100\\n self._blob_cache_size_check = (\\n blob_cache_size * blob_cache_size_check // 100)\\n self._check_blob_size()\\n\\n self.server_sync = server_sync\\n\\n self._server = _client_factory(\\n addr, self, cache, storage,\\n ZEO.asyncio.client.Fallback if read_only_fallback else read_only,\\n wait_timeout or 30,\\n ssl=ssl, ssl_server_hostname=ssl_server_hostname,\\n )\\n self._call = self._server.call\\n self._async = self._server.async_\\n self._async_iter = self._server.async_iter\\n self._wait = self._server.wait\\n\\n self._commit_lock = threading.Lock()\\n\\n if wait:\\n try:\\n self._wait()\\n except Exception:\\n # No point in keeping the server going if the storage\\n # creation fails\\n self._server.close()\\n raise\",\n \"def create():\",\n \"def create():\",\n \"def __enter__(self):\\n self._setup_shared_list()\\n self._shared_list_container = _SharedList(self._shared_list)\\n return self._shared_list_container\",\n \"def _mkObject(self):\\n return ImmutableObject(\\n store=self.store,\\n hash=u'somehash',\\n contentDigest=u'quux',\\n content=self.store.newFilePath('foo'),\\n contentType=u'application/octet-stream')\",\n \"def __init__process(self, n_cpu):\\n global shared_slices\\n global shared_data\\n\\n shared_slices_base = sharedctypes.RawArray(ctypes.c_double,\\n self._projection.shape[0])\\n shared_slices = np.frombuffer(shared_slices_base)\\n shared_slices = shared_slices.reshape((len(self._q.R), -1))\\n\\n shared_grad_base = sharedctypes.RawArray(ctypes.c_double,\\n self._projection.shape[0])\\n shared_grad = np.frombuffer(shared_grad_base)\\n shared_grad = shared_grad.reshape((len(self._q.R), -1))\\n\\n shared_data_base = mp.Array(ctypes.c_double,\\n self._data.size,\\n lock=False)\\n shared_data = np.ctypeslib.as_array(shared_data_base)\\n shared_data = shared_data.reshape(self._data.shape)\\n shared_data[:] = self._data\\n\\n self._pool = mp.Pool(n_cpu)\",\n \"def test_inmemory_client_creation_streaming_false(self, mocker):\\n\\n # Setup synchronizer\\n def _split_synchronizer(self, ready_flag, some, auth_api, streaming_enabled, sdk_matadata, telemetry_runtime_producer, sse_url=None, client_key=None):\\n synchronizer = mocker.Mock(spec=Synchronizer)\\n synchronizer.sync_all.return_values = None\\n self._ready_flag = ready_flag\\n self._synchronizer = synchronizer\\n self._streaming_enabled = False\\n self._telemetry_runtime_producer = telemetry_runtime_producer\\n\\n mocker.patch('splitio.sync.manager.Manager.__init__', new=_split_synchronizer)\\n\\n # Start factory and make assertions\\n factory = get_factory('some_api_key')\\n assert isinstance(factory._storages['splits'], inmemmory.InMemorySplitStorage)\\n assert isinstance(factory._storages['segments'], inmemmory.InMemorySegmentStorage)\\n assert isinstance(factory._storages['impressions'], inmemmory.InMemoryImpressionStorage)\\n assert factory._storages['impressions']._impressions.maxsize == 10000\\n assert isinstance(factory._storages['events'], inmemmory.InMemoryEventStorage)\\n assert factory._storages['events']._events.maxsize == 10000\\n\\n assert isinstance(factory._sync_manager, Manager)\\n\\n assert isinstance(factory._recorder, StandardRecorder)\\n assert isinstance(factory._recorder._impressions_manager, ImpressionsManager)\\n assert isinstance(factory._recorder._event_sotrage, inmemmory.EventStorage)\\n assert isinstance(factory._recorder._impression_storage, inmemmory.ImpressionStorage)\\n\\n assert factory._labels_enabled is True\\n try:\\n factory.block_until_ready(1)\\n except:\\n pass\\n assert factory.ready\\n factory.destroy()\",\n \"def clear_shared_memory():\\n\\n for shmtype in ('-m', '-s', '-q'):\\n items = _list_ipcs(shmtype)\\n for item in items:\\n try:\\n check_output(('ipcrm', shmtype, item['id']), stderr=STDOUT)\\n except CalledProcessError:\\n pass\",\n \"def share(self):\\n shared = super().share()\\n shared['opt'] = self.opt\\n shared['answers'] = self.answers\\n shared['dict'] = self.dict\\n shared['START_IDX'] = self.START_IDX\\n shared['END_IDX'] = self.END_IDX\\n shared['NULL_IDX'] = self.NULL_IDX\\n shared['model'] = self.model\\n shared['receiver'] = self.receiver\\n shared['receiver_dict'] = self.receiver_dict\\n if self.opt.get('numthreads', 1) > 1:\\n # we're doing hogwild so share the model too\\n if type(self.metrics) == dict:\\n # move metrics and model to shared memory\\n self.metrics = SharedTable(self.metrics)\\n self.model.share_memory()\\n shared['states'] = { # don't share optimizer states\\n 'optimizer_type': self.opt['optimizer'],\\n }\\n shared['metrics'] = self.metrics # do after numthreads check\\n return shared\",\n \"def load_array(\\n self, attr_name, buffer_name, dtype):\\n if attr_name in self._shm_attr_names:\\n raise ValueError(f'A Shared Memory array with the name {attr_name}\\\\\\n is already in this ShmManager')\\n _shm = SharedMemArrayManager(\\n buffer_name=buffer_name,\\n dtype=dtype)\\n self._shm_attr_names.append(attr_name)\\n setattr(self, attr_name, _shm)\",\n \"def _create_shared_vars(self, **inputs):\\n shared_vars = {}\\n for name, data in inputs.items():\\n shared_vars[name] = shared(data, name=name)\\n return shared_vars\",\n \"def testNanotecSharedMemory():\\n\\t\\n\\tmemoryClient = NanotecSharedMemoryClient()\\n\\t\\n\\t\\n\\t\\n\\tserialPort1 = memoryClient.sendInstruction(\\\"NanotecMotor,/dev/ttyACM0,17\\\")\\n\\t\\n\\tID1 = memoryClient.sendInstruction(\\\"getID,\\\" + serialPort1)\\n\\tprint(\\\"ID1 (actual): \\\" + ID1 + \\\", expected: 17\\\")\\n\\tprint(\\\"\\\")\\n\\t\\n\\tstartTime = time.time()\\n\\tnumCalls = 1000\\n\\tfor _ in range(numCalls):\\n\\t\\tID1 = memoryClient.sendInstruction(\\\"getSerialPort,\\\" + serialPort1)\\n\\tendTime = time.time()\\n\\ttotalTime = endTime - startTime\\n\\tprint(\\\"\\\")\\n\\tprint(\\\"ID Call\\\")\\n\\tprint(\\\"numCalls: \\\" + str(numCalls))\\n\\tprint(\\\"total time: \\\" + str(totalTime))\\n\\tprint(\\\"time per call: \\\" + str(totalTime/numCalls))\\n\\t\\n\\t\\n\\tstartTime = time.time()\\n\\tnumCalls = 1000\\n\\tfor _ in range(numCalls):\\n\\t\\tposition = memoryClient.sendInstruction(\\\"getAbsoluteAngularPosition,\\\" + serialPort1)\\n\\tendTime = time.time()\\n\\ttotalTime = endTime - startTime\\n\\tprint(\\\"\\\")\\n\\tprint(\\\"Position Call\\\")\\n\\tprint(\\\"numCalls: \\\" + str(numCalls))\\n\\tprint(\\\"total time: \\\" + str(totalTime))\\n\\tprint(\\\"time per call: \\\" + str(totalTime/numCalls))\\n\\t\\n\\treturn\",\n \"def __call__(cls, *args, **kwargs):\\n\\n def new_instance():\\n return super(SharedMemoryModelBase, cls).__call__(*args, **kwargs)\\n\\n instance_key = cls._get_cache_key(args, kwargs)\\n # depending on the arguments, we might not be able to infer the PK, so in that case we\\n # create a new instance\\n if instance_key is None:\\n return new_instance()\\n cached_instance = cls.get_cached_instance(instance_key)\\n if cached_instance is None:\\n cached_instance = new_instance()\\n cls.cache_instance(cached_instance, new=True)\\n return cached_instance\",\n \"def __init__(self):\\n manager = Manager()\\n # As the snippet is executing in multiprocessing.Process, a shared\\n # dict should be used to ensure the change is propagated.\\n self.local = manager.dict()\\n\\n # the object in shared dict should also be shared\\n for k, v in self.presets.items():\\n if isinstance(v, list):\\n self.local[k] = manager.list(v)\\n elif isinstance(v, dict):\\n self.local[k] = manager.dict(v)\\n elif isinstance(v, set):\\n self.local[k] = manager.set(v)\\n else:\\n self.local[k] = v\",\n \"def create_buffers(self):\",\n \"def init_memoryspace(reload=False):\\n global memoryspace\\n if memoryspace is not None and not reload:\\n return\\n\\n try:\\n memoryspace = MemorySpace()\\n except:\\n traceback.print_exc()\\n raise\",\n \"def makeSharedArrays(shapeList):\\n out_arrays = []\\n for shape in shapeList:\\n nx,ny = shape\\n arr = Array('d', nx*ny)\\n out_arrays.append(np.frombuffer(arr.get_obj()).reshape(shape))\\n\\n return out_arrays\",\n \"def build_shared_zeros(shape, name):\\n return theano.shared(\\n \\tvalue=np.zeros(shape, dtype=theano.config.floatX), \\n \\tname=name, \\n \\tborrow=True\\n )\",\n \"def _create_vm(self):\\n self._create_instance_in_the_db()\\n self.type_data = db.instance_type_get_by_name(None, 'm1.large')\\n self.conn.spawn(self.context, self.instance, self.network_info)\\n self._check_vm_record()\",\n \"def make_object():\\n return object()\",\n \"def __new__(cls, *args, **kwargs):\\n obj = super(Memory, cls).__new__(cls, *args, **kwargs)\\n obj.__dict__ = cls.data\\n\\n return obj\",\n \"def from_shares(share, precision=None, src=0, device=None):\\n result = BinarySharedTensor(src=SENTINEL)\\n share = share.to(device) if device is not None else share\\n result.share = CUDALongTensor(share) if share.is_cuda else share\\n result.encoder = FixedPointEncoder(precision_bits=precision)\\n return result\",\n \"def __init__(self, shape, dtype = 'd'):\\n self.shape = shape\\n self.dtype = dtype\\n \\n ncell = int(np.prod(self.shape))\\n self.shared_array_base = Array(dtype, ncell,lock=False) \\n pass\",\n \"def _createModuleObj(self):\\n ModuleTimeWeakening.__init__(self)\\n return\",\n \"def create(self, object_id, size, metadata=None):\\n # Turn the metadata into the right type.\\n metadata = bytearray(\\\"\\\") if metadata is None else metadata\\n buff = libplasma.create(self.conn, object_id, size, metadata)\\n return PlasmaBuffer(buff, object_id, self)\",\n \"def new(*args, **kwargs):\\n return BinarySharedTensor(*args, **kwargs)\",\n \"def create_graph_store_server(graph_data, graph_name, store_type, num_workers,\\n multigraph=None, port=8000):\\n if multigraph is not None:\\n dgl_warning(\\\"multigraph is deprecated.\\\" \\\\\\n \\\"DGL treat all graphs as multigraph by default.\\\")\\n return SharedMemoryStoreServer(graph_data, graph_name, None,\\n num_workers, port)\",\n \"def share():\\n return True\",\n \"def openValkka(self):\\n \\n self.livethread =LiveThread(\\\"livethread\\\")\\n # reserve 10 frames, 300 KB each\\n self.shmem_filter =ShmemFrameFilter(shmem_name_tag,10,300*1024)\\n # ShmemFrameFilter instantiates the server side of shmem bridge\\n # in a separate process do:\\n # rb=SharedMemRingBuffer(shmem_name_tag,10,30*1024*1024,False) # shmem ring buffer on the client side\\n self.live_out_filter =InfoFrameFilter(\\\"live_out_filter\\\",self.shmem_filter)\\n \\n # Start all threads\\n self.livethread.startCall()\",\n \"def createRotoNodeMI():\\n return gs()\",\n \"def createServer():\\n cd('/')\\n srv = cmo.createServer(managedServername) \\n srv.setCluster(getMBean('/Clusters/%s' % cluster_name))\\n srv.setListenPort(managedServerPort)\\n return srv\",\n \"def _create_workers(self):\\n WorkerNTuple = namedtuple(\\\"Worker\\\", [\\\"process\\\", \\\"connection\\\", \\\"barrier\\\"])\\n self.workers = []\\n\\n for env_i, s_s, s_r, s_d, s_a, s_i in zip(\\n self.split(self.env),\\n self.split(self.shared_tran.s),\\n self.split(self.shared_tran.r),\\n self.split(self.shared_tran.d),\\n self.split(self.shared_tran.ac),\\n self.split(self.shared_tran.info),\\n ):\\n\\n shared_tran = U.memories.SimpleMemory(s=s_s, r=s_r, d=s_d, ac=s_a, info=s_i)\\n parent_conn, child_conn = Pipe()\\n queue = Queue()\\n\\n process = EnvWorker(\\n env=env_i, conn=queue, barrier=child_conn, shared_transition=shared_tran\\n )\\n process.daemon = True\\n process.start()\\n\\n self.workers.append(\\n WorkerNTuple(process=process, connection=queue, barrier=parent_conn)\\n )\",\n \"def init_memmap( size_MB=2):\\n global mmap_size, mmap_file\\n mmap_name = \\\"mmap_python_java.mmap\\\"\\n mmap_size = size_MB*1024*1024\\n mmap_name_path = os.path.join(os.getcwd(), mmap_name)\\n gateway.jvm.pyboof.PyBoofEntryPoint.initializeMmap(mmap_name_path, size_MB)\\n # Open file in read,write,binary mode\\n mmap_fid = open(mmap_name, \\\"r+b\\\")\\n mmap_file = mmap.mmap(mmap_fid.fileno(), length=0, flags=mmap.MAP_SHARED,\\n prot=mmap.PROT_READ | mmap.PROT_WRITE)\",\n \"def spray(required_hole_size):\\n\\tglobal pool_object_handles\\n\\tgood_object = find_object_to_spray(required_hole_size)\\n\\tfor i in range(SPRAY_COUNT):\\n\\t\\tpool_object_handles.append(allocate_object(good_object, i))\\n\\tprint \\\"[+] Spray done!\\\"\\n\\treturn good_object\",\n \"def create_new_session(sessions, segmeta):\\n # Find an available session id\\n new_sid = 0\\n while new_sid in [s[0].meta.sessionid for s in sessions.values()]:\\n new_sid += 1\\n # Create meta and fill in information of the file\\n meta = MetaInfo(segmeta.filename, segmeta.segmentid, new_sid)\\n sp = snc_parameters(meta.segsize, 0.01, 16, 64, 1280, BAND_SNC, 1, 1, 0, -1)\\n meta.set_snc_params(sp)\\n # Fork a child process and build pipe between parent and child\\n session = Session(meta)\\n (fdp, fdc) = mp.Pipe()\\n session.fdp = fdp\\n session.fdc = fdc\\n logging.info(\\\"New session created, ID: %d \\\" % (new_sid,))\\n print(session.meta)\\n # Fork a process to serve the clients of the session\\n child = mp.Process(target=session.main)\\n child.start()\\n session.fdc.close() # Close parent's fdc\\n sessions[(segmeta.filename, segmeta.segmentid)] = (session, child)\\n return session\",\n \"def __init__(self,server_list):\\n self.workers=[]\\n self.worker_by_name={}\\n worker_id = 1\\n for host,port in server_list:\\n # Add the uid here can help with port conflicts, but only works\\n # on Unix clusters. We really need to work out a daemon service\\n # model that makes the port mess transparent.\\n port = port #+ os.getuid()\\n new_worker = sync_cluster.standard_sync_client(host,port,worker_id)\\n self.workers.append(new_worker)\\n self.worker_by_name[host] = new_worker\\n worker_id = worker_id + 1\",\n \"def allocate_and_set_workspace(handle, allocator, workspace_desc, pref, mem_space, workspace_kind, device_id, stream, stream_ctx, logger, task_name=''):\\n workspace_size = cutn.workspace_get_memory_size(handle, workspace_desc, pref, mem_space, workspace_kind)\\n # Allocate and set workspace\\n if mem_space == cutn.Memspace.DEVICE:\\n with utils.device_ctx(device_id), stream_ctx:\\n try:\\n logger.debug(f\\\"Allocating device memory for {task_name}\\\")\\n workspace_ptr = allocator.memalloc(workspace_size)\\n except TypeError as e:\\n message = \\\"The method 'memalloc' in the allocator object must conform to the interface in the \\\"\\\\\\n \\\"'BaseCUDAMemoryManager' protocol.\\\"\\n raise TypeError(message) from e\\n \\n logger.debug(f\\\"Finished allocating device memory of size {formatters.MemoryStr(workspace_size)} for decomposition in the context of stream {stream}.\\\")\\n device_ptr = utils.get_ptr_from_memory_pointer(workspace_ptr)\\n cutn.workspace_set_memory(handle, workspace_desc, mem_space, workspace_kind, device_ptr, workspace_size)\\n logger.debug(f\\\"The workspace memory (device pointer = {device_ptr}) has been set in the workspace descriptor.\\\")\\n return workspace_ptr\\n elif workspace_size != 0:\\n # host workspace\\n logger.debug(f\\\"Allocating host memory for {task_name}\\\")\\n workspace_host = numpy.empty(workspace_size, dtype=numpy.int8)\\n logger.debug(f\\\"Finished allocating host memory of size {formatters.MemoryStr(workspace_size)} for decomposition.\\\")\\n cutn.workspace_set_memory(handle, workspace_desc, mem_space, workspace_kind, workspace_host.ctypes.data, workspace_size)\\n logger.debug(f\\\"The workspace memory (host pointer = {workspace_host.ctypes.data}) has been set in the workspace descriptor.\\\")\\n return workspace_host\\n else:\\n return None\",\n \"def __init__(self, sharedItem, sharedInterfaces, shareID):\\n rself = _really(self)\\n rself._sharedItem = sharedItem\\n rself._shareID = shareID\\n rself._adapterCache = {}\\n # Drop all duplicate shared interfaces.\\n uniqueInterfaces = list(sharedInterfaces)\\n # XXX there _MUST_ Be a better algorithm for this\\n for left in sharedInterfaces:\\n for right in sharedInterfaces:\\n if left.extends(right) and right in uniqueInterfaces:\\n uniqueInterfaces.remove(right)\\n for eachInterface in uniqueInterfaces:\\n if not eachInterface.providedBy(sharedItem):\\n impl = eachInterface(sharedItem, None)\\n if impl is not None:\\n rself._adapterCache[eachInterface] = impl\\n rself._sharedInterfaces = uniqueInterfaces\\n # Make me look *exactly* like the item I am proxying for, at least for\\n # the purposes of adaptation\\n # directlyProvides(self, providedBy(sharedItem))\\n directlyProvides(self, uniqueInterfaces)\",\n \"def __init__(self, manager, name):\\n Online.AllocatorControl.AllocatorClient.__init__(self,manager,name)\\n Online.DatapointLoader.DatapointLoader.__init__(self,manager,name)\",\n \"def createObject(self, *args):\\n return _libsbml.MultiCompartmentPlugin_createObject(self, *args)\",\n \"def create_spaces():\\n\\n data.load('spaces')\\n\\n mc.refresh()\\n spaces.build_all()\",\n \"def __init__(self, shared_states):\\n self.shared_states = shared_states\",\n \"def memory_shares(self, shares):\\n\\n assert shares >= 0\\n config_spec = vim.vm.ConfigSpec()\\n shares_alloc = vim.ResourceAllocationInfo()\\n shares_alloc.shares = vim.SharesInfo(level=\\\"custom\\\", shares=shares)\\n config_spec.memoryAllocation = shares_alloc\\n return self.vm_obj.ReconfigVM_Task(config_spec)\",\n \"def __init__(self):\\n self.mem = [0] * 256\\n self.pc = 0\\n self.running = False\",\n \"def _create_impl(self):\",\n \"def make(self):\\n pass\",\n \"def set_shared_bitshares_instance(bitshares_instance):\\n clear_cache()\\n SharedInstance.instance = bitshares_instance\",\n \"def __init__(self):\\n self.write_queue = Manager().Queue()\\n\\n BaseManager.register('Arduino',Arduino)\\n BaseManager.register('Algorithm',Algorithm)\\n BaseManager.register('Android',Android)\\n BaseManager.register('ImageCV', ImageCV)\\n manager = BaseManager()\\n manager.start()\\n shared_ard = manager.Arduino()\\n shared_alg = manager.Algorithm()\\n shared_and = manager.Android()\\n shared_icv = manager.ImageCV()\\n \\n p1 = Process(target=self.read_algorithm, args=(shared_alg, shared_icv))\\n p1.start()\\n p2 = Process(target=self.read_arduino, args=[shared_ard])\\n p2.start()\\n p3 = Process(target=self.read_android, args=[shared_and])\\n p3.start()\\n p4 = Process(target=self.read_imagecv, args=[shared_icv])\\n p4.start()\\n p5 = Process(target=self.write_target, args=(shared_ard, shared_alg, shared_and, shared_icv))\\n p5.start()\\n p5.join()\",\n \"def create_builder():\\r\\n stream = Stream()\\r\\n return stream.fork()\",\n \"def test_pool_with_memmap_array_view():\\r\\n assert_array_equal = np.testing.assert_array_equal\\r\\n\\r\\n # Fork the subprocess before allocating the objects to be passed\\r\\n pool_temp_folder = os.path.join(TEMP_FOLDER, 'pool')\\r\\n os.makedirs(pool_temp_folder)\\r\\n p = MemmapingPool(10, max_nbytes=2, temp_folder=pool_temp_folder)\\r\\n try:\\r\\n\\r\\n filename = os.path.join(TEMP_FOLDER, 'test.mmap')\\r\\n a = np.memmap(filename, dtype=np.float32, shape=(3, 5), mode='w+')\\r\\n a.fill(1.0)\\r\\n\\r\\n # Create an ndarray view on the memmap instance\\r\\n a_view = np.asarray(a)\\r\\n assert_false(isinstance(a_view, np.memmap))\\r\\n assert_true(has_shareable_memory(a_view))\\r\\n\\r\\n p.map(double, [(a_view, (i, j), 1.0)\\r\\n for i in range(a.shape[0])\\r\\n for j in range(a.shape[1])])\\r\\n\\r\\n # Both a and the a_view have been updated\\r\\n assert_array_equal(a, 2 * np.ones(a.shape))\\r\\n assert_array_equal(a_view, 2 * np.ones(a.shape))\\r\\n\\r\\n # Passing memmap array view to the pool should not trigger the\\r\\n # creation of new files on the FS\\r\\n assert_equal(os.listdir(pool_temp_folder), [])\\r\\n\\r\\n finally:\\r\\n p.terminate()\\r\\n del p\",\n \"def create(self):\\n\\t\\tself.creating += 1\\n\\t\\ttry:\\n\\t\\t\\tself.adopt(self.factory())\\n\\t\\tfinally:\\n\\t\\t\\tself.creating -= 1\",\n \"def create_memory_agent(reactor, pumper, server_protocol):\\n # Note, we currently don't actually do any \\\"resource traversing\\\"\\n # and basically accept any path at all to our websocket resource\\n if server_protocol is None:\\n server_protocol = WebSocketServerProtocol\\n return _TwistedWebMemoryAgent(reactor, pumper, server_protocol)\",\n \"def __init__(self, *args):\\n this = _ida_segment.new_lock_segment(*args)\\n try: self.this.append(this)\\n except: self.this = this\",\n \"def shared_mem_zero_initializer(shape, dtype, name): # pylint: disable=unused-argument\\n data = empty_shared_mem(name, True, shape, dtype)\\n dlpack = data.to_dlpack()\\n arr = F.zerocopy_from_dlpack(dlpack)\\n arr[:] = 0\\n return arr\",\n \"def ShmemRawArray(type_, size_or_initializer, tag, create=True):\\n if tag[0] != \\\"/\\\":\\n tag = \\\"/%s\\\" % (tag,)\\n\\n if isinstance(size_or_initializer, int):\\n type_ = type_ * size_or_initializer\\n else:\\n type_ = type_ * len(size_or_initializer)\\n\\n buffer = ShmemBufferWrapper(tag, ctypes.sizeof(type_), create=create)\\n obj = type_.from_address(buffer.get_address())\\n obj._buffer = buffer\\n\\n if not isinstance(size_or_initializer, int):\\n obj.__init__(*size_or_initializer)\\n\\n return obj\",\n \"async def unregister_system_shared_memory(\\n self, name: str = ..., headers: dict[str, t.Any] = ...\\n ) -> None:\",\n \"def create_instance(c_instance):\\n\\treturn 0\",\n \"def __create__container(self):\\n self.__used_containers.append(contenedor.Arena(self.__blocks_size))\",\n \"def add_array(self, attr_name, data, dtype=None):\\n if attr_name in self._shm_attr_names:\\n raise ValueError(f'A Shared Memory array with the name {attr_name}\\\\\\n is already in this ShmManager')\\n _shm = SharedMemArrayManager(\\n data=data, dtype=dtype)\\n self._shm_attr_names.append(attr_name)\\n setattr(self, attr_name, _shm)\",\n \"def __init__(self):\\n super(MemoryPersistence, self).__init__(descriptor)\",\n \"def create_mock_medium_topology(\\n self,\\n spout_parallelism=1,\\n bolt1_parallelism=1,\\n bolt2_parallelism=1,\\n bolt3_parallelism=1):\\n topology = protoTopology.Topology()\\n topology.id = \\\"mock_topology_id\\\"\\n topology.name = \\\"mock_topology_name\\\"\\n\\n # Streams\\n stream1 = protoTopology.StreamId()\\n stream1.id = \\\"mock_stream1\\\"\\n stream1.component_name = \\\"mock_spout1\\\"\\n\\n stream2 = protoTopology.StreamId()\\n stream2.id = \\\"mock_stream2\\\"\\n stream2.component_name = \\\"mock_spout1\\\"\\n\\n stream3 = protoTopology.StreamId()\\n stream3.id = \\\"mock_stream3\\\"\\n stream3.component_name = \\\"mock_bolt1\\\"\\n\\n stream4 = protoTopology.StreamId()\\n stream4.id = \\\"mock_stream4\\\"\\n stream4.component_name = \\\"mock_bolt2\\\"\\n\\n # Spouts\\n spout1 = self.create_mock_spout(\\\"mock_spout1\\\",\\n [stream1, stream2],\\n spout_parallelism)\\n topology.spouts.extend([spout1])\\n\\n # Bolts\\n bolt1 = self.create_mock_bolt(\\\"mock_bolt1\\\",\\n [stream1],\\n [stream3],\\n bolt1_parallelism)\\n bolt2 = self.create_mock_bolt(\\\"mock_bolt2\\\",\\n [stream2],\\n [stream4],\\n bolt2_parallelism)\\n bolt3 = self.create_mock_bolt(\\\"mock_bolt3\\\",\\n [stream3, stream4],\\n [],\\n bolt3_parallelism)\\n topology.bolts.extend([bolt1, bolt2, bolt3])\\n\\n\\n return topology\",\n \"def init_native():\\n return Native()\",\n \"def __fake_data__(self):\\n\\n # Set directory for configuration files\\n self.configFilePath = q.system.fs.joinPaths(q.dirs.varDir, 'tftproot')\\n \\n # Add some share's\\n for i in xrange(3):\\n share = NFSShare()\\n share.name = 'share-%s' % q.base.idgenerator.generateRandomInt(0, 255)\\n self.shares[share.name] = share\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6806886","0.6637284","0.6420833","0.5987398","0.5987398","0.5987398","0.59054685","0.5809415","0.5729596","0.5698809","0.5693551","0.5631676","0.561561","0.561286","0.56091833","0.5602408","0.56005305","0.5592581","0.55451244","0.5470646","0.5406517","0.5383486","0.5353251","0.5348532","0.53436226","0.5337712","0.53144467","0.5309993","0.5309897","0.5306308","0.52457654","0.5236737","0.5202982","0.52005017","0.51796734","0.51786715","0.5174165","0.51371706","0.5128458","0.5128458","0.51249343","0.5116323","0.51073706","0.50953954","0.50677377","0.5060064","0.50520927","0.50467324","0.50460625","0.50378543","0.5033081","0.501999","0.49968335","0.49948907","0.49768144","0.49709585","0.49643534","0.49623796","0.49598727","0.49550888","0.49493524","0.4947857","0.49467817","0.49363193","0.49349856","0.49329215","0.49316183","0.49267006","0.49223292","0.4919613","0.49093682","0.48755422","0.48742226","0.4869546","0.48627317","0.48513812","0.48493725","0.48441952","0.48428556","0.48418027","0.48347265","0.48192167","0.48152524","0.48090863","0.48071688","0.48003054","0.48002774","0.47990933","0.47919762","0.4790654","0.4783653","0.4782526","0.47735357","0.4760217","0.47464925","0.4738815","0.4730515","0.4729926","0.4714383","0.47123384"],"string":"[\n \"0.6806886\",\n \"0.6637284\",\n \"0.6420833\",\n \"0.5987398\",\n \"0.5987398\",\n \"0.5987398\",\n \"0.59054685\",\n \"0.5809415\",\n \"0.5729596\",\n \"0.5698809\",\n \"0.5693551\",\n \"0.5631676\",\n \"0.561561\",\n \"0.561286\",\n \"0.56091833\",\n \"0.5602408\",\n \"0.56005305\",\n \"0.5592581\",\n \"0.55451244\",\n \"0.5470646\",\n \"0.5406517\",\n \"0.5383486\",\n \"0.5353251\",\n \"0.5348532\",\n \"0.53436226\",\n \"0.5337712\",\n \"0.53144467\",\n \"0.5309993\",\n \"0.5309897\",\n \"0.5306308\",\n \"0.52457654\",\n \"0.5236737\",\n \"0.5202982\",\n \"0.52005017\",\n \"0.51796734\",\n \"0.51786715\",\n \"0.5174165\",\n \"0.51371706\",\n \"0.5128458\",\n \"0.5128458\",\n \"0.51249343\",\n \"0.5116323\",\n \"0.51073706\",\n \"0.50953954\",\n \"0.50677377\",\n \"0.5060064\",\n \"0.50520927\",\n \"0.50467324\",\n \"0.50460625\",\n \"0.50378543\",\n \"0.5033081\",\n \"0.501999\",\n \"0.49968335\",\n \"0.49948907\",\n \"0.49768144\",\n \"0.49709585\",\n \"0.49643534\",\n \"0.49623796\",\n \"0.49598727\",\n \"0.49550888\",\n \"0.49493524\",\n \"0.4947857\",\n \"0.49467817\",\n \"0.49363193\",\n \"0.49349856\",\n \"0.49329215\",\n \"0.49316183\",\n \"0.49267006\",\n \"0.49223292\",\n \"0.4919613\",\n \"0.49093682\",\n \"0.48755422\",\n \"0.48742226\",\n \"0.4869546\",\n \"0.48627317\",\n \"0.48513812\",\n \"0.48493725\",\n \"0.48441952\",\n \"0.48428556\",\n \"0.48418027\",\n \"0.48347265\",\n \"0.48192167\",\n \"0.48152524\",\n \"0.48090863\",\n \"0.48071688\",\n \"0.48003054\",\n \"0.48002774\",\n \"0.47990933\",\n \"0.47919762\",\n \"0.4790654\",\n \"0.4783653\",\n \"0.4782526\",\n \"0.47735357\",\n \"0.4760217\",\n \"0.47464925\",\n \"0.4738815\",\n \"0.4730515\",\n \"0.4729926\",\n \"0.4714383\",\n \"0.47123384\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.58049566"},"document_rank":{"kind":"string","value":"8"}}},{"rowIdx":90498,"cells":{"query":{"kind":"string","value":"PID algorithm for anything"},"document":{"kind":"string","value":"def computePID(setpoint,\n _input, last_error, prev_time):\n kp = 0.5\n kd = 5\n ki = 0.02\n\n current_time = time.time()\n d_time = current_time - prev_time\n \n error = setpoint - _input\n #print(\"error\", error)\n\n #error_sum += (error * d_time)\n \n d_error = (error - last_error) / d_time\n\n output = kp * error #+ kd * d_error#ki * error_sum + kd * d_error\n last_error = error\n prev_time = current_time\n \n return output, last_error, prev_time"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def ppid(self):","def pid(self):","def pidGet(self) -> float:\n ...","def pidGet(self) -> float:\n ...","def inspire_pidstore():","def dynamic_pid(self):\n pass","def _update_PID(self):\n self.pid = PID(p=self.paramP, i=self.paramI, d=self.paramD, setpoint=self.voltageSetpoint, memory=self.paramMemory)","def _get_pid(split_data, sensor):\n prot, ip_dst, port_dst, timestamp = split_data\n prot = prot.lower()\n\n if not sanitizer.check_get_pid_params(prot, ip_dst, port_dst, timestamp):\n return '-1,error checking input'\n\n return sensor.search_process(prot, ip_dst, port_dst, timestamp)","def calculate_percid(\n pos_total, length_query, length_subject, length_total, option_pid=\"mean\"\n):\n if option_pid == \"mean\":\n pid = pos_total / ((length_query + length_subject) / 2.0)\n elif option_pid == \"subject\":\n pid = pos_total / length_subject\n elif option_pid == \"query\":\n pid = pos_total / length_query\n elif option_pid == \"shortest\":\n pid = pos_total / min(length_query, length_subject)\n elif option_pid == \"longest\":\n pid = pos_total / max(length_query, length_subject)\n elif option_pid == \"HSP\":\n pid = pos_total / length_total\n\n return pid","def test_pid_ccs2():\n d = trivariates['anddup']\n pid = PID_CCS(d, [[0], [1], [2]], [3])\n for atom in pid._lattice:\n if atom == ((0,), (1,), (2,)):\n assert pid[atom] == pytest.approx(0.10375937481971094)\n elif atom in [((0,), (2,)), ((1,),)]:\n assert pid[atom] == pytest.approx(0.20751874963942191)\n elif atom in [((2,), (0, 1)), ((0,), (1, 2)), ((0, 1), (0, 2)), ((0, 1), (1, 2)), ((0, 2), (1, 2)), ((0, 1, 2),)]:\n assert pid[atom] == pytest.approx(0.14624062518028902)\n elif atom in [((2,),), ((0,),), ((0, 1), (0, 2), (1, 2)), ((0, 2),)]:\n assert pid[atom] == pytest.approx(-0.14624062518028902)\n else:\n assert pid[atom] == pytest.approx(0.0)","def get_pid(self):\n return self.k_p, self.k_i, self.k_d","def first_part_pid(self,text,pid):\n\n len_max=4\n key_list=pid.keys()\n while 1:\n num=min(len_max,len(text))\n if len_max==0:\n sys.exit('error pid dico not complete or invalid input :'+str([text[:min(3,len(text))]])+'\\\n \\n Complete proc_info.py')\n \n if text[:num].lower() in key_list:\n tag=text[:num].lower()\n text=text[num:]\n return text, pid[tag]\n else:\n len_max+=-1","def test_pid_ccs3():\n d = trivariates['anddup']\n pid = PID_CCS(d)\n for atom in pid._lattice:\n if atom == ((0,), (1,), (2,)):\n assert pid[atom] == pytest.approx(0.10375937481971094)\n elif atom in [((0,), (2,)), ((1,),)]:\n assert pid[atom] == pytest.approx(0.20751874963942191)\n elif atom in [((2,), (0, 1)), ((0,), (1, 2)), ((0, 1), (0, 2)), ((0, 1), (1, 2)), ((0, 2), (1, 2)), ((0, 1, 2),)]:\n assert pid[atom] == pytest.approx(0.14624062518028902)\n elif atom in [((2,),), ((0,),), ((0, 1), (0, 2), (1, 2)), ((0, 2),)]:\n assert pid[atom] == pytest.approx(-0.14624062518028902)\n else:\n assert pid[atom] == pytest.approx(0.0)","def pass_in_pid(self,process_line,multi):\n \n ParticlesFile=Card('./Source/MODEL/particles.dat')\n pid=ParticlesFile.give_pid_dict()\n \n #\n # Update information with multi_particle tag\n #\n for couple in multi.items():\n text=couple[1]\n tag=couple[0]\n pid_list=[]\n len_max=3\n key_list=pid.keys()\n while text:\n text,add=self.first_part_pid(text,pid)\n pid_list+=add\n\n pid.update({tag:pid_list})\n\n\n\n #\n # pid list is now complete\n # convert line in decay pid information\n decay_rule=[]\n #1) take only the decay part:\n for letter in ['$','\\\\','@','#','\\n']:\n if letter in process_line:\n process_line=process_line[:process_line.index(letter)]\n break # only one such symbol to signify the end of the decay part\n process_line=process_line[process_line.index('>')+1:]\n\n \n decay_diag=[]\n level_decay=0\n while process_line:\n if process_line[0]==' ':\n process_line=process_line[1:]\n continue\n if process_line[0]=='>':\n process_line=process_line[1:]\n continue \n\n if process_line[0]=='(':\n process_line=process_line[1:]\n level_decay+=1\n new_decay=1\n continue\n \n if process_line[0]==')':\n level_decay-=1\n current_part=current_part.mother\n process_line=process_line[1:]\n continue\n\n\n process_line,pid_content=self.first_part_pid(process_line,pid)\n\n if level_decay==0 or (level_decay==1 and new_decay):\n new_decay=0\n part=Proc_decay(pid_content)\n decay_diag.append(part)\n current_part=part\n elif new_decay:\n new_decay=0\n part=current_part.add_desint(pid_content) #return new part\n current_part=part\n else:\n current_part.add_desint(pid_content)\n\n\n return decay_diag","def _PIDController__calculate(self): \n \n\t\tenabled = self.m_enabled\n\t\tpidInput = self.m_pidInput\n\n\t\tif enabled:\n\n\t\t input = pidInput.PIDGet()\n\n\t\t self.m_error = self.m_setpoint - input\n\t\t if self.m_continuous:\n\t\t \n\t\t if math.fabs(self.m_error) > (self.m_maximumInput - self.m_minimumInput) / 2:\n\t\t if self.m_error > 0:\n\t\t self.m_error = self.m_error - self.m_maximumInput + self.m_minimumInput\n\t\t else:\n\t\t self.m_error = self.m_error + self.m_maximumInput - self.m_minimumInput\n\n\t\t potentialIGain = (self.m_totalError + self.m_error) * self.m_I\n\t\t \n\t\t if potentialIGain < self.m_maximumOutput:\n\t\t if potentialIGain > self.m_minimumOutput:\n\t\t self.m_totalError += self.m_error\n\t\t else:\n\t\t self.m_totalError = self.m_minimumOutput / self.m_I\n\t\t else:\n\t\t self.m_totalError = self.m_maximumOutput / self.m_I\n\n\t\t self.m_result = self.m_P * self.m_error + self.m_I * self.m_totalError + self.m_D * (self.m_error - self.m_prevError)\n\t\t self.m_prevError = self.m_error\n\n\t\t if self.m_result > self.m_maximumOutput:\n\t\t self.m_result = self.m_maximumOutput\n\t\t elif self.m_result < self.m_minimumOutput:\n\t\t self.m_result = self.m_minimumOutput\n\n\t\t pidOutput = self.m_pidOutput\n\t\t result = self.m_result","def pid():\n return 0x0204","def pid():\n return 0x0204","def get_pid(packet):\n return ((ord(packet[TS.PID_START_INDEX]) & 0x1f)<<8) | ord(packet[TS.PID_START_INDEX+1])","def get_seq_ppi(filename):\n with open(filename) as file:\n #return get_pairs(file)\n p= get_Ps(file)\n pp = p[0]\n ppid = get_ppi(pp)\n return ppid","def detect_instance_pids(self):\n for instance in self.all_instances:\n instance.detect_pid(\n ppid=self.instance.pid,\n full_binary_path=self.cfg.real_sbin_dir,\n offset=0,\n )\n\n self.show_all_instances()\n self.detect_arangosh_instances(self.cfg, self.cfg.version)","def pidHTTPd(htconf):\n# pcmd = \"/bin/ps -ef|/bin/grep \" + htconf + \"|/bin/grep -v grep|/bin/awk '{print $3}'|sort -u\"\n# pcmd = '/bin/ps -ef'\n# pcmd = 'ps -eo pid,ppid,rss,vsize,pcpu,pmem,cmd -ww --sort=pid'\n pcmd = 'ps -eo pid,ppid,rss,cmd'\n# produces something like the following (when selecting htconf == httpd.conf99)\n#30645 1 4420 /devstore/apache2/bin/httpd -f /devstore/apache2/conf/httpd.conf99\n#30646 30645 1640 /devstore/apache2/bin/httpd -f /devstore/apache2/conf/httpd.conf99\n#30647 30645 2628 /devstore/apache2/bin/fcgi- -f /devstore/apache2/conf/httpd.conf99\n#30648 30645 37216 /devstore/apache2/bin/httpd -f /devstore/apache2/conf/httpd.conf99\n#30649 30645 3064 /devstore/apache2/bin/httpd -f /devstore/apache2/conf/httpd.conf99\n#30650 30645 3064 /devstore/apache2/bin/httpd -f /devstore/apache2/conf/httpd.conf99\n#30651 30645 3064 /devstore/apache2/bin/httpd -f /devstore/apache2/conf/httpd.conf99\n#30652 30645 3064 /devstore/apache2/bin/httpd -f /devstore/apache2/conf/httpd.conf99\n#30656 30645 3064 /devstore/apache2/bin/httpd -f /devstore/apache2/conf/httpd.conf99\n# the 3rd column is ram util. in units of kbytes, kill the entire set of httpd pids\n# (by killing parent proc) if any one thread exceeds 1,000,000 kbytes (> 1gb)\n pid = os.popen(pcmd, \"r\")\n ppids = [] ; pids = [] ; memuse = [] ; vals = [] \n parentpid = -1\n restart = False\n try:\n for p in pid.xreadlines():\n p.rstrip()\n vals = p.split()\n conf = vals[-1] # last val should be confile\n try:\n if conf.index(htconf) >= 0 :\n pids.append(int(vals[0]))\n ppids.append(int(vals[1]))\n memuse.append(int(vals[2])) \n# print >> FileKeyUtils.WMSlog, 'pidHTTPd> pids: ', pids, ', ppids: ', ppids, ' memuse: ', memuse\n if int(vals[1]) == 1 : parentpid = int(vals[0])\n if int(vals[2]) > 1000000 : restart = True\n except:\n# print >> FileKeyUtils.WMSlog, 'pidHTTPd> vals: ', vals\n pass\n except: pass\n\n print >> FileKeyUtils.WMSlog, 'pidHTTPd>', htconf, ' parentpid:', parentpid, ', memuse:', memuse\n if restart: # return parentpid\n return parentpid\n\n return -1","def __init__(self):\n self.pidDict = { # particle_name, pid\n \"total\" : 0,\n \"charged\" : 1,\n \"charged_eta\" : 2,\n \"pion\" : 6, # sum(7, 8, -7)\n \"pion_p\" : 7,\n \"pion_0\" : 8,\n \"pion_m\" : -7,\n \"kaon\" : 11, # sum(12, 13)\n \"kaon_p\" : 12,\n \"kaon_0\" : 13,\n \"anti_kaon\" : -11, # sum(-12, -13)\n \"kaon_m\" : -12,\n \"anti_kaon_0\" : -13,\n \"nucleon\" : 16, # sum(17, 18)\n \"proton\" : 17,\n \"neutron\" : 18,\n \"anti_nucleon\" : -16, # sum(-17, -18)\n \"anti_proton\" : -17,\n \"anti_neutron\" : -18,\n \"sigma\" : 21, # sum(22, 23, 24)\n \"sigma_p\" : 22,\n \"sigma_0\" : 23,\n \"sigma_m\" : 24,\n \"anti_sigma\" : -21,\n \"anti_sigma_p\" : -22,\n \"anti_sigma_0\" : -23,\n \"anti_sigma_m\" : -24,\n \"xi\" : 26, # sum(27, 28)\n \"xi_0\" : 27,\n \"xi_m\" : 28,\n \"anti_xi\" : -26,\n \"anti_xi_0\" : -27,\n \"anti_xi_m\" : -28,\n \"lambda\" : 31,\n \"anti_lambda\" : -31,\n \"omega\" : 36,\n \"anti_omega\" : -36,\n \"phi\" : 41,\n \"rho\" : 46, #sum(47, 48, -47)\n \"rho_p\" : 47,\n \"rho_0\" : 48,\n \"rho_m\" : -47,\n \"eta\" : 51,\n \"eta_prime\" : 52,\n \"gamma\" : 61,\n \"omega782\" : 65,\n \"eta\" : 71,\n \"etap\" : 72,\n }\n\n for aParticle in self.pidDict.keys():\n if self.pidDict[aParticle]>=0:\n self.pidDict[aParticle+\"_hydro\"] = self.pidDict[aParticle]+1000\n else:\n self.pidDict[aParticle+\"_hydro\"] = self.pidDict[aParticle]-1000\n if self.pidDict[aParticle]>=0:\n self.pidDict[aParticle+\"_thermal\"] = self.pidDict[aParticle]+2000\n else:\n self.pidDict[aParticle+\"_thermal\"] = self.pidDict[aParticle]-2000\n\n self.pidDict.update({\n \"photon_total\" : 9000,\n \"photon_total_eq\" : 9001,\n \"photon_QGP_tot\" : 9002,\n \"photon_QGP_eq\" : 9003,\n \"photon_HG_tot\" : 9004,\n \"photon_HG_eq\" : 9005,\n \"direct_gamma_shortdecay_hydro\" : 9006,\n \"decay_gamma_pi0_hydro\" : 9007,\n \"decay_gamma_eta_hydro\" : 9008,\n \"decay_gamma_omega_hydro\" : 9009,\n \"decay_gamma_phi_hydro\" : 9010,\n \"decay_gamma_etap_hydro\" : 9011,\n \"decay_gamma_Sigma0_hydro\" : 9012,\n })\n\n #UrQMD pid Dictionary, name conversion defined as in binUtility\n self.UrQMDpidDict = { #particle name, UrQMD id# : isospin*2000 + pid\n 2101 : \"pion_p\",\n -1899 : \"pion_m\",\n 101 : \"pion_0\",\n 1106 : \"kaon_p\",\n -894 : \"kaon_0\",\n -1106 : \"kaon_m\",\n 894 : \"anti_kaon_0\",\n 1001 : \"proton\",\n -999 : \"neutron\",\n -1001 : \"anti_proton\",\n 999 : \"anti_neutron\",\n 2040 : \"sigma_p\",\n -1960 : \"sigma_m\",\n 40 : \"sigma_0\",\n -2040 : \"anti_sigma_p\",\n 1960 : \"anti_sigma_m\",\n -40 : \"anti_sigma_0\",\n 1049 : \"xi_0\",\n -951 : \"xi_m\",\n -1049 : \"anti_xi_0\",\n 951 : \"anti_xi_m\",\n 27 : \"lambda\",\n -27 : \"anti_lambda\",\n 55 : \"omega\",\n -55 : \"anti_omega\",\n 109 : \"phi\",\n 102 : \"eta\",\n 107 : \"eta_prime\",\n 100 : \"gamma\",\n }\n\n #pdg pid Dictionary\n self.PDGpidDict = { #pdg id#, particle name\n 211 : \"pion_p\",\n -211 : \"pion_m\",\n 111 : \"pion_0\",\n 321 : \"kaon_p\",\n 311 : \"kaon_0\",\n -321 : \"kaon_m\",\n -311 : \"anti_kaon_0\",\n 2212 : \"proton\",\n 2112 : \"neutron\",\n -2212 : \"anti_proton\",\n -2112 : \"anti_neutron\",\n 3222 : \"sigma_p\",\n 3112 : \"sigma_m\",\n 3212 : \"sigma_0\",\n -3222 : \"anti_sigma_p\",\n -3112 : \"anti_sigma_m\",\n -3212 : \"anti_sigma_0\",\n 3322 : \"xi_0\",\n 3312 : \"xi_m\",\n -3322 : \"anti_xi_0\",\n -3312 : \"anti_xi_m\",\n 3122 : \"lambda\",\n -3122 : \"anti_lambda\",\n 3334 : \"omega\",\n -3334 : \"anti_omega\",\n 333 : \"phi\",\n 221 : \"eta\",\n 331 : \"eta_prime\",\n 22 : \"gamma\",\n }\n\n #particle mass Dictionary (unit in GeV)\n self.masspidDict = {\n \"pion\" : 0.13957,\n \"pion_p\" : 0.13957,\n \"pion_0\" : 0.13498,\n \"pion_m\" : 0.13957,\n \"kaon\" : 0.49368,\n \"kaon_p\" : 0.49368,\n \"kaon_0\" : 0.49765,\n \"anti_kaon\" : 0.49368,\n \"kaon_m\" : 0.49368,\n \"anti_kaon_0\" : 0.49765,\n \"nucleon\" : 0.93827,\n \"proton\" : 0.93827,\n \"neutron\" : 0.93957,\n \"anti_nucleon\" : 0.93827,\n \"anti_proton\" : 0.93827,\n \"anit_neutron\" : 0.93957,\n \"sigma\" : 1.18937,\n \"sigma_p\" : 1.18937,\n \"sigma_0\" : 1.19264,\n \"sigma_m\" : 1.19745,\n \"anti_sigma\" : 1.18937,\n \"anti_sigma_p\" : 1.18937,\n \"anti_sigma_0\" : 1.19264,\n \"anti_sigma_m\" : 1.19745,\n \"xi\" : 1.31483,\n \"xi_0\" : 1.31483,\n \"xi_m\" : 1.32131,\n \"anti_xi\" : 1.31483,\n \"anti_xi_0\" : 1.31483,\n \"anti_xi_m\" : 1.32131,\n \"lambda\" : 1.11568,\n \"anti_lambda\" : 1.11568,\n \"omega\" : 1.67243,\n \"anti_omega\" : 1.67243,\n \"rho\" : 0.77580,\n \"rho_p\" : 0.77580,\n \"rho_0\" : 0.77580,\n \"rho_m\" : 0.77580,\n \"phi\" : 1.01946,\n \"eta\" : 0.54775,\n \"eta_prime\" : 0.95778,\n \"gamma\" : 0.0,\n }\n for aParticle in self.masspidDict.keys():\n self.masspidDict[aParticle+\"_hydro\"] = self.masspidDict[aParticle]\n self.masspidDict[aParticle+\"_thermal\"] = self.masspidDict[aParticle]\n\n # charged hadrons list\n self.charged_hadron_list = [\n \"pion_p\", \"pion_m\", \"kaon_p\", \"kaon_m\", \"proton\", \"anti_proton\",\n \"sigma_p\", \"sigma_m\", \"anti_sigma_p\", \"anti_sigma_m\",\n \"xi_m\", \"anti_xi_m\"]","def _PIDController__calculate(self): \n \n\t\tenabled = self.m_enabled\n\t\tpidInput = self.m_pidInput\n\t\tpidInput2 = self.source2\n\n\t\tif enabled:\n\n\t\t input = pidInput.PIDGet() - pidInput2.PIDGet()\n\n\t\t self.m_error = self.m_setpoint - input\n\t\t if self.m_continuous:\n\t\t \n\t\t if math.fabs(self.m_error) > (self.m_maximumInput - self.m_minimumInput) / 2:\n\t\t if self.m_error > 0:\n\t\t self.m_error = self.m_error - self.m_maximumInput + self.m_minimumInput\n\t\t else:\n\t\t self.m_error = self.m_error + self.m_maximumInput - self.m_minimumInput\n\n\t\t potentialIGain = (self.m_totalError + self.m_error) * self.m_I\n\t\t \n\t\t if potentialIGain < self.m_maximumOutput:\n\t\t if potentialIGain > self.m_minimumOutput:\n\t\t self.m_totalError += self.m_error\n\t\t else:\n\t\t self.m_totalError = self.m_minimumOutput / self.m_I\n\t\t else:\n\t\t self.m_totalError = self.m_maximumOutput / self.m_I\n\n\t\t self.m_result = self.m_P * self.m_error + self.m_I * self.m_totalError + self.m_D * (self.m_error - self.m_prevError)\n\t\t self.m_prevError = self.m_error\n\n\t\t if self.m_result > self.m_maximumOutput:\n\t\t self.m_result = self.m_maximumOutput\n\t\t elif self.m_result < self.m_minimumOutput:\n\t\t self.m_result = self.m_minimumOutput\n\n\t\t pidOutput = self.m_pidOutput\n\t\t result = self.m_result","def genPID(toHash):\n sha256 = getSHA256Hex(toHash)\n pid = sha256[0:32]\n return pid","def put_pid(html):\n pid = 1\n while \"<p>\" in html:\n pttn = \"<p id=\\\"p\"+str(pid)+\"\\\">\"\n html = html.replace(\"<p>\", pttn, 1)\n pid += 1\n return html","def find_prod_ids(dist_list, no_prod):\n list_of_prod = []\n for worker in dist_list:\n\n if len(list_of_prod) < no_prod:\n list_of_prod.append(worker)\n\n else:\n\n for i in list_of_prod:\n\n if i[1] > worker[1]:\n list_of_prod.remove(i)\n list_of_prod.append(worker)\n worker = i\n\n else:\n\n continue\n PIDs = []\n for i in list_of_prod:\n PIDs.append(i[0])\n PIDs.sort()\n return (PIDs)","def test_pid_ccs1():\n d = bivariates['gband']\n pid = PID_CCS(d, ((0,), (1,)), (2,))\n assert pid[((0,), (1,))] == pytest.approx(0.81127812445913283)\n assert pid[((0,),)] == pytest.approx(0.5)\n assert pid[((1,),)] == pytest.approx(0.5)\n assert pid[((0, 1),)] == pytest.approx(0.0)","def getmypid():\n raise NotImplementedError()","def _translate_line_to_pid_pair(self, line):","def pidof(process_name):\n\n\tpids = []\n\n\tif 'licornd' in process_name:\n\t\t# licorn / linux 3.x specifiq : we can match 'licornd/wmi'\n\t\t# faster than 'licornd-wmi', and in some case the 'cmdline'\n\t\t# is empty, whereas the 'comm' is not.\n\t\tnames = [ process_name, process_name.replace('/', '-') ]\n\n\telse:\n\t\tnames = [ process_name ]\n\n\tfor entry in os.listdir('/proc'):\n\t\tif entry.isdigit():\n\t\t\ttry:\n\n\t\t\t\tif cgroup and open('/proc/%s/cpuset' % entry).read().strip() != cgroup:\n\t\t\t\t\tlogging.progress(_(u'Skipped process @{0} which is not '\n\t\t\t\t\t\t\t\t\t\tu'in the same cgroup.').format(entry))\n\t\t\t\t\tcontinue\n\n\t\t\t\ttry:\n\t\t\t\t\t# Linux 3.x only\n\t\t\t\t\tcommand_line1 = open('/proc/%s/comm' % entry).read().strip()\n\t\t\t\texcept:\n\t\t\t\t\tcommand_line1 = ''\n\n\t\t\t\tcommand_line2 = open('/proc/%s/cmdline' % entry).read().strip()\n\n\t\t\t\tfor pname in names:\n\t\t\t\t\tif pname == command_line1 or pname+'\\0' in command_line2:\n\t\t\t\t\t\tpids.append(int(entry))\n\n\t\t\texcept (IOError, OSError), e:\n\t\t\t\t# in rare cases, the process vanishes during iteration. This\n\t\t\t\t# is harmless. Any other error is not cool, raise it.\n\t\t\t\tif e.errno != errno.ENOENT:\n\t\t\t\t\traise e\n\n\treturn pids","def usePIDOutput(self, output):\n self.motor.pidWrite(output)","def IDCG_p(topic, p):\n lbl_scores = gold_topic_labels[topic].items() # (label, score) list\n top_p = sorted(lbl_scores, key=lambda x: x[1], reverse=True)[:p]\n idcg = 0\n for idx, (label, rel) in enumerate(top_p):\n rank = idx + 1\n if idx == 0:\n idcg += rel\n continue\n idcg += rel/ math.log(rank,2)\n return idcg","def test_pid_ig1():\n d = bivariates['and']\n pid = PID_IG(d, ((0,), (1,)), (2,))\n assert pid[((0,), (1,))] == pytest.approx(0.08283, abs=1e-4)\n assert pid[((0,),)] == pytest.approx(0.22845, abs=1e-4)\n assert pid[((1,),)] == pytest.approx(0.22845, abs=1e-4)\n assert pid[((0, 1),)] == pytest.approx(0.27155, abs=1e-4)","def myID() -> np.int:\r\n return 304976335","def myID() -> np.int:\r\n return 304976335","def GenDistinctId(self):\t\n \"\"\"4 bits to unique a machine \\\n\t5 bits for processes\"\"\"\n\tmachineId = format(self.mid, 4)\n processId = format(self.pid) \n \treturn machineId + processId","def _pid(self, name):\n return self.pid_lookup[name]","def process_id(job_id):\n pass # Not implemented yet","def process():","def pids():\n stream = os.popen(\"ps aux | grep '[m]itm' | awk '{print $2}'\")\n return stream.read()","def pid(self):\n\t\treturn self.__pid","def findPIDs(name, user = os.getpid()):\n\n pids = []\n\n ps = subprocess.Popen(['ps', '-u', user, 'w'], stdout=subprocess.PIPE).communicate()[0]\n processes = ps.split('\\n')\n\n for line in processes:\n if len(line.split()) < 5:\n continue\n if re.match(name, line.split()[4]):\n #Then we have matching process\n pids.append(line.split()[0])\n\n return pids","def get_num_pids(self, data):\n return self.parse_data(data)[0]","def pid(self, drive, p=None, i=None, d=None):\n if p is None:\n # get proportional band\n self.__ser__.write(\"RP{}\\r\".format(drive).encode())\n self.__ser__.flush()\n p = str2float(self.__ser__.read_until('\\r'))\n else:\n # set proportional band\n self.__ser__.write(\"SP{} {}\\r\".format(drive, p).encode())\n self.__ser__.flush()\n p = self.rcvd_ok()\n if i is None:\n # get integral band\n self.__ser__.write(\"RI{}\\r\".format(drive).encode())\n self.__ser__.flush()\n i = str2float(self.__ser__.read_until('\\r'))\n else:\n # set integral band\n self.__ser__.write(\"SI{} {}\\r\".format(drive, i).encode())\n self.__ser__.flush()\n i = self.rcvd_ok()\n if d is None:\n # get derivative band\n self.__ser__.write(\"RD{}\\r\".format(drive).encode())\n self.__ser__.flush()\n d = str2float(self.__ser__.read_until('\\r'))\n else:\n # set derivative band\n self.__ser__.write(\"SD{} {}\\r\".format(drive, d).encode())\n self.__ser__.flush()\n d = self.rcvd_ok()\n return((p, i, d))","def test_pid_proj2():\n d = bivariates['reduced or']\n pid = PID_IG(d, [[0], [1]], [2])\n assert pid[((0,), (1,))] == pytest.approx(-0.03122, abs=1e-4)\n assert pid[((0,),)] == pytest.approx(0.34250, abs=1e-4)\n assert pid[((1,),)] == pytest.approx(0.34250, abs=1e-4)\n assert pid[((0, 1),)] == pytest.approx(0.34622, abs=1e-4)","def ppid(self):\n return self._ppid","def get_pids(self, file_path, pid):\n if 'cuhk03' in file_path: \n prefix = 'cuhk'\n else: \n prefix = file_path.split('/')[1]\n return prefix + '_' + str(pid)","def runPidGen ( tree , ## initial tree/chain to be updated \n pidgen , ## PidGen object \n newpid , ## name of new PID variable \n seed = None , ## random seed\n silent = False , ## silent ?\n variants = False , ## add alterbvative models?\n parallel = False , ## use parallel processing?\n **kwargs ) : ## arguments for parallel processing (WorkManager)\n\n assert isinstance ( tree , ROOT.TTree ) and tree , \"Invalid 'tree' argument!\"\n assert isinstance ( pidgen , PidGen ) , \"Invalid 'pidgen' argument!\"\n\n assert not newpid in tree.branches() ,\"`Branch' %s already exists!\" % newpid \n\n old_branches = set ( tree.branches() ) | set ( tree.leaves() )\n\n\n ## parallel processing?\n if parallel and isinstance ( tree , ROOT.TChain ) and 1 < len ( tree.files() ) :\n \n from ostap.trees.trees import Chain\n ch = Chain ( tree ) \n cname = tree.name\n \n ## create the task \n task = AddPidGen ( newpid = newpid ,\n pidgen = pidgen ,\n seed = seed ,\n variants = variants )\n \n wmgr = WorkManager ( silent = silent , **kwargs )\n trees = ch.split ( max_files = 1 )\n \n wmgr.process ( task , trees )\n \n new_chain = ROOT.TChain ( cname )\n for f in ch.files : new_chain.Add ( f )\n \n ## sequential processing \n else :\n\n if kwargs :\n logger.warning ( \"runPidGen: ignore arguments : %s\" % [ k for k in kwargs.keys( ) ] )\n \n from ostap.utils.utils import root_random_seed\n with root_random_seed ( seed ) :\n \n from ostap.math.make_fun import make_fun3\n the_function = ( make_fun3 ( pidgen ) , \n pidgen.pt_log_var ,\n pidgen.eta_var ,\n pidgen.ntrk_log_var )\n \n ## add new branch \n new_chain = tree.add_new_branch ( newpid ,\n the_function , \n verbose = not silent ,\n report = False )\n \n if variants : \n vars = pidgen.variants ()\n for var in progress_bar ( vars , silent = silent , description = ' %+d variants:' % len ( vars ) ) : \n varpg = PidGen ( pt_log_var = pidgen.pt_log_var ,\n eta_var = pidgen.eta_var ,\n ntrk_log_var = pidgen.ntrk_log_var ,\n config = pidgen.config ,\n dataset = pidgen.dataset ,\n variant = var ,\n silent = True )\n ## add new variable \n new_chain = runPidGen ( new_chain ,\n varpg ,\n '%s_%s' % ( newpid , var ) ,\n seed = seed ,\n silent = True ,\n variants = False ) \n ## final summary table \n if not silent :\n \n title = 'PidGen(%s): configuration&statistics' % pidgen.variant \n logger.info ( '%s:\\n%s' % ( title , pidgen.table ( title , prefix = '# ' ) ) )\n\n new_branches = set ( new_chain.branches() ) | set ( new_chain.leaves() )\n new_branches = new_branches - old_branches\n if new_branches :\n n = len ( new_branches )\n if 1 == n : title = 'Added %s branch to TTree/TChain' % n \n else : title = 'Added %s branches to TTree/TChain' % n \n table = new_chain.table ( new_branches , title = title , prefix = '# ' )\n logger.info ( '%s:\\n%s' % ( title , table ) ) \n \n return new_chain","def get_PID(self):\n return self.PID","def process():\n interesting_procs = set(INTERESTING_PROCESSES)\n\n pids = psutil.pids()\n info = {\n \"stats_type\": \"process\",\n \"proc\": {\n \"count\": len(pids),\n }\n }\n proc_root = os.environ.get(\"PROC_ROOT\", \"/proc\")\n for pid in pids:\n proc_info = proc.core.Process.from_path(\n os.path.join(proc_root, str(pid)))\n\n proc_name = get_proc_name(proc_info, interesting_procs)\n if not proc_name:\n continue\n\n if 'sshd' in proc_name and ':' in proc_info.cmdline:\n continue\n\n if proc_name not in info['proc']:\n info['proc'][proc_name] = {\n 'running': proc_info.state in ('R', 'S', 'D', 'T', 'W'),\n 'pid': proc_info.pid,\n 'ppid': proc_info.ppid,\n 'user_time': int(proc_info.stat_fields[16]), # cutime\n 'sys_time': int(proc_info.stat_fields[17]), # cstime\n 'vsize': proc_info.vsize,\n 'rss': proc_info.rss,\n 'voluntary_ctxt_switches': int(proc_info.status_fields[\n 'voluntary_ctxt_switches']),\n 'nonvoluntary_ctxt_switches': int(proc_info.status_fields[\n 'nonvoluntary_ctxt_switches']),\n 'age': proc_info.runtime,\n 'count': 1\n }\n else:\n pinfo = info['proc'][proc_name]\n pinfo['count'] += 1\n\n def append(dest, field, value):\n \"\"\"Append values for an existing process.\"\"\"\n if isinstance(dest[field], list):\n dest[field].append(value)\n else:\n dest[field] = [dest[field], value]\n\n # append('state', proc_info.state)\n append(pinfo, 'pid', proc_info.pid)\n append(pinfo, 'ppid', proc_info.ppid)\n pinfo['user_time'] += int(proc_info.stat_fields[16]) # cutime\n pinfo['sys_time'] += int(proc_info.stat_fields[17]) # cstime\n pinfo['vsize'] += proc_info.vsize\n pinfo['rss'] += proc_info.rss\n pinfo['voluntary_ctxt_switches'] = \\\n int(proc_info.status_fields['voluntary_ctxt_switches'])\n pinfo['nonvoluntary_ctxt_switches'] = \\\n int(proc_info.status_fields['nonvoluntary_ctxt_switches'])\n append(pinfo, 'age', proc_info.runtime)\n\n return info","def ews_pid (tag):\n\n return mapitags.PROP_ID(tag)","def PIDs():\n from ctypes import windll,c_ulong,byref,sizeof\n PIDs = (c_ulong*512)()\n size_of_PIDs = c_ulong()\n windll.psapi.EnumProcesses(byref(PIDs),sizeof(PIDs),byref(size_of_PIDs))\n nPIDs = size_of_PIDs.value/sizeof(c_ulong())\n pidProcess = sorted([int(i) for i in PIDs][:nPIDs])\n return pidProcess","def pid_controller_calculator(pid_parameters, error, duration=0.17):\n k_p = pid_parameters[0]\n k_i = pid_parameters[1]\n k_d = pid_parameters[2]\n error = np.array(error)\n proportional_term = k_p * error[-1]\n integrational_term = k_i * duration * np.sum(error)\n differential_term = k_d * (error[-1] - error[-2]) / duration\n output = np.sqrt(\n (proportional_term + integrational_term + differential_term) * 22)\n return output","def get_process_speed(self, pid):\n raise NotImplementedError()","def get_pid(name):\n try: \n for process in psutil.process_iter():\n try:\n proc = process.as_dict(attrs=['pid', 'name'])\n if name in proc['name']:\n pid = proc['pid']\n logging.info(f\"Found PID {pid} for {name}\")\n return int(pid) \n except (psutil.NoSuchProcess, psutil.AccessDenied , psutil.ZombieProcess) :\n pass \n except Exception as e:\n logging.exception(f\"EXCEPTION: {e} \\n Full stack trace: \\n\", exc_info=1)","def frequency(self, pt):\n return math.floor(abs(self.id - pt.id) / 2)","def def_pid(self,pid):\n self.pid=int(pid)","def sub_processor(lock, pid, video_list):\r\n text = 'processor %d' % pid\r\n with lock:\r\n progress = tqdm.tqdm(\r\n total=len(video_list),\r\n position=pid,\r\n desc=text\r\n )\r\n for i in range(len(video_list)):\r\n video_name = video_list[i]\r\n \"\"\" Read result csv file \"\"\"\r\n df = pd.read_csv(os.path.join(config.post_csv_load_dir, video_name + \".csv\"))\r\n \"\"\" Calculate final score of proposals \"\"\"\r\n df['score'] = df.iou.values[:] * df.start.values[:] * df.end.values[:]\r\n if len(df) > 1:\r\n df = softNMS(df)\r\n df = df.sort_values(by=\"score\", ascending=False)\r\n video_info = video_dict[video_name]\r\n video_duration = video_info[\"duration_second\"]\r\n proposal_list = []\r\n\r\n for j in range(min(top_number, len(df))):\r\n tmp_proposal = {}\r\n tmp_proposal[\"score\"] = df.score.values[j]\r\n tmp_proposal[\"segment\"] = [max(0, df.xmin.values[j]) * video_duration,\r\n min(1, df.xmax.values[j]) * video_duration]\r\n tmp_proposal[\"label\"] = \"行走\"\r\n # tmp_proposal[\"label\"] = \"Fun sliding down\"\r\n proposal_list.append(tmp_proposal)\r\n result_dict[video_name] = proposal_list\r\n with lock:\r\n progress.update(1)\r\n\r\n with lock:\r\n progress.close()","def get_pids(self, file_path, pid):\n if 'cuhk03' in file_path:\n prefix = 'cuhk'\n else:\n prefix = file_path.split('/')[1]\n return prefix + '_' + str(pid)","def pidof(processname = None):\n processname = os.path.basename(processname)\n pidpath = os.path.join(pid_path,processname + \".pid\")\n if processname is not None and os.path.exists(pidpath):\n f = open (pidpath)\n pids = f.readlines()\n f.close()\n return pids\n else:\n return False","def get_pids(pid):\n\n pids=set([pid])\n for child in get_children(pid):\n pids.update(traverse_tree(child,pids))\n \n return list(pids)","def get_pid_processor(pid):\n if pid != 0:\n pid_str = pid\n else:\n pid_str = 'self'\n\n # read procfs /proc/PID/stat file to get info about processor\n # that PID was scheduled on last time\n try:\n with open(\"/proc/{}/stat\".format(pid_str)) as stat_file:\n proc_stat = stat_file.readline().strip().split(' ')\n return int(proc_stat[39])\n except EnvironmentError:\n return -1","def getPMid(inF, i):\n\n return inF.root.Sensors.DataPMT[i][0]","def update_pid_running_on_dpdk_cpu(self):\n #cpu_list = self.get_cpu_list_by_mask","def _get_pid(self):\n ps_txt = six.ensure_str(self.controller.run(\n args=[\"ps\", \"ww\", \"-u\"+str(os.getuid())]\n ).stdout.getvalue()).strip()\n lines = ps_txt.split(\"\\n\")[1:]\n\n for line in lines:\n if line.find(\"ceph-{0} -i {1}\".format(self.daemon_type, self.daemon_id)) != -1:\n log.info(\"Found ps line for daemon: {0}\".format(line))\n return int(line.split()[0])\n log.info(\"No match for {0} {1}: {2}\".format(\n self.daemon_type, self.daemon_id, ps_txt\n ))\n return None","def worker(nums, outdict):\n print(threading.current_thread().name)\n print (\"pid:\", os.getpid())\n for n in nums:\n outdict[n] = factorize_naive(n)","def run_numbers():\n if run_nos:\n # Get task names\n tasks = []\n for rn in dcm_dict.keys():\n tasks.append(dcm_dict[rn]['task_name'])\n # Assign run numbers\n for tsk in set(tasks):\n n_runs = sum(i == tsk for i in tasks)\n if n_runs == 1:\n for rn in dcm_dict.keys():\n if dcm_dict[rn]['task_name'] == tsk:\n # Add in the 'task' prefix required by BIDS format if missing from name\n if not tsk[0:4] == 'task':\n dcm_dict[rn]['out_name'] = 'task-'+tsk+'_run-01'\n else:\n dcm_dict[rn]['out_name'] = tsk+'_run-01'\n elif n_runs > 1:\n task_runs = []\n run_times = []\n for rn in dcm_dict.keys():\n if dcm_dict[rn]['task_name'] == tsk:\n task_runs.append(rn)\n run_times.append(dcm_dict[rn]['start_time'].timestamp())\n idx_order = sorted(range(len(run_times)), key=lambda k: run_times[k])\n for i in idx_order:\n if not tsk[0:4] == 'task':\n dcm_dict[task_runs[i]]['out_name'] = 'task-'+tsk+'_run-0'+str(i+1)\n else:\n dcm_dict[task_runs[i]]['out_name'] = tsk+'_run-0'+str(i+1)\n else:\n for rn in dcm_dict.keys():\n dcm_dict[rn]['out_name'] = dcm_dict[rn]['task_name']","def get_cpu_clock_cycles_of_pid(pid):\n try:\n with open(LINUX_PROCESS_STAT_LOCATION % pid, 'r') as f:\n pid_entries = f.read().split(' ')\n except IOError:\n return None\n\n pid_cycles = 0\n if len(pid_entries) > 14:\n pid_cycles = int(pid_entries[13]) + int(pid_entries[14])\n return pid_cycles","def set_pid(self, pid): # type: (int) -> None\n for i in range(len(self.__target_pids)):\n if self.__target_pids[i] == \"$$TBD\":\n self.__target_pids[i] = pid\n break","def to_id_matrix(f):\n if path.isfile(\"data/\"+f+\".npy\"):\n return 0\n \n # Get a worker number to position the progress bar\n global idxQueue\n thr_idx = idxQueue.get()\n\n setproctitle(f\"RNANet statistics.py Worker {thr_idx+1} to_id_matrix({f})\")\n\n if not path.isfile(f\"{path_to_seq_data}/realigned/{f}_3d_only.stk\"):\n warn(f\"File not found: {path_to_seq_data}/realigned/{f}_3d_only.stk\")\n align = AlignIO.read(f\"{path_to_seq_data}/realigned/{f}_3d_only.stk\", \"stockholm\")\n names = [ x.id for x in align if '[' in x.id ]\n del align\n \n pbar = tqdm(total = len(names)*(len(names)-1)*0.5, position=thr_idx+1, desc=f\"Worker {thr_idx+1}: {f} idty matrix\", unit=\"comparisons\", leave=False)\n pbar.update(0)\n \n # Prepare the job\n process = subprocess.Popen(shlex.split(f\"esl-alipid --rna --noheader --informat stockholm {path_to_seq_data}/realigned/{f}_3d_only.stk\"), stdout=subprocess.PIPE, stderr=subprocess.PIPE)\n id_matrix = np.zeros((len(names), len(names)))\n cnt = 0\n while not cnt or process.poll() is None:\n output = process.stdout.read()\n if output:\n lines = output.strip().split(b'\\n')\n for l in lines:\n cnt += 1\n line = l.split()\n s1 = line[0].decode('utf-8')\n s2 = line[1].decode('utf-8')\n score = line[2].decode('utf-8')\n id1 = names.index(s1)\n id2 = names.index(s2)\n id_matrix[id1, id2] = float(score)\n pbar.update(1)\n if cnt != len(names)*(len(names)-1)*0.5:\n warn(f\"{f} got {cnt} updates on {len(names)*(len(names)-1)*0.5}\")\n if process.poll() != 0:\n l = process.stderr.read().strip().split(b'\\n')\n warn(\"\\n\".join([ line.decode('utf-8') for line in l ]))\n pbar.close()\n\n np.save(\"data/\"+f+\".npy\", id_matrix)\n\n idxQueue.put(thr_idx) # replace the thread index in the queue\n setproctitle(f\"RNANet statistics.py Worker {thr_idx+1} finished\")\n return 0","def emit(self, pid):\n print \"Emit with pid: {}\".format(pid)\n if pid is None:\n return False\n metrics = {'cpu': 0,\n 'ram': 1,\n 'net': 2,\n 'bytes_sent': 1,\n 'bytes_recv': 1,\n 'packets_sent': 1,\n 'packets_recv': 1,\n 'errin': 0,\n 'errout': 0,\n 'dropin': 0,\n 'dropout': 0,\n 'disk': 0,\n 'files': 0,\n 'time': calendar.timegm(time.gmtime()) * 1000}\n #return False # prevent this\n ##########################################################################################################\n # psutil read metrics\n try:\n # self.proc = psutil.Process(pid)\n process_name = None\n if self.personal_cloud.lower() == \"stacksync\":\n if os.name == 'nt':\n process_name = \"javaw.exe\"\n elif os.name == \"posix\":\n process_name = \"java\"\n\n elif self.personal_cloud.lower() == \"dropbox\":\n if os.name == 'nt':\n process_name = \"Dropbox.exe\"\n elif os.name == \"posix\":\n process_name = \"dropbox\"\n elif self.personal_cloud.lower() == \"owncloud\":\n process_name = \"owncloudcmd\"\n elif self.personal_cloud.lower() == 'mega':\n process_name = \"megacmd\"\n\n if self.proc is None or self.proc.pid != pid:\n self.proc = psutil.Process(pid)\n\n if process_name == self.proc.name() or \"owncloudcmd\" == process_name or \"megacmd\" == process_name:\n print \"OKEY match {} == {}\".format(self.proc.name(), process_name)\n else:\n print \"sync client does not match: {}\".format(process_name)\n return False\n\n except Exception as ex:\n print \"sync client is not running! {}\".format(pid)\n print ex.message\n return False # exit as the process is not alive.\n\n ##########################################################################################################\n print \"PID: {} [{}]\".format(pid, self.personal_cloud.lower())\n try:\n if self.personal_cloud.lower() == \"stacksync\":\n # todo lookup for stacksync process here => using psutil\n cpu_usage = int(math.ceil(self.proc.cpu_percent(0)))\n ram_usage = self.proc.memory_info().rss\n metrics['cpu'] = cpu_usage\n metrics['ram'] = ram_usage\n elif self.personal_cloud.lower() == \"owncloud\":\n cpu_usage = int(math.ceil(self.proc.children()[0].cpu_percent(interval=1)))\n ram_usage = self.proc.children()[0].memory_info().rss\n metrics['cpu'] = cpu_usage\n metrics['ram'] = ram_usage\n elif self.personal_cloud.lower() == \"mega\":\n cpu_usage = int(math.ceil(self.proc.children()[0].cpu_percent(interval=1)))\n ram_usage = self.proc.children()[0].memory_info().rss\n metrics['cpu'] = cpu_usage\n metrics['ram'] = ram_usage\n elif self.personal_cloud.lower() == \"dropbox\":\n # todo lookup for dropbox process here => using psutil\n cpu_usage = int(math.ceil(self.proc.cpu_percent(0)))\n ram_usage = self.proc.memory_info().rss\n metrics['cpu'] = cpu_usage\n metrics['ram'] = ram_usage\n except Exception as e:\n print e.message\n\n # assign the network usage metric\n\n if self.prev_metric is not None:\n # do nothing because its the first emit ant there are no previous metric to compare\n # last_net = self.prev_metric['metrics']['net']\n last_time = self.prev_metric['metrics']['time']\n\n curr_net_counter = psutil.net_io_counters(pernic=True)['eth0'] # read the bytes from somewhere\n curr_time = metrics['time']\n elapsed_time = (curr_time - last_time) / 1000 # segons\n for key, value in curr_net_counter.__dict__.items():\n metrics[key] = (value - getattr(self.prev_net_counter, key)) / elapsed_time # unit is seconds\n self.prev_net_counter = curr_net_counter\n # assign hard drive usage metric\n\n if os.name == \"nt\":\n drive_usage = \"1234\"\n elif os.name == \"posix\":\n drive_usage_cmd = ['/usr/bin/du', '-ks', '/home/vagrant/{}'.format(self.personal_folder)]\n drive_usage_output = subprocess.Popen(drive_usage_cmd, stdout=subprocess.PIPE)\n drive_usage = drive_usage_output.stdout.read()\n try:\n metrics['disk'] = int(drive_usage.split('\\t')[0]) # kilo bytes cast string to int\n except Exception as ex:\n print \"invalid literal for... memory unit\"\n metrics['disk'] = 1\n # assign add folder num of files metric\n\n\n\n\n if os.name == \"nt\":\n num_files = \"123\"\n elif os.name == \"posix\":\n find_cmd = '/usr/bin/find /home/vagrant/{} -type f'.format(self.personal_folder).split()\n proc_find = subprocess.Popen(find_cmd, stdout=subprocess.PIPE)\n wc_cmd = '/usr/bin/wc -l'.split()\n proc_wc = subprocess.Popen(wc_cmd, stdin=proc_find.stdout, stdout=subprocess.PIPE)\n num_files = proc_wc.communicate()[0]\n try:\n metrics['files'] = int(num_files.split('\\t')[0])\n except Exception as ex:\n print \"invalid literal for... file counter\"\n\n net_stats = self.traffic_monitor.notify_stats()\n # z = dict(x.items() + y.items()) => metrics\n # envez de esto dict join\n metrics['data_rate_size_up'] = net_stats['data_rate']['size_up']\n metrics['data_rate_size_down'] = net_stats['data_rate']['size_down']\n metrics['data_rate_pack_up'] = net_stats['data_rate']['pack_up']\n metrics['data_rate_pack_down'] = net_stats['data_rate']['pack_down']\n metrics['meta_rate_size_up'] = net_stats['meta_rate']['size_up']\n metrics['meta_rate_size_down'] = net_stats['meta_rate']['size_down']\n metrics['meta_rate_pack_up'] = net_stats['meta_rate']['pack_up']\n metrics['meta_rate_pack_down'] = net_stats['meta_rate']['pack_down']\n\n '''\n {'data_rate':\n {'size_up': 0.471, 'pack_down': 0.00175, 'pack_up': 0.00225, 'size_down': 0.612},\n 'meta_rate':\n {'size_up': 0.0, 'pack_down': 0.0, 'pack_up': 0.0, 'size_down': 0.0},\n 'time': 1461065156000\n }\n '''\n\n tags = ''\n if tags == '':\n tags = {\n 'profile': self.receipt,\n 'credentials': 'pc_credentials',\n 'client': self.personal_cloud.lower(),\n }\n\n data = {\n 'metrics': metrics,\n 'tags': tags\n }\n self.prev_metric = data # update the last emited metric\n msg = json.dumps(data)\n print msg\n\n self.channel.basic_publish(\n exchange='metrics',\n routing_key=self.hostname,\n body=msg)\n\n return True","def set_default_pids(config, gState):\n axes = dict(RADEC = \"raDec\", ROT = \"rot\", FOCUS = \"focus\", SCALE = \"scale\")\n for axis in config.options('PID'):\n axis = axes[axis.upper()]\n Kp, Ti_min, Ti_max, Td, Imax, nfilt = [float(v) for v in config.get('PID', axis).split()] \n gState.set_pid_defaults(axis, Kp=Kp, Ti_min=Ti_min, Ti_max=Ti_max, Td=Td, Imax=Imax, nfilt=int(nfilt))\n gState.pid[axis].setPID(Kp=Kp, Ti=Ti_min, Td=Td, Imax=Imax, nfilt=nfilt)","def pid(self):\n return self.__pid","def collect_pidin(self, log_dir):\n log_type = \"pidin\"\n log_name = \"pidin.txt\"\n cmd = \"pidin > /tmp/{}\".format(log_name)\n\n self._collect_log(log_type, log_dir, log_name, cmd)","def free_pid():\n host, pid, tid = get_process_id()\n while True:\n # PIDs are often restricted to a small range. On Linux the range >32k is by default not used.\n pid = random.randint(33000, 65000)\n if not process_alive(host, pid, tid):\n return pid","def test_003_pid(self):\n HEADING()\n pid = self.db.pid()\n print (pid)\n assert True","def pids(node, java_class):\n cmd = \"ps -C java -wwo pid,args | grep '%s' | awk -F' ' '{print $1}'\" % java_class\n\n return [int(pid) for pid in node.account.ssh_capture(cmd, allow_fail=True)]","def calc_conservation(aln):\n\n length = len(aln.values()[0])\n seqs = aln.values()\n percids = []\n\n # find identity positions\n for i in xrange(length):\n chars = util.hist_dict(util.cget(seqs, i))\n if \"-\" in chars:\n del chars[\"-\"]\n\n if len(chars) == 0:\n percids.append(0.0)\n else:\n pid = max(chars.values()) / float(len(aln))\n percids.append(pid)\n return percids","def set_pid(self, kp, ki, kd):\n for vehicle_id in self.vehicle_ids:\n self.frenets[vehicle_id].set_pid(kp, ki, kd)","def freq():","def __init__(self,x,dof):\n self.x=x\n self.dof=dof\n numSeg=10\n p1=self.P(numSeg)\n p2=0\n while True:\n numSeg*=2\n p2=self.P(numSeg)\n if self.checarPs(p1,p2):\n break\n else:\n p1=p2\n print(round(p2,5))","def pid(self):\n if self.proc is None:\n return 0\n return self._pid()","def answer():\n for k in range(2,3000):\n for j in range(k-1,0,-1):\n pj, pk = P(j), P(k)\n #print( j, k, pj, pk )\n if isPent(pk-pj):\n #print( j, k, pj, pk, pk+pj, isPent(pk+pj), pk-pj )\n if isPent(pk+pj) and isPent(pk-pj):\n return pk-pj","def __next_shape_id(self):\n cNvPrs = self.__spTree.xpath('//p:cNvPr', namespaces=_nsmap)\n ids = [int(cNvPr.get('id')) for cNvPr in cNvPrs]\n ids.sort()\n # first gap in sequence wins, or falls off the end as max(ids)+1\n next_id = 1\n for id in ids:\n if id > next_id:\n break\n next_id += 1\n return next_id","def __get_pid(self):\n str_pid = os.getpid() + 65535\n str_hex_pid = hex(str_pid)[2:]\n return str_hex_pid","def setup_process_stats(pid):\n return psutil.Process(pid)","def setChildPIDs(self):\n\t\tpids = []\n\t\tfor proc in process_iter():\n\t\t\tfor child in self.expectedChildren:\n\t\t\t\tif child == proc.name():\n\t\t\t\t\tif proc.parent().name() == \"Python\": # Hardcoded string comparison. Sue me.\n\t\t\t\t\t\tpids.append(proc.pid)\n\t\tself.pids = pids","def ncore(self):","def Pp(nccd):\n return (128.1-56.9) * (nccd - 1) / (6-1) + 56.9","def pids(self):\n return self._pidToProcess.iterkeys()","def nid2partid(self, nids, ntype=...):\n ...","def nid2partid(self, nids, ntype=...):\n ...","def identify_processes(self) -> Dict[int, dict]:\n\n processes = {}\n\n for process in self.behavior[\"generic\"]:\n\n proc_name, proc_path = split_path(process[\"process_path\"])\n\n processes[int(process[\"pid\"])] = {\n FieldNames.PROCESS_IMAGE: proc_name,\n FieldNames.PROCESS_IMAGE_PATH: proc_path,\n FieldNames.PROCESS_ID: int(process[\"pid\"]),\n }\n\n return processes","def test_pnc(id):\n if id < int('0x10ffffff', 16): # 285212671\n return 'player'\n elif id < int('0x40ffffff', 16): # 1090519039\n return 'creature'\n elif id < int('0x80000fff', 16): # 2147487743\n return 'npc'\n else:\n print 'creature.Id error', id\n return None","def findpc(self):\n u = -(-can.C.len() + self.P.len() + can.R)/self.V.len()\n if u >= 0:\n return self.P + self.V.scale(u), u\n else:\n u = (can.C.len() - self.P.len() + can.R)/self.V.len()\n return self.P + self.V.scale(u), u","def process_synthetic_peptides(cluster):\n total_spectra = 0\n sequence_counts = dict()\n\n for spectrum in cluster.get_spectra():\n # ignore all none synthetic spectra\n if \"PXD004732\" not in spectrum.get_title():\n continue\n\n total_spectra += 1\n\n # spectra from this dataset only contain one psm\n if len(spectrum.psms) != 1:\n raise Exception(\"Unidentified spectrum from project PXD004732 encountered: \" + spectrum.get_title())\n\n psm = [p for p in spectrum.psms][0]\n\n if psm.sequence not in sequence_counts:\n sequence_counts[psm.sequence] = 1\n else:\n sequence_counts[psm.sequence] += 1\n\n # done if no synthetic peptides were found\n if total_spectra == 0:\n return \"0\\tNA\\tNA\"\n\n # get the max count\n max_count = max(sequence_counts.values())\n\n # get the matching sequences\n max_sequences = [s for s in sequence_counts if sequence_counts[s] == max_count]\n\n # calculate the ratio\n max_ratio = max_count / total_spectra\n\n return str(total_spectra) + \"\\t\" + str(max_ratio) + \"\\t\" + \";\".join(max_sequences)","def calc_process_coupling(partitions, graph):\n avg_pc = calc_avg_process_coupling(partitions, graph)\n if not (len(partitions) or avg_pc) == 0:\n pc = avg_pc / len(partitions)\n else:\n pc = 0\n return pc","def get_num_pids(self, data):\n pids = set()\n for items in data:\n pid = items[1]\n pids.add(pid)\n return len(pids)","def calculateIdentities(percIdentity, length):\n return np.floor(percIdentity * length / 100 + 0.5)","def __init__(self, pid, period, num_period=None):\n\n super(PIDTimedLoop, self).__init__(period, num_period)\n self._pid = pid\n self._is_active = pid.poll() is None"],"string":"[\n \"def ppid(self):\",\n \"def pid(self):\",\n \"def pidGet(self) -> float:\\n ...\",\n \"def pidGet(self) -> float:\\n ...\",\n \"def inspire_pidstore():\",\n \"def dynamic_pid(self):\\n pass\",\n \"def _update_PID(self):\\n self.pid = PID(p=self.paramP, i=self.paramI, d=self.paramD, setpoint=self.voltageSetpoint, memory=self.paramMemory)\",\n \"def _get_pid(split_data, sensor):\\n prot, ip_dst, port_dst, timestamp = split_data\\n prot = prot.lower()\\n\\n if not sanitizer.check_get_pid_params(prot, ip_dst, port_dst, timestamp):\\n return '-1,error checking input'\\n\\n return sensor.search_process(prot, ip_dst, port_dst, timestamp)\",\n \"def calculate_percid(\\n pos_total, length_query, length_subject, length_total, option_pid=\\\"mean\\\"\\n):\\n if option_pid == \\\"mean\\\":\\n pid = pos_total / ((length_query + length_subject) / 2.0)\\n elif option_pid == \\\"subject\\\":\\n pid = pos_total / length_subject\\n elif option_pid == \\\"query\\\":\\n pid = pos_total / length_query\\n elif option_pid == \\\"shortest\\\":\\n pid = pos_total / min(length_query, length_subject)\\n elif option_pid == \\\"longest\\\":\\n pid = pos_total / max(length_query, length_subject)\\n elif option_pid == \\\"HSP\\\":\\n pid = pos_total / length_total\\n\\n return pid\",\n \"def test_pid_ccs2():\\n d = trivariates['anddup']\\n pid = PID_CCS(d, [[0], [1], [2]], [3])\\n for atom in pid._lattice:\\n if atom == ((0,), (1,), (2,)):\\n assert pid[atom] == pytest.approx(0.10375937481971094)\\n elif atom in [((0,), (2,)), ((1,),)]:\\n assert pid[atom] == pytest.approx(0.20751874963942191)\\n elif atom in [((2,), (0, 1)), ((0,), (1, 2)), ((0, 1), (0, 2)), ((0, 1), (1, 2)), ((0, 2), (1, 2)), ((0, 1, 2),)]:\\n assert pid[atom] == pytest.approx(0.14624062518028902)\\n elif atom in [((2,),), ((0,),), ((0, 1), (0, 2), (1, 2)), ((0, 2),)]:\\n assert pid[atom] == pytest.approx(-0.14624062518028902)\\n else:\\n assert pid[atom] == pytest.approx(0.0)\",\n \"def get_pid(self):\\n return self.k_p, self.k_i, self.k_d\",\n \"def first_part_pid(self,text,pid):\\n\\n len_max=4\\n key_list=pid.keys()\\n while 1:\\n num=min(len_max,len(text))\\n if len_max==0:\\n sys.exit('error pid dico not complete or invalid input :'+str([text[:min(3,len(text))]])+'\\\\\\n \\\\n Complete proc_info.py')\\n \\n if text[:num].lower() in key_list:\\n tag=text[:num].lower()\\n text=text[num:]\\n return text, pid[tag]\\n else:\\n len_max+=-1\",\n \"def test_pid_ccs3():\\n d = trivariates['anddup']\\n pid = PID_CCS(d)\\n for atom in pid._lattice:\\n if atom == ((0,), (1,), (2,)):\\n assert pid[atom] == pytest.approx(0.10375937481971094)\\n elif atom in [((0,), (2,)), ((1,),)]:\\n assert pid[atom] == pytest.approx(0.20751874963942191)\\n elif atom in [((2,), (0, 1)), ((0,), (1, 2)), ((0, 1), (0, 2)), ((0, 1), (1, 2)), ((0, 2), (1, 2)), ((0, 1, 2),)]:\\n assert pid[atom] == pytest.approx(0.14624062518028902)\\n elif atom in [((2,),), ((0,),), ((0, 1), (0, 2), (1, 2)), ((0, 2),)]:\\n assert pid[atom] == pytest.approx(-0.14624062518028902)\\n else:\\n assert pid[atom] == pytest.approx(0.0)\",\n \"def pass_in_pid(self,process_line,multi):\\n \\n ParticlesFile=Card('./Source/MODEL/particles.dat')\\n pid=ParticlesFile.give_pid_dict()\\n \\n #\\n # Update information with multi_particle tag\\n #\\n for couple in multi.items():\\n text=couple[1]\\n tag=couple[0]\\n pid_list=[]\\n len_max=3\\n key_list=pid.keys()\\n while text:\\n text,add=self.first_part_pid(text,pid)\\n pid_list+=add\\n\\n pid.update({tag:pid_list})\\n\\n\\n\\n #\\n # pid list is now complete\\n # convert line in decay pid information\\n decay_rule=[]\\n #1) take only the decay part:\\n for letter in ['$','\\\\\\\\','@','#','\\\\n']:\\n if letter in process_line:\\n process_line=process_line[:process_line.index(letter)]\\n break # only one such symbol to signify the end of the decay part\\n process_line=process_line[process_line.index('>')+1:]\\n\\n \\n decay_diag=[]\\n level_decay=0\\n while process_line:\\n if process_line[0]==' ':\\n process_line=process_line[1:]\\n continue\\n if process_line[0]=='>':\\n process_line=process_line[1:]\\n continue \\n\\n if process_line[0]=='(':\\n process_line=process_line[1:]\\n level_decay+=1\\n new_decay=1\\n continue\\n \\n if process_line[0]==')':\\n level_decay-=1\\n current_part=current_part.mother\\n process_line=process_line[1:]\\n continue\\n\\n\\n process_line,pid_content=self.first_part_pid(process_line,pid)\\n\\n if level_decay==0 or (level_decay==1 and new_decay):\\n new_decay=0\\n part=Proc_decay(pid_content)\\n decay_diag.append(part)\\n current_part=part\\n elif new_decay:\\n new_decay=0\\n part=current_part.add_desint(pid_content) #return new part\\n current_part=part\\n else:\\n current_part.add_desint(pid_content)\\n\\n\\n return decay_diag\",\n \"def _PIDController__calculate(self): \\n \\n\\t\\tenabled = self.m_enabled\\n\\t\\tpidInput = self.m_pidInput\\n\\n\\t\\tif enabled:\\n\\n\\t\\t input = pidInput.PIDGet()\\n\\n\\t\\t self.m_error = self.m_setpoint - input\\n\\t\\t if self.m_continuous:\\n\\t\\t \\n\\t\\t if math.fabs(self.m_error) > (self.m_maximumInput - self.m_minimumInput) / 2:\\n\\t\\t if self.m_error > 0:\\n\\t\\t self.m_error = self.m_error - self.m_maximumInput + self.m_minimumInput\\n\\t\\t else:\\n\\t\\t self.m_error = self.m_error + self.m_maximumInput - self.m_minimumInput\\n\\n\\t\\t potentialIGain = (self.m_totalError + self.m_error) * self.m_I\\n\\t\\t \\n\\t\\t if potentialIGain < self.m_maximumOutput:\\n\\t\\t if potentialIGain > self.m_minimumOutput:\\n\\t\\t self.m_totalError += self.m_error\\n\\t\\t else:\\n\\t\\t self.m_totalError = self.m_minimumOutput / self.m_I\\n\\t\\t else:\\n\\t\\t self.m_totalError = self.m_maximumOutput / self.m_I\\n\\n\\t\\t self.m_result = self.m_P * self.m_error + self.m_I * self.m_totalError + self.m_D * (self.m_error - self.m_prevError)\\n\\t\\t self.m_prevError = self.m_error\\n\\n\\t\\t if self.m_result > self.m_maximumOutput:\\n\\t\\t self.m_result = self.m_maximumOutput\\n\\t\\t elif self.m_result < self.m_minimumOutput:\\n\\t\\t self.m_result = self.m_minimumOutput\\n\\n\\t\\t pidOutput = self.m_pidOutput\\n\\t\\t result = self.m_result\",\n \"def pid():\\n return 0x0204\",\n \"def pid():\\n return 0x0204\",\n \"def get_pid(packet):\\n return ((ord(packet[TS.PID_START_INDEX]) & 0x1f)<<8) | ord(packet[TS.PID_START_INDEX+1])\",\n \"def get_seq_ppi(filename):\\n with open(filename) as file:\\n #return get_pairs(file)\\n p= get_Ps(file)\\n pp = p[0]\\n ppid = get_ppi(pp)\\n return ppid\",\n \"def detect_instance_pids(self):\\n for instance in self.all_instances:\\n instance.detect_pid(\\n ppid=self.instance.pid,\\n full_binary_path=self.cfg.real_sbin_dir,\\n offset=0,\\n )\\n\\n self.show_all_instances()\\n self.detect_arangosh_instances(self.cfg, self.cfg.version)\",\n \"def pidHTTPd(htconf):\\n# pcmd = \\\"/bin/ps -ef|/bin/grep \\\" + htconf + \\\"|/bin/grep -v grep|/bin/awk '{print $3}'|sort -u\\\"\\n# pcmd = '/bin/ps -ef'\\n# pcmd = 'ps -eo pid,ppid,rss,vsize,pcpu,pmem,cmd -ww --sort=pid'\\n pcmd = 'ps -eo pid,ppid,rss,cmd'\\n# produces something like the following (when selecting htconf == httpd.conf99)\\n#30645 1 4420 /devstore/apache2/bin/httpd -f /devstore/apache2/conf/httpd.conf99\\n#30646 30645 1640 /devstore/apache2/bin/httpd -f /devstore/apache2/conf/httpd.conf99\\n#30647 30645 2628 /devstore/apache2/bin/fcgi- -f /devstore/apache2/conf/httpd.conf99\\n#30648 30645 37216 /devstore/apache2/bin/httpd -f /devstore/apache2/conf/httpd.conf99\\n#30649 30645 3064 /devstore/apache2/bin/httpd -f /devstore/apache2/conf/httpd.conf99\\n#30650 30645 3064 /devstore/apache2/bin/httpd -f /devstore/apache2/conf/httpd.conf99\\n#30651 30645 3064 /devstore/apache2/bin/httpd -f /devstore/apache2/conf/httpd.conf99\\n#30652 30645 3064 /devstore/apache2/bin/httpd -f /devstore/apache2/conf/httpd.conf99\\n#30656 30645 3064 /devstore/apache2/bin/httpd -f /devstore/apache2/conf/httpd.conf99\\n# the 3rd column is ram util. in units of kbytes, kill the entire set of httpd pids\\n# (by killing parent proc) if any one thread exceeds 1,000,000 kbytes (> 1gb)\\n pid = os.popen(pcmd, \\\"r\\\")\\n ppids = [] ; pids = [] ; memuse = [] ; vals = [] \\n parentpid = -1\\n restart = False\\n try:\\n for p in pid.xreadlines():\\n p.rstrip()\\n vals = p.split()\\n conf = vals[-1] # last val should be confile\\n try:\\n if conf.index(htconf) >= 0 :\\n pids.append(int(vals[0]))\\n ppids.append(int(vals[1]))\\n memuse.append(int(vals[2])) \\n# print >> FileKeyUtils.WMSlog, 'pidHTTPd> pids: ', pids, ', ppids: ', ppids, ' memuse: ', memuse\\n if int(vals[1]) == 1 : parentpid = int(vals[0])\\n if int(vals[2]) > 1000000 : restart = True\\n except:\\n# print >> FileKeyUtils.WMSlog, 'pidHTTPd> vals: ', vals\\n pass\\n except: pass\\n\\n print >> FileKeyUtils.WMSlog, 'pidHTTPd>', htconf, ' parentpid:', parentpid, ', memuse:', memuse\\n if restart: # return parentpid\\n return parentpid\\n\\n return -1\",\n \"def __init__(self):\\n self.pidDict = { # particle_name, pid\\n \\\"total\\\" : 0,\\n \\\"charged\\\" : 1,\\n \\\"charged_eta\\\" : 2,\\n \\\"pion\\\" : 6, # sum(7, 8, -7)\\n \\\"pion_p\\\" : 7,\\n \\\"pion_0\\\" : 8,\\n \\\"pion_m\\\" : -7,\\n \\\"kaon\\\" : 11, # sum(12, 13)\\n \\\"kaon_p\\\" : 12,\\n \\\"kaon_0\\\" : 13,\\n \\\"anti_kaon\\\" : -11, # sum(-12, -13)\\n \\\"kaon_m\\\" : -12,\\n \\\"anti_kaon_0\\\" : -13,\\n \\\"nucleon\\\" : 16, # sum(17, 18)\\n \\\"proton\\\" : 17,\\n \\\"neutron\\\" : 18,\\n \\\"anti_nucleon\\\" : -16, # sum(-17, -18)\\n \\\"anti_proton\\\" : -17,\\n \\\"anti_neutron\\\" : -18,\\n \\\"sigma\\\" : 21, # sum(22, 23, 24)\\n \\\"sigma_p\\\" : 22,\\n \\\"sigma_0\\\" : 23,\\n \\\"sigma_m\\\" : 24,\\n \\\"anti_sigma\\\" : -21,\\n \\\"anti_sigma_p\\\" : -22,\\n \\\"anti_sigma_0\\\" : -23,\\n \\\"anti_sigma_m\\\" : -24,\\n \\\"xi\\\" : 26, # sum(27, 28)\\n \\\"xi_0\\\" : 27,\\n \\\"xi_m\\\" : 28,\\n \\\"anti_xi\\\" : -26,\\n \\\"anti_xi_0\\\" : -27,\\n \\\"anti_xi_m\\\" : -28,\\n \\\"lambda\\\" : 31,\\n \\\"anti_lambda\\\" : -31,\\n \\\"omega\\\" : 36,\\n \\\"anti_omega\\\" : -36,\\n \\\"phi\\\" : 41,\\n \\\"rho\\\" : 46, #sum(47, 48, -47)\\n \\\"rho_p\\\" : 47,\\n \\\"rho_0\\\" : 48,\\n \\\"rho_m\\\" : -47,\\n \\\"eta\\\" : 51,\\n \\\"eta_prime\\\" : 52,\\n \\\"gamma\\\" : 61,\\n \\\"omega782\\\" : 65,\\n \\\"eta\\\" : 71,\\n \\\"etap\\\" : 72,\\n }\\n\\n for aParticle in self.pidDict.keys():\\n if self.pidDict[aParticle]>=0:\\n self.pidDict[aParticle+\\\"_hydro\\\"] = self.pidDict[aParticle]+1000\\n else:\\n self.pidDict[aParticle+\\\"_hydro\\\"] = self.pidDict[aParticle]-1000\\n if self.pidDict[aParticle]>=0:\\n self.pidDict[aParticle+\\\"_thermal\\\"] = self.pidDict[aParticle]+2000\\n else:\\n self.pidDict[aParticle+\\\"_thermal\\\"] = self.pidDict[aParticle]-2000\\n\\n self.pidDict.update({\\n \\\"photon_total\\\" : 9000,\\n \\\"photon_total_eq\\\" : 9001,\\n \\\"photon_QGP_tot\\\" : 9002,\\n \\\"photon_QGP_eq\\\" : 9003,\\n \\\"photon_HG_tot\\\" : 9004,\\n \\\"photon_HG_eq\\\" : 9005,\\n \\\"direct_gamma_shortdecay_hydro\\\" : 9006,\\n \\\"decay_gamma_pi0_hydro\\\" : 9007,\\n \\\"decay_gamma_eta_hydro\\\" : 9008,\\n \\\"decay_gamma_omega_hydro\\\" : 9009,\\n \\\"decay_gamma_phi_hydro\\\" : 9010,\\n \\\"decay_gamma_etap_hydro\\\" : 9011,\\n \\\"decay_gamma_Sigma0_hydro\\\" : 9012,\\n })\\n\\n #UrQMD pid Dictionary, name conversion defined as in binUtility\\n self.UrQMDpidDict = { #particle name, UrQMD id# : isospin*2000 + pid\\n 2101 : \\\"pion_p\\\",\\n -1899 : \\\"pion_m\\\",\\n 101 : \\\"pion_0\\\",\\n 1106 : \\\"kaon_p\\\",\\n -894 : \\\"kaon_0\\\",\\n -1106 : \\\"kaon_m\\\",\\n 894 : \\\"anti_kaon_0\\\",\\n 1001 : \\\"proton\\\",\\n -999 : \\\"neutron\\\",\\n -1001 : \\\"anti_proton\\\",\\n 999 : \\\"anti_neutron\\\",\\n 2040 : \\\"sigma_p\\\",\\n -1960 : \\\"sigma_m\\\",\\n 40 : \\\"sigma_0\\\",\\n -2040 : \\\"anti_sigma_p\\\",\\n 1960 : \\\"anti_sigma_m\\\",\\n -40 : \\\"anti_sigma_0\\\",\\n 1049 : \\\"xi_0\\\",\\n -951 : \\\"xi_m\\\",\\n -1049 : \\\"anti_xi_0\\\",\\n 951 : \\\"anti_xi_m\\\",\\n 27 : \\\"lambda\\\",\\n -27 : \\\"anti_lambda\\\",\\n 55 : \\\"omega\\\",\\n -55 : \\\"anti_omega\\\",\\n 109 : \\\"phi\\\",\\n 102 : \\\"eta\\\",\\n 107 : \\\"eta_prime\\\",\\n 100 : \\\"gamma\\\",\\n }\\n\\n #pdg pid Dictionary\\n self.PDGpidDict = { #pdg id#, particle name\\n 211 : \\\"pion_p\\\",\\n -211 : \\\"pion_m\\\",\\n 111 : \\\"pion_0\\\",\\n 321 : \\\"kaon_p\\\",\\n 311 : \\\"kaon_0\\\",\\n -321 : \\\"kaon_m\\\",\\n -311 : \\\"anti_kaon_0\\\",\\n 2212 : \\\"proton\\\",\\n 2112 : \\\"neutron\\\",\\n -2212 : \\\"anti_proton\\\",\\n -2112 : \\\"anti_neutron\\\",\\n 3222 : \\\"sigma_p\\\",\\n 3112 : \\\"sigma_m\\\",\\n 3212 : \\\"sigma_0\\\",\\n -3222 : \\\"anti_sigma_p\\\",\\n -3112 : \\\"anti_sigma_m\\\",\\n -3212 : \\\"anti_sigma_0\\\",\\n 3322 : \\\"xi_0\\\",\\n 3312 : \\\"xi_m\\\",\\n -3322 : \\\"anti_xi_0\\\",\\n -3312 : \\\"anti_xi_m\\\",\\n 3122 : \\\"lambda\\\",\\n -3122 : \\\"anti_lambda\\\",\\n 3334 : \\\"omega\\\",\\n -3334 : \\\"anti_omega\\\",\\n 333 : \\\"phi\\\",\\n 221 : \\\"eta\\\",\\n 331 : \\\"eta_prime\\\",\\n 22 : \\\"gamma\\\",\\n }\\n\\n #particle mass Dictionary (unit in GeV)\\n self.masspidDict = {\\n \\\"pion\\\" : 0.13957,\\n \\\"pion_p\\\" : 0.13957,\\n \\\"pion_0\\\" : 0.13498,\\n \\\"pion_m\\\" : 0.13957,\\n \\\"kaon\\\" : 0.49368,\\n \\\"kaon_p\\\" : 0.49368,\\n \\\"kaon_0\\\" : 0.49765,\\n \\\"anti_kaon\\\" : 0.49368,\\n \\\"kaon_m\\\" : 0.49368,\\n \\\"anti_kaon_0\\\" : 0.49765,\\n \\\"nucleon\\\" : 0.93827,\\n \\\"proton\\\" : 0.93827,\\n \\\"neutron\\\" : 0.93957,\\n \\\"anti_nucleon\\\" : 0.93827,\\n \\\"anti_proton\\\" : 0.93827,\\n \\\"anit_neutron\\\" : 0.93957,\\n \\\"sigma\\\" : 1.18937,\\n \\\"sigma_p\\\" : 1.18937,\\n \\\"sigma_0\\\" : 1.19264,\\n \\\"sigma_m\\\" : 1.19745,\\n \\\"anti_sigma\\\" : 1.18937,\\n \\\"anti_sigma_p\\\" : 1.18937,\\n \\\"anti_sigma_0\\\" : 1.19264,\\n \\\"anti_sigma_m\\\" : 1.19745,\\n \\\"xi\\\" : 1.31483,\\n \\\"xi_0\\\" : 1.31483,\\n \\\"xi_m\\\" : 1.32131,\\n \\\"anti_xi\\\" : 1.31483,\\n \\\"anti_xi_0\\\" : 1.31483,\\n \\\"anti_xi_m\\\" : 1.32131,\\n \\\"lambda\\\" : 1.11568,\\n \\\"anti_lambda\\\" : 1.11568,\\n \\\"omega\\\" : 1.67243,\\n \\\"anti_omega\\\" : 1.67243,\\n \\\"rho\\\" : 0.77580,\\n \\\"rho_p\\\" : 0.77580,\\n \\\"rho_0\\\" : 0.77580,\\n \\\"rho_m\\\" : 0.77580,\\n \\\"phi\\\" : 1.01946,\\n \\\"eta\\\" : 0.54775,\\n \\\"eta_prime\\\" : 0.95778,\\n \\\"gamma\\\" : 0.0,\\n }\\n for aParticle in self.masspidDict.keys():\\n self.masspidDict[aParticle+\\\"_hydro\\\"] = self.masspidDict[aParticle]\\n self.masspidDict[aParticle+\\\"_thermal\\\"] = self.masspidDict[aParticle]\\n\\n # charged hadrons list\\n self.charged_hadron_list = [\\n \\\"pion_p\\\", \\\"pion_m\\\", \\\"kaon_p\\\", \\\"kaon_m\\\", \\\"proton\\\", \\\"anti_proton\\\",\\n \\\"sigma_p\\\", \\\"sigma_m\\\", \\\"anti_sigma_p\\\", \\\"anti_sigma_m\\\",\\n \\\"xi_m\\\", \\\"anti_xi_m\\\"]\",\n \"def _PIDController__calculate(self): \\n \\n\\t\\tenabled = self.m_enabled\\n\\t\\tpidInput = self.m_pidInput\\n\\t\\tpidInput2 = self.source2\\n\\n\\t\\tif enabled:\\n\\n\\t\\t input = pidInput.PIDGet() - pidInput2.PIDGet()\\n\\n\\t\\t self.m_error = self.m_setpoint - input\\n\\t\\t if self.m_continuous:\\n\\t\\t \\n\\t\\t if math.fabs(self.m_error) > (self.m_maximumInput - self.m_minimumInput) / 2:\\n\\t\\t if self.m_error > 0:\\n\\t\\t self.m_error = self.m_error - self.m_maximumInput + self.m_minimumInput\\n\\t\\t else:\\n\\t\\t self.m_error = self.m_error + self.m_maximumInput - self.m_minimumInput\\n\\n\\t\\t potentialIGain = (self.m_totalError + self.m_error) * self.m_I\\n\\t\\t \\n\\t\\t if potentialIGain < self.m_maximumOutput:\\n\\t\\t if potentialIGain > self.m_minimumOutput:\\n\\t\\t self.m_totalError += self.m_error\\n\\t\\t else:\\n\\t\\t self.m_totalError = self.m_minimumOutput / self.m_I\\n\\t\\t else:\\n\\t\\t self.m_totalError = self.m_maximumOutput / self.m_I\\n\\n\\t\\t self.m_result = self.m_P * self.m_error + self.m_I * self.m_totalError + self.m_D * (self.m_error - self.m_prevError)\\n\\t\\t self.m_prevError = self.m_error\\n\\n\\t\\t if self.m_result > self.m_maximumOutput:\\n\\t\\t self.m_result = self.m_maximumOutput\\n\\t\\t elif self.m_result < self.m_minimumOutput:\\n\\t\\t self.m_result = self.m_minimumOutput\\n\\n\\t\\t pidOutput = self.m_pidOutput\\n\\t\\t result = self.m_result\",\n \"def genPID(toHash):\\n sha256 = getSHA256Hex(toHash)\\n pid = sha256[0:32]\\n return pid\",\n \"def put_pid(html):\\n pid = 1\\n while \\\"<p>\\\" in html:\\n pttn = \\\"<p id=\\\\\\\"p\\\"+str(pid)+\\\"\\\\\\\">\\\"\\n html = html.replace(\\\"<p>\\\", pttn, 1)\\n pid += 1\\n return html\",\n \"def find_prod_ids(dist_list, no_prod):\\n list_of_prod = []\\n for worker in dist_list:\\n\\n if len(list_of_prod) < no_prod:\\n list_of_prod.append(worker)\\n\\n else:\\n\\n for i in list_of_prod:\\n\\n if i[1] > worker[1]:\\n list_of_prod.remove(i)\\n list_of_prod.append(worker)\\n worker = i\\n\\n else:\\n\\n continue\\n PIDs = []\\n for i in list_of_prod:\\n PIDs.append(i[0])\\n PIDs.sort()\\n return (PIDs)\",\n \"def test_pid_ccs1():\\n d = bivariates['gband']\\n pid = PID_CCS(d, ((0,), (1,)), (2,))\\n assert pid[((0,), (1,))] == pytest.approx(0.81127812445913283)\\n assert pid[((0,),)] == pytest.approx(0.5)\\n assert pid[((1,),)] == pytest.approx(0.5)\\n assert pid[((0, 1),)] == pytest.approx(0.0)\",\n \"def getmypid():\\n raise NotImplementedError()\",\n \"def _translate_line_to_pid_pair(self, line):\",\n \"def pidof(process_name):\\n\\n\\tpids = []\\n\\n\\tif 'licornd' in process_name:\\n\\t\\t# licorn / linux 3.x specifiq : we can match 'licornd/wmi'\\n\\t\\t# faster than 'licornd-wmi', and in some case the 'cmdline'\\n\\t\\t# is empty, whereas the 'comm' is not.\\n\\t\\tnames = [ process_name, process_name.replace('/', '-') ]\\n\\n\\telse:\\n\\t\\tnames = [ process_name ]\\n\\n\\tfor entry in os.listdir('/proc'):\\n\\t\\tif entry.isdigit():\\n\\t\\t\\ttry:\\n\\n\\t\\t\\t\\tif cgroup and open('/proc/%s/cpuset' % entry).read().strip() != cgroup:\\n\\t\\t\\t\\t\\tlogging.progress(_(u'Skipped process @{0} which is not '\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\tu'in the same cgroup.').format(entry))\\n\\t\\t\\t\\t\\tcontinue\\n\\n\\t\\t\\t\\ttry:\\n\\t\\t\\t\\t\\t# Linux 3.x only\\n\\t\\t\\t\\t\\tcommand_line1 = open('/proc/%s/comm' % entry).read().strip()\\n\\t\\t\\t\\texcept:\\n\\t\\t\\t\\t\\tcommand_line1 = ''\\n\\n\\t\\t\\t\\tcommand_line2 = open('/proc/%s/cmdline' % entry).read().strip()\\n\\n\\t\\t\\t\\tfor pname in names:\\n\\t\\t\\t\\t\\tif pname == command_line1 or pname+'\\\\0' in command_line2:\\n\\t\\t\\t\\t\\t\\tpids.append(int(entry))\\n\\n\\t\\t\\texcept (IOError, OSError), e:\\n\\t\\t\\t\\t# in rare cases, the process vanishes during iteration. This\\n\\t\\t\\t\\t# is harmless. Any other error is not cool, raise it.\\n\\t\\t\\t\\tif e.errno != errno.ENOENT:\\n\\t\\t\\t\\t\\traise e\\n\\n\\treturn pids\",\n \"def usePIDOutput(self, output):\\n self.motor.pidWrite(output)\",\n \"def IDCG_p(topic, p):\\n lbl_scores = gold_topic_labels[topic].items() # (label, score) list\\n top_p = sorted(lbl_scores, key=lambda x: x[1], reverse=True)[:p]\\n idcg = 0\\n for idx, (label, rel) in enumerate(top_p):\\n rank = idx + 1\\n if idx == 0:\\n idcg += rel\\n continue\\n idcg += rel/ math.log(rank,2)\\n return idcg\",\n \"def test_pid_ig1():\\n d = bivariates['and']\\n pid = PID_IG(d, ((0,), (1,)), (2,))\\n assert pid[((0,), (1,))] == pytest.approx(0.08283, abs=1e-4)\\n assert pid[((0,),)] == pytest.approx(0.22845, abs=1e-4)\\n assert pid[((1,),)] == pytest.approx(0.22845, abs=1e-4)\\n assert pid[((0, 1),)] == pytest.approx(0.27155, abs=1e-4)\",\n \"def myID() -> np.int:\\r\\n return 304976335\",\n \"def myID() -> np.int:\\r\\n return 304976335\",\n \"def GenDistinctId(self):\\t\\n \\\"\\\"\\\"4 bits to unique a machine \\\\\\n\\t5 bits for processes\\\"\\\"\\\"\\n\\tmachineId = format(self.mid, 4)\\n processId = format(self.pid) \\n \\treturn machineId + processId\",\n \"def _pid(self, name):\\n return self.pid_lookup[name]\",\n \"def process_id(job_id):\\n pass # Not implemented yet\",\n \"def process():\",\n \"def pids():\\n stream = os.popen(\\\"ps aux | grep '[m]itm' | awk '{print $2}'\\\")\\n return stream.read()\",\n \"def pid(self):\\n\\t\\treturn self.__pid\",\n \"def findPIDs(name, user = os.getpid()):\\n\\n pids = []\\n\\n ps = subprocess.Popen(['ps', '-u', user, 'w'], stdout=subprocess.PIPE).communicate()[0]\\n processes = ps.split('\\\\n')\\n\\n for line in processes:\\n if len(line.split()) < 5:\\n continue\\n if re.match(name, line.split()[4]):\\n #Then we have matching process\\n pids.append(line.split()[0])\\n\\n return pids\",\n \"def get_num_pids(self, data):\\n return self.parse_data(data)[0]\",\n \"def pid(self, drive, p=None, i=None, d=None):\\n if p is None:\\n # get proportional band\\n self.__ser__.write(\\\"RP{}\\\\r\\\".format(drive).encode())\\n self.__ser__.flush()\\n p = str2float(self.__ser__.read_until('\\\\r'))\\n else:\\n # set proportional band\\n self.__ser__.write(\\\"SP{} {}\\\\r\\\".format(drive, p).encode())\\n self.__ser__.flush()\\n p = self.rcvd_ok()\\n if i is None:\\n # get integral band\\n self.__ser__.write(\\\"RI{}\\\\r\\\".format(drive).encode())\\n self.__ser__.flush()\\n i = str2float(self.__ser__.read_until('\\\\r'))\\n else:\\n # set integral band\\n self.__ser__.write(\\\"SI{} {}\\\\r\\\".format(drive, i).encode())\\n self.__ser__.flush()\\n i = self.rcvd_ok()\\n if d is None:\\n # get derivative band\\n self.__ser__.write(\\\"RD{}\\\\r\\\".format(drive).encode())\\n self.__ser__.flush()\\n d = str2float(self.__ser__.read_until('\\\\r'))\\n else:\\n # set derivative band\\n self.__ser__.write(\\\"SD{} {}\\\\r\\\".format(drive, d).encode())\\n self.__ser__.flush()\\n d = self.rcvd_ok()\\n return((p, i, d))\",\n \"def test_pid_proj2():\\n d = bivariates['reduced or']\\n pid = PID_IG(d, [[0], [1]], [2])\\n assert pid[((0,), (1,))] == pytest.approx(-0.03122, abs=1e-4)\\n assert pid[((0,),)] == pytest.approx(0.34250, abs=1e-4)\\n assert pid[((1,),)] == pytest.approx(0.34250, abs=1e-4)\\n assert pid[((0, 1),)] == pytest.approx(0.34622, abs=1e-4)\",\n \"def ppid(self):\\n return self._ppid\",\n \"def get_pids(self, file_path, pid):\\n if 'cuhk03' in file_path: \\n prefix = 'cuhk'\\n else: \\n prefix = file_path.split('/')[1]\\n return prefix + '_' + str(pid)\",\n \"def runPidGen ( tree , ## initial tree/chain to be updated \\n pidgen , ## PidGen object \\n newpid , ## name of new PID variable \\n seed = None , ## random seed\\n silent = False , ## silent ?\\n variants = False , ## add alterbvative models?\\n parallel = False , ## use parallel processing?\\n **kwargs ) : ## arguments for parallel processing (WorkManager)\\n\\n assert isinstance ( tree , ROOT.TTree ) and tree , \\\"Invalid 'tree' argument!\\\"\\n assert isinstance ( pidgen , PidGen ) , \\\"Invalid 'pidgen' argument!\\\"\\n\\n assert not newpid in tree.branches() ,\\\"`Branch' %s already exists!\\\" % newpid \\n\\n old_branches = set ( tree.branches() ) | set ( tree.leaves() )\\n\\n\\n ## parallel processing?\\n if parallel and isinstance ( tree , ROOT.TChain ) and 1 < len ( tree.files() ) :\\n \\n from ostap.trees.trees import Chain\\n ch = Chain ( tree ) \\n cname = tree.name\\n \\n ## create the task \\n task = AddPidGen ( newpid = newpid ,\\n pidgen = pidgen ,\\n seed = seed ,\\n variants = variants )\\n \\n wmgr = WorkManager ( silent = silent , **kwargs )\\n trees = ch.split ( max_files = 1 )\\n \\n wmgr.process ( task , trees )\\n \\n new_chain = ROOT.TChain ( cname )\\n for f in ch.files : new_chain.Add ( f )\\n \\n ## sequential processing \\n else :\\n\\n if kwargs :\\n logger.warning ( \\\"runPidGen: ignore arguments : %s\\\" % [ k for k in kwargs.keys( ) ] )\\n \\n from ostap.utils.utils import root_random_seed\\n with root_random_seed ( seed ) :\\n \\n from ostap.math.make_fun import make_fun3\\n the_function = ( make_fun3 ( pidgen ) , \\n pidgen.pt_log_var ,\\n pidgen.eta_var ,\\n pidgen.ntrk_log_var )\\n \\n ## add new branch \\n new_chain = tree.add_new_branch ( newpid ,\\n the_function , \\n verbose = not silent ,\\n report = False )\\n \\n if variants : \\n vars = pidgen.variants ()\\n for var in progress_bar ( vars , silent = silent , description = ' %+d variants:' % len ( vars ) ) : \\n varpg = PidGen ( pt_log_var = pidgen.pt_log_var ,\\n eta_var = pidgen.eta_var ,\\n ntrk_log_var = pidgen.ntrk_log_var ,\\n config = pidgen.config ,\\n dataset = pidgen.dataset ,\\n variant = var ,\\n silent = True )\\n ## add new variable \\n new_chain = runPidGen ( new_chain ,\\n varpg ,\\n '%s_%s' % ( newpid , var ) ,\\n seed = seed ,\\n silent = True ,\\n variants = False ) \\n ## final summary table \\n if not silent :\\n \\n title = 'PidGen(%s): configuration&statistics' % pidgen.variant \\n logger.info ( '%s:\\\\n%s' % ( title , pidgen.table ( title , prefix = '# ' ) ) )\\n\\n new_branches = set ( new_chain.branches() ) | set ( new_chain.leaves() )\\n new_branches = new_branches - old_branches\\n if new_branches :\\n n = len ( new_branches )\\n if 1 == n : title = 'Added %s branch to TTree/TChain' % n \\n else : title = 'Added %s branches to TTree/TChain' % n \\n table = new_chain.table ( new_branches , title = title , prefix = '# ' )\\n logger.info ( '%s:\\\\n%s' % ( title , table ) ) \\n \\n return new_chain\",\n \"def get_PID(self):\\n return self.PID\",\n \"def process():\\n interesting_procs = set(INTERESTING_PROCESSES)\\n\\n pids = psutil.pids()\\n info = {\\n \\\"stats_type\\\": \\\"process\\\",\\n \\\"proc\\\": {\\n \\\"count\\\": len(pids),\\n }\\n }\\n proc_root = os.environ.get(\\\"PROC_ROOT\\\", \\\"/proc\\\")\\n for pid in pids:\\n proc_info = proc.core.Process.from_path(\\n os.path.join(proc_root, str(pid)))\\n\\n proc_name = get_proc_name(proc_info, interesting_procs)\\n if not proc_name:\\n continue\\n\\n if 'sshd' in proc_name and ':' in proc_info.cmdline:\\n continue\\n\\n if proc_name not in info['proc']:\\n info['proc'][proc_name] = {\\n 'running': proc_info.state in ('R', 'S', 'D', 'T', 'W'),\\n 'pid': proc_info.pid,\\n 'ppid': proc_info.ppid,\\n 'user_time': int(proc_info.stat_fields[16]), # cutime\\n 'sys_time': int(proc_info.stat_fields[17]), # cstime\\n 'vsize': proc_info.vsize,\\n 'rss': proc_info.rss,\\n 'voluntary_ctxt_switches': int(proc_info.status_fields[\\n 'voluntary_ctxt_switches']),\\n 'nonvoluntary_ctxt_switches': int(proc_info.status_fields[\\n 'nonvoluntary_ctxt_switches']),\\n 'age': proc_info.runtime,\\n 'count': 1\\n }\\n else:\\n pinfo = info['proc'][proc_name]\\n pinfo['count'] += 1\\n\\n def append(dest, field, value):\\n \\\"\\\"\\\"Append values for an existing process.\\\"\\\"\\\"\\n if isinstance(dest[field], list):\\n dest[field].append(value)\\n else:\\n dest[field] = [dest[field], value]\\n\\n # append('state', proc_info.state)\\n append(pinfo, 'pid', proc_info.pid)\\n append(pinfo, 'ppid', proc_info.ppid)\\n pinfo['user_time'] += int(proc_info.stat_fields[16]) # cutime\\n pinfo['sys_time'] += int(proc_info.stat_fields[17]) # cstime\\n pinfo['vsize'] += proc_info.vsize\\n pinfo['rss'] += proc_info.rss\\n pinfo['voluntary_ctxt_switches'] = \\\\\\n int(proc_info.status_fields['voluntary_ctxt_switches'])\\n pinfo['nonvoluntary_ctxt_switches'] = \\\\\\n int(proc_info.status_fields['nonvoluntary_ctxt_switches'])\\n append(pinfo, 'age', proc_info.runtime)\\n\\n return info\",\n \"def ews_pid (tag):\\n\\n return mapitags.PROP_ID(tag)\",\n \"def PIDs():\\n from ctypes import windll,c_ulong,byref,sizeof\\n PIDs = (c_ulong*512)()\\n size_of_PIDs = c_ulong()\\n windll.psapi.EnumProcesses(byref(PIDs),sizeof(PIDs),byref(size_of_PIDs))\\n nPIDs = size_of_PIDs.value/sizeof(c_ulong())\\n pidProcess = sorted([int(i) for i in PIDs][:nPIDs])\\n return pidProcess\",\n \"def pid_controller_calculator(pid_parameters, error, duration=0.17):\\n k_p = pid_parameters[0]\\n k_i = pid_parameters[1]\\n k_d = pid_parameters[2]\\n error = np.array(error)\\n proportional_term = k_p * error[-1]\\n integrational_term = k_i * duration * np.sum(error)\\n differential_term = k_d * (error[-1] - error[-2]) / duration\\n output = np.sqrt(\\n (proportional_term + integrational_term + differential_term) * 22)\\n return output\",\n \"def get_process_speed(self, pid):\\n raise NotImplementedError()\",\n \"def get_pid(name):\\n try: \\n for process in psutil.process_iter():\\n try:\\n proc = process.as_dict(attrs=['pid', 'name'])\\n if name in proc['name']:\\n pid = proc['pid']\\n logging.info(f\\\"Found PID {pid} for {name}\\\")\\n return int(pid) \\n except (psutil.NoSuchProcess, psutil.AccessDenied , psutil.ZombieProcess) :\\n pass \\n except Exception as e:\\n logging.exception(f\\\"EXCEPTION: {e} \\\\n Full stack trace: \\\\n\\\", exc_info=1)\",\n \"def frequency(self, pt):\\n return math.floor(abs(self.id - pt.id) / 2)\",\n \"def def_pid(self,pid):\\n self.pid=int(pid)\",\n \"def sub_processor(lock, pid, video_list):\\r\\n text = 'processor %d' % pid\\r\\n with lock:\\r\\n progress = tqdm.tqdm(\\r\\n total=len(video_list),\\r\\n position=pid,\\r\\n desc=text\\r\\n )\\r\\n for i in range(len(video_list)):\\r\\n video_name = video_list[i]\\r\\n \\\"\\\"\\\" Read result csv file \\\"\\\"\\\"\\r\\n df = pd.read_csv(os.path.join(config.post_csv_load_dir, video_name + \\\".csv\\\"))\\r\\n \\\"\\\"\\\" Calculate final score of proposals \\\"\\\"\\\"\\r\\n df['score'] = df.iou.values[:] * df.start.values[:] * df.end.values[:]\\r\\n if len(df) > 1:\\r\\n df = softNMS(df)\\r\\n df = df.sort_values(by=\\\"score\\\", ascending=False)\\r\\n video_info = video_dict[video_name]\\r\\n video_duration = video_info[\\\"duration_second\\\"]\\r\\n proposal_list = []\\r\\n\\r\\n for j in range(min(top_number, len(df))):\\r\\n tmp_proposal = {}\\r\\n tmp_proposal[\\\"score\\\"] = df.score.values[j]\\r\\n tmp_proposal[\\\"segment\\\"] = [max(0, df.xmin.values[j]) * video_duration,\\r\\n min(1, df.xmax.values[j]) * video_duration]\\r\\n tmp_proposal[\\\"label\\\"] = \\\"行走\\\"\\r\\n # tmp_proposal[\\\"label\\\"] = \\\"Fun sliding down\\\"\\r\\n proposal_list.append(tmp_proposal)\\r\\n result_dict[video_name] = proposal_list\\r\\n with lock:\\r\\n progress.update(1)\\r\\n\\r\\n with lock:\\r\\n progress.close()\",\n \"def get_pids(self, file_path, pid):\\n if 'cuhk03' in file_path:\\n prefix = 'cuhk'\\n else:\\n prefix = file_path.split('/')[1]\\n return prefix + '_' + str(pid)\",\n \"def pidof(processname = None):\\n processname = os.path.basename(processname)\\n pidpath = os.path.join(pid_path,processname + \\\".pid\\\")\\n if processname is not None and os.path.exists(pidpath):\\n f = open (pidpath)\\n pids = f.readlines()\\n f.close()\\n return pids\\n else:\\n return False\",\n \"def get_pids(pid):\\n\\n pids=set([pid])\\n for child in get_children(pid):\\n pids.update(traverse_tree(child,pids))\\n \\n return list(pids)\",\n \"def get_pid_processor(pid):\\n if pid != 0:\\n pid_str = pid\\n else:\\n pid_str = 'self'\\n\\n # read procfs /proc/PID/stat file to get info about processor\\n # that PID was scheduled on last time\\n try:\\n with open(\\\"/proc/{}/stat\\\".format(pid_str)) as stat_file:\\n proc_stat = stat_file.readline().strip().split(' ')\\n return int(proc_stat[39])\\n except EnvironmentError:\\n return -1\",\n \"def getPMid(inF, i):\\n\\n return inF.root.Sensors.DataPMT[i][0]\",\n \"def update_pid_running_on_dpdk_cpu(self):\\n #cpu_list = self.get_cpu_list_by_mask\",\n \"def _get_pid(self):\\n ps_txt = six.ensure_str(self.controller.run(\\n args=[\\\"ps\\\", \\\"ww\\\", \\\"-u\\\"+str(os.getuid())]\\n ).stdout.getvalue()).strip()\\n lines = ps_txt.split(\\\"\\\\n\\\")[1:]\\n\\n for line in lines:\\n if line.find(\\\"ceph-{0} -i {1}\\\".format(self.daemon_type, self.daemon_id)) != -1:\\n log.info(\\\"Found ps line for daemon: {0}\\\".format(line))\\n return int(line.split()[0])\\n log.info(\\\"No match for {0} {1}: {2}\\\".format(\\n self.daemon_type, self.daemon_id, ps_txt\\n ))\\n return None\",\n \"def worker(nums, outdict):\\n print(threading.current_thread().name)\\n print (\\\"pid:\\\", os.getpid())\\n for n in nums:\\n outdict[n] = factorize_naive(n)\",\n \"def run_numbers():\\n if run_nos:\\n # Get task names\\n tasks = []\\n for rn in dcm_dict.keys():\\n tasks.append(dcm_dict[rn]['task_name'])\\n # Assign run numbers\\n for tsk in set(tasks):\\n n_runs = sum(i == tsk for i in tasks)\\n if n_runs == 1:\\n for rn in dcm_dict.keys():\\n if dcm_dict[rn]['task_name'] == tsk:\\n # Add in the 'task' prefix required by BIDS format if missing from name\\n if not tsk[0:4] == 'task':\\n dcm_dict[rn]['out_name'] = 'task-'+tsk+'_run-01'\\n else:\\n dcm_dict[rn]['out_name'] = tsk+'_run-01'\\n elif n_runs > 1:\\n task_runs = []\\n run_times = []\\n for rn in dcm_dict.keys():\\n if dcm_dict[rn]['task_name'] == tsk:\\n task_runs.append(rn)\\n run_times.append(dcm_dict[rn]['start_time'].timestamp())\\n idx_order = sorted(range(len(run_times)), key=lambda k: run_times[k])\\n for i in idx_order:\\n if not tsk[0:4] == 'task':\\n dcm_dict[task_runs[i]]['out_name'] = 'task-'+tsk+'_run-0'+str(i+1)\\n else:\\n dcm_dict[task_runs[i]]['out_name'] = tsk+'_run-0'+str(i+1)\\n else:\\n for rn in dcm_dict.keys():\\n dcm_dict[rn]['out_name'] = dcm_dict[rn]['task_name']\",\n \"def get_cpu_clock_cycles_of_pid(pid):\\n try:\\n with open(LINUX_PROCESS_STAT_LOCATION % pid, 'r') as f:\\n pid_entries = f.read().split(' ')\\n except IOError:\\n return None\\n\\n pid_cycles = 0\\n if len(pid_entries) > 14:\\n pid_cycles = int(pid_entries[13]) + int(pid_entries[14])\\n return pid_cycles\",\n \"def set_pid(self, pid): # type: (int) -> None\\n for i in range(len(self.__target_pids)):\\n if self.__target_pids[i] == \\\"$$TBD\\\":\\n self.__target_pids[i] = pid\\n break\",\n \"def to_id_matrix(f):\\n if path.isfile(\\\"data/\\\"+f+\\\".npy\\\"):\\n return 0\\n \\n # Get a worker number to position the progress bar\\n global idxQueue\\n thr_idx = idxQueue.get()\\n\\n setproctitle(f\\\"RNANet statistics.py Worker {thr_idx+1} to_id_matrix({f})\\\")\\n\\n if not path.isfile(f\\\"{path_to_seq_data}/realigned/{f}_3d_only.stk\\\"):\\n warn(f\\\"File not found: {path_to_seq_data}/realigned/{f}_3d_only.stk\\\")\\n align = AlignIO.read(f\\\"{path_to_seq_data}/realigned/{f}_3d_only.stk\\\", \\\"stockholm\\\")\\n names = [ x.id for x in align if '[' in x.id ]\\n del align\\n \\n pbar = tqdm(total = len(names)*(len(names)-1)*0.5, position=thr_idx+1, desc=f\\\"Worker {thr_idx+1}: {f} idty matrix\\\", unit=\\\"comparisons\\\", leave=False)\\n pbar.update(0)\\n \\n # Prepare the job\\n process = subprocess.Popen(shlex.split(f\\\"esl-alipid --rna --noheader --informat stockholm {path_to_seq_data}/realigned/{f}_3d_only.stk\\\"), stdout=subprocess.PIPE, stderr=subprocess.PIPE)\\n id_matrix = np.zeros((len(names), len(names)))\\n cnt = 0\\n while not cnt or process.poll() is None:\\n output = process.stdout.read()\\n if output:\\n lines = output.strip().split(b'\\\\n')\\n for l in lines:\\n cnt += 1\\n line = l.split()\\n s1 = line[0].decode('utf-8')\\n s2 = line[1].decode('utf-8')\\n score = line[2].decode('utf-8')\\n id1 = names.index(s1)\\n id2 = names.index(s2)\\n id_matrix[id1, id2] = float(score)\\n pbar.update(1)\\n if cnt != len(names)*(len(names)-1)*0.5:\\n warn(f\\\"{f} got {cnt} updates on {len(names)*(len(names)-1)*0.5}\\\")\\n if process.poll() != 0:\\n l = process.stderr.read().strip().split(b'\\\\n')\\n warn(\\\"\\\\n\\\".join([ line.decode('utf-8') for line in l ]))\\n pbar.close()\\n\\n np.save(\\\"data/\\\"+f+\\\".npy\\\", id_matrix)\\n\\n idxQueue.put(thr_idx) # replace the thread index in the queue\\n setproctitle(f\\\"RNANet statistics.py Worker {thr_idx+1} finished\\\")\\n return 0\",\n \"def emit(self, pid):\\n print \\\"Emit with pid: {}\\\".format(pid)\\n if pid is None:\\n return False\\n metrics = {'cpu': 0,\\n 'ram': 1,\\n 'net': 2,\\n 'bytes_sent': 1,\\n 'bytes_recv': 1,\\n 'packets_sent': 1,\\n 'packets_recv': 1,\\n 'errin': 0,\\n 'errout': 0,\\n 'dropin': 0,\\n 'dropout': 0,\\n 'disk': 0,\\n 'files': 0,\\n 'time': calendar.timegm(time.gmtime()) * 1000}\\n #return False # prevent this\\n ##########################################################################################################\\n # psutil read metrics\\n try:\\n # self.proc = psutil.Process(pid)\\n process_name = None\\n if self.personal_cloud.lower() == \\\"stacksync\\\":\\n if os.name == 'nt':\\n process_name = \\\"javaw.exe\\\"\\n elif os.name == \\\"posix\\\":\\n process_name = \\\"java\\\"\\n\\n elif self.personal_cloud.lower() == \\\"dropbox\\\":\\n if os.name == 'nt':\\n process_name = \\\"Dropbox.exe\\\"\\n elif os.name == \\\"posix\\\":\\n process_name = \\\"dropbox\\\"\\n elif self.personal_cloud.lower() == \\\"owncloud\\\":\\n process_name = \\\"owncloudcmd\\\"\\n elif self.personal_cloud.lower() == 'mega':\\n process_name = \\\"megacmd\\\"\\n\\n if self.proc is None or self.proc.pid != pid:\\n self.proc = psutil.Process(pid)\\n\\n if process_name == self.proc.name() or \\\"owncloudcmd\\\" == process_name or \\\"megacmd\\\" == process_name:\\n print \\\"OKEY match {} == {}\\\".format(self.proc.name(), process_name)\\n else:\\n print \\\"sync client does not match: {}\\\".format(process_name)\\n return False\\n\\n except Exception as ex:\\n print \\\"sync client is not running! {}\\\".format(pid)\\n print ex.message\\n return False # exit as the process is not alive.\\n\\n ##########################################################################################################\\n print \\\"PID: {} [{}]\\\".format(pid, self.personal_cloud.lower())\\n try:\\n if self.personal_cloud.lower() == \\\"stacksync\\\":\\n # todo lookup for stacksync process here => using psutil\\n cpu_usage = int(math.ceil(self.proc.cpu_percent(0)))\\n ram_usage = self.proc.memory_info().rss\\n metrics['cpu'] = cpu_usage\\n metrics['ram'] = ram_usage\\n elif self.personal_cloud.lower() == \\\"owncloud\\\":\\n cpu_usage = int(math.ceil(self.proc.children()[0].cpu_percent(interval=1)))\\n ram_usage = self.proc.children()[0].memory_info().rss\\n metrics['cpu'] = cpu_usage\\n metrics['ram'] = ram_usage\\n elif self.personal_cloud.lower() == \\\"mega\\\":\\n cpu_usage = int(math.ceil(self.proc.children()[0].cpu_percent(interval=1)))\\n ram_usage = self.proc.children()[0].memory_info().rss\\n metrics['cpu'] = cpu_usage\\n metrics['ram'] = ram_usage\\n elif self.personal_cloud.lower() == \\\"dropbox\\\":\\n # todo lookup for dropbox process here => using psutil\\n cpu_usage = int(math.ceil(self.proc.cpu_percent(0)))\\n ram_usage = self.proc.memory_info().rss\\n metrics['cpu'] = cpu_usage\\n metrics['ram'] = ram_usage\\n except Exception as e:\\n print e.message\\n\\n # assign the network usage metric\\n\\n if self.prev_metric is not None:\\n # do nothing because its the first emit ant there are no previous metric to compare\\n # last_net = self.prev_metric['metrics']['net']\\n last_time = self.prev_metric['metrics']['time']\\n\\n curr_net_counter = psutil.net_io_counters(pernic=True)['eth0'] # read the bytes from somewhere\\n curr_time = metrics['time']\\n elapsed_time = (curr_time - last_time) / 1000 # segons\\n for key, value in curr_net_counter.__dict__.items():\\n metrics[key] = (value - getattr(self.prev_net_counter, key)) / elapsed_time # unit is seconds\\n self.prev_net_counter = curr_net_counter\\n # assign hard drive usage metric\\n\\n if os.name == \\\"nt\\\":\\n drive_usage = \\\"1234\\\"\\n elif os.name == \\\"posix\\\":\\n drive_usage_cmd = ['/usr/bin/du', '-ks', '/home/vagrant/{}'.format(self.personal_folder)]\\n drive_usage_output = subprocess.Popen(drive_usage_cmd, stdout=subprocess.PIPE)\\n drive_usage = drive_usage_output.stdout.read()\\n try:\\n metrics['disk'] = int(drive_usage.split('\\\\t')[0]) # kilo bytes cast string to int\\n except Exception as ex:\\n print \\\"invalid literal for... memory unit\\\"\\n metrics['disk'] = 1\\n # assign add folder num of files metric\\n\\n\\n\\n\\n if os.name == \\\"nt\\\":\\n num_files = \\\"123\\\"\\n elif os.name == \\\"posix\\\":\\n find_cmd = '/usr/bin/find /home/vagrant/{} -type f'.format(self.personal_folder).split()\\n proc_find = subprocess.Popen(find_cmd, stdout=subprocess.PIPE)\\n wc_cmd = '/usr/bin/wc -l'.split()\\n proc_wc = subprocess.Popen(wc_cmd, stdin=proc_find.stdout, stdout=subprocess.PIPE)\\n num_files = proc_wc.communicate()[0]\\n try:\\n metrics['files'] = int(num_files.split('\\\\t')[0])\\n except Exception as ex:\\n print \\\"invalid literal for... file counter\\\"\\n\\n net_stats = self.traffic_monitor.notify_stats()\\n # z = dict(x.items() + y.items()) => metrics\\n # envez de esto dict join\\n metrics['data_rate_size_up'] = net_stats['data_rate']['size_up']\\n metrics['data_rate_size_down'] = net_stats['data_rate']['size_down']\\n metrics['data_rate_pack_up'] = net_stats['data_rate']['pack_up']\\n metrics['data_rate_pack_down'] = net_stats['data_rate']['pack_down']\\n metrics['meta_rate_size_up'] = net_stats['meta_rate']['size_up']\\n metrics['meta_rate_size_down'] = net_stats['meta_rate']['size_down']\\n metrics['meta_rate_pack_up'] = net_stats['meta_rate']['pack_up']\\n metrics['meta_rate_pack_down'] = net_stats['meta_rate']['pack_down']\\n\\n '''\\n {'data_rate':\\n {'size_up': 0.471, 'pack_down': 0.00175, 'pack_up': 0.00225, 'size_down': 0.612},\\n 'meta_rate':\\n {'size_up': 0.0, 'pack_down': 0.0, 'pack_up': 0.0, 'size_down': 0.0},\\n 'time': 1461065156000\\n }\\n '''\\n\\n tags = ''\\n if tags == '':\\n tags = {\\n 'profile': self.receipt,\\n 'credentials': 'pc_credentials',\\n 'client': self.personal_cloud.lower(),\\n }\\n\\n data = {\\n 'metrics': metrics,\\n 'tags': tags\\n }\\n self.prev_metric = data # update the last emited metric\\n msg = json.dumps(data)\\n print msg\\n\\n self.channel.basic_publish(\\n exchange='metrics',\\n routing_key=self.hostname,\\n body=msg)\\n\\n return True\",\n \"def set_default_pids(config, gState):\\n axes = dict(RADEC = \\\"raDec\\\", ROT = \\\"rot\\\", FOCUS = \\\"focus\\\", SCALE = \\\"scale\\\")\\n for axis in config.options('PID'):\\n axis = axes[axis.upper()]\\n Kp, Ti_min, Ti_max, Td, Imax, nfilt = [float(v) for v in config.get('PID', axis).split()] \\n gState.set_pid_defaults(axis, Kp=Kp, Ti_min=Ti_min, Ti_max=Ti_max, Td=Td, Imax=Imax, nfilt=int(nfilt))\\n gState.pid[axis].setPID(Kp=Kp, Ti=Ti_min, Td=Td, Imax=Imax, nfilt=nfilt)\",\n \"def pid(self):\\n return self.__pid\",\n \"def collect_pidin(self, log_dir):\\n log_type = \\\"pidin\\\"\\n log_name = \\\"pidin.txt\\\"\\n cmd = \\\"pidin > /tmp/{}\\\".format(log_name)\\n\\n self._collect_log(log_type, log_dir, log_name, cmd)\",\n \"def free_pid():\\n host, pid, tid = get_process_id()\\n while True:\\n # PIDs are often restricted to a small range. On Linux the range >32k is by default not used.\\n pid = random.randint(33000, 65000)\\n if not process_alive(host, pid, tid):\\n return pid\",\n \"def test_003_pid(self):\\n HEADING()\\n pid = self.db.pid()\\n print (pid)\\n assert True\",\n \"def pids(node, java_class):\\n cmd = \\\"ps -C java -wwo pid,args | grep '%s' | awk -F' ' '{print $1}'\\\" % java_class\\n\\n return [int(pid) for pid in node.account.ssh_capture(cmd, allow_fail=True)]\",\n \"def calc_conservation(aln):\\n\\n length = len(aln.values()[0])\\n seqs = aln.values()\\n percids = []\\n\\n # find identity positions\\n for i in xrange(length):\\n chars = util.hist_dict(util.cget(seqs, i))\\n if \\\"-\\\" in chars:\\n del chars[\\\"-\\\"]\\n\\n if len(chars) == 0:\\n percids.append(0.0)\\n else:\\n pid = max(chars.values()) / float(len(aln))\\n percids.append(pid)\\n return percids\",\n \"def set_pid(self, kp, ki, kd):\\n for vehicle_id in self.vehicle_ids:\\n self.frenets[vehicle_id].set_pid(kp, ki, kd)\",\n \"def freq():\",\n \"def __init__(self,x,dof):\\n self.x=x\\n self.dof=dof\\n numSeg=10\\n p1=self.P(numSeg)\\n p2=0\\n while True:\\n numSeg*=2\\n p2=self.P(numSeg)\\n if self.checarPs(p1,p2):\\n break\\n else:\\n p1=p2\\n print(round(p2,5))\",\n \"def pid(self):\\n if self.proc is None:\\n return 0\\n return self._pid()\",\n \"def answer():\\n for k in range(2,3000):\\n for j in range(k-1,0,-1):\\n pj, pk = P(j), P(k)\\n #print( j, k, pj, pk )\\n if isPent(pk-pj):\\n #print( j, k, pj, pk, pk+pj, isPent(pk+pj), pk-pj )\\n if isPent(pk+pj) and isPent(pk-pj):\\n return pk-pj\",\n \"def __next_shape_id(self):\\n cNvPrs = self.__spTree.xpath('//p:cNvPr', namespaces=_nsmap)\\n ids = [int(cNvPr.get('id')) for cNvPr in cNvPrs]\\n ids.sort()\\n # first gap in sequence wins, or falls off the end as max(ids)+1\\n next_id = 1\\n for id in ids:\\n if id > next_id:\\n break\\n next_id += 1\\n return next_id\",\n \"def __get_pid(self):\\n str_pid = os.getpid() + 65535\\n str_hex_pid = hex(str_pid)[2:]\\n return str_hex_pid\",\n \"def setup_process_stats(pid):\\n return psutil.Process(pid)\",\n \"def setChildPIDs(self):\\n\\t\\tpids = []\\n\\t\\tfor proc in process_iter():\\n\\t\\t\\tfor child in self.expectedChildren:\\n\\t\\t\\t\\tif child == proc.name():\\n\\t\\t\\t\\t\\tif proc.parent().name() == \\\"Python\\\": # Hardcoded string comparison. Sue me.\\n\\t\\t\\t\\t\\t\\tpids.append(proc.pid)\\n\\t\\tself.pids = pids\",\n \"def ncore(self):\",\n \"def Pp(nccd):\\n return (128.1-56.9) * (nccd - 1) / (6-1) + 56.9\",\n \"def pids(self):\\n return self._pidToProcess.iterkeys()\",\n \"def nid2partid(self, nids, ntype=...):\\n ...\",\n \"def nid2partid(self, nids, ntype=...):\\n ...\",\n \"def identify_processes(self) -> Dict[int, dict]:\\n\\n processes = {}\\n\\n for process in self.behavior[\\\"generic\\\"]:\\n\\n proc_name, proc_path = split_path(process[\\\"process_path\\\"])\\n\\n processes[int(process[\\\"pid\\\"])] = {\\n FieldNames.PROCESS_IMAGE: proc_name,\\n FieldNames.PROCESS_IMAGE_PATH: proc_path,\\n FieldNames.PROCESS_ID: int(process[\\\"pid\\\"]),\\n }\\n\\n return processes\",\n \"def test_pnc(id):\\n if id < int('0x10ffffff', 16): # 285212671\\n return 'player'\\n elif id < int('0x40ffffff', 16): # 1090519039\\n return 'creature'\\n elif id < int('0x80000fff', 16): # 2147487743\\n return 'npc'\\n else:\\n print 'creature.Id error', id\\n return None\",\n \"def findpc(self):\\n u = -(-can.C.len() + self.P.len() + can.R)/self.V.len()\\n if u >= 0:\\n return self.P + self.V.scale(u), u\\n else:\\n u = (can.C.len() - self.P.len() + can.R)/self.V.len()\\n return self.P + self.V.scale(u), u\",\n \"def process_synthetic_peptides(cluster):\\n total_spectra = 0\\n sequence_counts = dict()\\n\\n for spectrum in cluster.get_spectra():\\n # ignore all none synthetic spectra\\n if \\\"PXD004732\\\" not in spectrum.get_title():\\n continue\\n\\n total_spectra += 1\\n\\n # spectra from this dataset only contain one psm\\n if len(spectrum.psms) != 1:\\n raise Exception(\\\"Unidentified spectrum from project PXD004732 encountered: \\\" + spectrum.get_title())\\n\\n psm = [p for p in spectrum.psms][0]\\n\\n if psm.sequence not in sequence_counts:\\n sequence_counts[psm.sequence] = 1\\n else:\\n sequence_counts[psm.sequence] += 1\\n\\n # done if no synthetic peptides were found\\n if total_spectra == 0:\\n return \\\"0\\\\tNA\\\\tNA\\\"\\n\\n # get the max count\\n max_count = max(sequence_counts.values())\\n\\n # get the matching sequences\\n max_sequences = [s for s in sequence_counts if sequence_counts[s] == max_count]\\n\\n # calculate the ratio\\n max_ratio = max_count / total_spectra\\n\\n return str(total_spectra) + \\\"\\\\t\\\" + str(max_ratio) + \\\"\\\\t\\\" + \\\";\\\".join(max_sequences)\",\n \"def calc_process_coupling(partitions, graph):\\n avg_pc = calc_avg_process_coupling(partitions, graph)\\n if not (len(partitions) or avg_pc) == 0:\\n pc = avg_pc / len(partitions)\\n else:\\n pc = 0\\n return pc\",\n \"def get_num_pids(self, data):\\n pids = set()\\n for items in data:\\n pid = items[1]\\n pids.add(pid)\\n return len(pids)\",\n \"def calculateIdentities(percIdentity, length):\\n return np.floor(percIdentity * length / 100 + 0.5)\",\n \"def __init__(self, pid, period, num_period=None):\\n\\n super(PIDTimedLoop, self).__init__(period, num_period)\\n self._pid = pid\\n self._is_active = pid.poll() is None\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.71910334","0.6614745","0.6562891","0.6562891","0.6499642","0.63020134","0.616472","0.5998051","0.59355164","0.5924834","0.5907015","0.5819289","0.5810391","0.5769309","0.5708543","0.56778383","0.56778383","0.5675718","0.5638636","0.5638505","0.55943847","0.5553763","0.55432653","0.54564303","0.54461485","0.5435159","0.53765106","0.5369094","0.53627986","0.53438497","0.53255165","0.5304847","0.5303941","0.5300217","0.5300217","0.52929586","0.52838165","0.5271652","0.52598035","0.524999","0.5213454","0.5192826","0.518985","0.51804847","0.5179272","0.51764154","0.51691574","0.5163137","0.5160749","0.51544106","0.51543045","0.51539624","0.51456654","0.51386976","0.51380116","0.5134552","0.5119694","0.51010174","0.50981337","0.5087597","0.5070942","0.50655776","0.5056955","0.50467306","0.50252527","0.4996708","0.49941993","0.49939814","0.4980158","0.4970195","0.49565282","0.4955215","0.4953371","0.49482808","0.49445763","0.49422476","0.49365032","0.4936094","0.49292153","0.49261966","0.49200156","0.49163634","0.49159646","0.49143124","0.48896885","0.4888978","0.48815972","0.48808432","0.48714903","0.48635632","0.4862853","0.4862853","0.4862299","0.48621517","0.48419523","0.4841293","0.48330575","0.4830546","0.4829574","0.48232135"],"string":"[\n \"0.71910334\",\n \"0.6614745\",\n \"0.6562891\",\n \"0.6562891\",\n \"0.6499642\",\n \"0.63020134\",\n \"0.616472\",\n \"0.5998051\",\n \"0.59355164\",\n \"0.5924834\",\n \"0.5907015\",\n \"0.5819289\",\n \"0.5810391\",\n \"0.5769309\",\n \"0.5708543\",\n \"0.56778383\",\n \"0.56778383\",\n \"0.5675718\",\n \"0.5638636\",\n \"0.5638505\",\n \"0.55943847\",\n \"0.5553763\",\n \"0.55432653\",\n \"0.54564303\",\n \"0.54461485\",\n \"0.5435159\",\n \"0.53765106\",\n \"0.5369094\",\n \"0.53627986\",\n \"0.53438497\",\n \"0.53255165\",\n \"0.5304847\",\n \"0.5303941\",\n \"0.5300217\",\n \"0.5300217\",\n \"0.52929586\",\n \"0.52838165\",\n \"0.5271652\",\n \"0.52598035\",\n \"0.524999\",\n \"0.5213454\",\n \"0.5192826\",\n \"0.518985\",\n \"0.51804847\",\n \"0.5179272\",\n \"0.51764154\",\n \"0.51691574\",\n \"0.5163137\",\n \"0.5160749\",\n \"0.51544106\",\n \"0.51543045\",\n \"0.51539624\",\n \"0.51456654\",\n \"0.51386976\",\n \"0.51380116\",\n \"0.5134552\",\n \"0.5119694\",\n \"0.51010174\",\n \"0.50981337\",\n \"0.5087597\",\n \"0.5070942\",\n \"0.50655776\",\n \"0.5056955\",\n \"0.50467306\",\n \"0.50252527\",\n \"0.4996708\",\n \"0.49941993\",\n \"0.49939814\",\n \"0.4980158\",\n \"0.4970195\",\n \"0.49565282\",\n \"0.4955215\",\n \"0.4953371\",\n \"0.49482808\",\n \"0.49445763\",\n \"0.49422476\",\n \"0.49365032\",\n \"0.4936094\",\n \"0.49292153\",\n \"0.49261966\",\n \"0.49200156\",\n \"0.49163634\",\n \"0.49159646\",\n \"0.49143124\",\n \"0.48896885\",\n \"0.4888978\",\n \"0.48815972\",\n \"0.48808432\",\n \"0.48714903\",\n \"0.48635632\",\n \"0.4862853\",\n \"0.4862853\",\n \"0.4862299\",\n \"0.48621517\",\n \"0.48419523\",\n \"0.4841293\",\n \"0.48330575\",\n \"0.4830546\",\n \"0.4829574\",\n \"0.48232135\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.5710995"},"document_rank":{"kind":"string","value":"14"}}},{"rowIdx":90499,"cells":{"query":{"kind":"string","value":"calculates PID for x, y and z"},"document":{"kind":"string","value":"def xyzPID(home_lon, home_lat, home_alt,\n lon, lat, alt,\n error_sum, last_error_lon, last_error_lat, prev_time):\n #x PID\n output_lon, last_error_lon, prev_time = calculatePID(home_lon,lon,error_sum, last_error_lon, prev_time)\n #y PID\n output_lat, last_error_lat, prev_time = calculatePID(home_lat,lat,error_sum, last_error_lat, prev_time)\n #z PID\n #calculatePID(home_alt,\n # alt,\n # error_sum, last_error_alt, prev_time)\n \n return output_lon, output_lat, last_error_lat, last_error_lon, prev_time"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def elec_p_xyz_loop(x, y, z):\n U = 0.\n\n r = np.sqrt(x**2 + y**2 + z**2)\n x = x/r\n y = y/r\n z = z/r\n\n npts = x.size\n for i in range(npts-1):\n for j in range(i+1, npts):\n dsq = (x[i]-x[j])**2 + (y[i]-y[j])**2 + (z[i]-z[j])**2\n U += 1./np.sqrt(dsq)\n return U","def cal_pt(self):\n\n if not self.check_def(['E','px','py','pz']):\n sys.exit('Particle error: Quadri impulsion not define (error for pt routine)')\n\n self.pt =math.sqrt(self.px**2+self.py**2)","def computePID(setpoint,\n _input, last_error, prev_time):\n kp = 0.5\n kd = 5\n ki = 0.02\n\n current_time = time.time()\n d_time = current_time - prev_time\n \n error = setpoint - _input\n #print(\"error\", error)\n\n #error_sum += (error * d_time)\n \n d_error = (error - last_error) / d_time\n\n output = kp * error #+ kd * d_error#ki * error_sum + kd * d_error\n last_error = error\n prev_time = current_time\n \n return output, last_error, prev_time","def test_pid_ccs3():\n d = trivariates['anddup']\n pid = PID_CCS(d)\n for atom in pid._lattice:\n if atom == ((0,), (1,), (2,)):\n assert pid[atom] == pytest.approx(0.10375937481971094)\n elif atom in [((0,), (2,)), ((1,),)]:\n assert pid[atom] == pytest.approx(0.20751874963942191)\n elif atom in [((2,), (0, 1)), ((0,), (1, 2)), ((0, 1), (0, 2)), ((0, 1), (1, 2)), ((0, 2), (1, 2)), ((0, 1, 2),)]:\n assert pid[atom] == pytest.approx(0.14624062518028902)\n elif atom in [((2,),), ((0,),), ((0, 1), (0, 2), (1, 2)), ((0, 2),)]:\n assert pid[atom] == pytest.approx(-0.14624062518028902)\n else:\n assert pid[atom] == pytest.approx(0.0)","def __init__(self):\n self.pidDict = { # particle_name, pid\n \"total\" : 0,\n \"charged\" : 1,\n \"charged_eta\" : 2,\n \"pion\" : 6, # sum(7, 8, -7)\n \"pion_p\" : 7,\n \"pion_0\" : 8,\n \"pion_m\" : -7,\n \"kaon\" : 11, # sum(12, 13)\n \"kaon_p\" : 12,\n \"kaon_0\" : 13,\n \"anti_kaon\" : -11, # sum(-12, -13)\n \"kaon_m\" : -12,\n \"anti_kaon_0\" : -13,\n \"nucleon\" : 16, # sum(17, 18)\n \"proton\" : 17,\n \"neutron\" : 18,\n \"anti_nucleon\" : -16, # sum(-17, -18)\n \"anti_proton\" : -17,\n \"anti_neutron\" : -18,\n \"sigma\" : 21, # sum(22, 23, 24)\n \"sigma_p\" : 22,\n \"sigma_0\" : 23,\n \"sigma_m\" : 24,\n \"anti_sigma\" : -21,\n \"anti_sigma_p\" : -22,\n \"anti_sigma_0\" : -23,\n \"anti_sigma_m\" : -24,\n \"xi\" : 26, # sum(27, 28)\n \"xi_0\" : 27,\n \"xi_m\" : 28,\n \"anti_xi\" : -26,\n \"anti_xi_0\" : -27,\n \"anti_xi_m\" : -28,\n \"lambda\" : 31,\n \"anti_lambda\" : -31,\n \"omega\" : 36,\n \"anti_omega\" : -36,\n \"phi\" : 41,\n \"rho\" : 46, #sum(47, 48, -47)\n \"rho_p\" : 47,\n \"rho_0\" : 48,\n \"rho_m\" : -47,\n \"eta\" : 51,\n \"eta_prime\" : 52,\n \"gamma\" : 61,\n \"omega782\" : 65,\n \"eta\" : 71,\n \"etap\" : 72,\n }\n\n for aParticle in self.pidDict.keys():\n if self.pidDict[aParticle]>=0:\n self.pidDict[aParticle+\"_hydro\"] = self.pidDict[aParticle]+1000\n else:\n self.pidDict[aParticle+\"_hydro\"] = self.pidDict[aParticle]-1000\n if self.pidDict[aParticle]>=0:\n self.pidDict[aParticle+\"_thermal\"] = self.pidDict[aParticle]+2000\n else:\n self.pidDict[aParticle+\"_thermal\"] = self.pidDict[aParticle]-2000\n\n self.pidDict.update({\n \"photon_total\" : 9000,\n \"photon_total_eq\" : 9001,\n \"photon_QGP_tot\" : 9002,\n \"photon_QGP_eq\" : 9003,\n \"photon_HG_tot\" : 9004,\n \"photon_HG_eq\" : 9005,\n \"direct_gamma_shortdecay_hydro\" : 9006,\n \"decay_gamma_pi0_hydro\" : 9007,\n \"decay_gamma_eta_hydro\" : 9008,\n \"decay_gamma_omega_hydro\" : 9009,\n \"decay_gamma_phi_hydro\" : 9010,\n \"decay_gamma_etap_hydro\" : 9011,\n \"decay_gamma_Sigma0_hydro\" : 9012,\n })\n\n #UrQMD pid Dictionary, name conversion defined as in binUtility\n self.UrQMDpidDict = { #particle name, UrQMD id# : isospin*2000 + pid\n 2101 : \"pion_p\",\n -1899 : \"pion_m\",\n 101 : \"pion_0\",\n 1106 : \"kaon_p\",\n -894 : \"kaon_0\",\n -1106 : \"kaon_m\",\n 894 : \"anti_kaon_0\",\n 1001 : \"proton\",\n -999 : \"neutron\",\n -1001 : \"anti_proton\",\n 999 : \"anti_neutron\",\n 2040 : \"sigma_p\",\n -1960 : \"sigma_m\",\n 40 : \"sigma_0\",\n -2040 : \"anti_sigma_p\",\n 1960 : \"anti_sigma_m\",\n -40 : \"anti_sigma_0\",\n 1049 : \"xi_0\",\n -951 : \"xi_m\",\n -1049 : \"anti_xi_0\",\n 951 : \"anti_xi_m\",\n 27 : \"lambda\",\n -27 : \"anti_lambda\",\n 55 : \"omega\",\n -55 : \"anti_omega\",\n 109 : \"phi\",\n 102 : \"eta\",\n 107 : \"eta_prime\",\n 100 : \"gamma\",\n }\n\n #pdg pid Dictionary\n self.PDGpidDict = { #pdg id#, particle name\n 211 : \"pion_p\",\n -211 : \"pion_m\",\n 111 : \"pion_0\",\n 321 : \"kaon_p\",\n 311 : \"kaon_0\",\n -321 : \"kaon_m\",\n -311 : \"anti_kaon_0\",\n 2212 : \"proton\",\n 2112 : \"neutron\",\n -2212 : \"anti_proton\",\n -2112 : \"anti_neutron\",\n 3222 : \"sigma_p\",\n 3112 : \"sigma_m\",\n 3212 : \"sigma_0\",\n -3222 : \"anti_sigma_p\",\n -3112 : \"anti_sigma_m\",\n -3212 : \"anti_sigma_0\",\n 3322 : \"xi_0\",\n 3312 : \"xi_m\",\n -3322 : \"anti_xi_0\",\n -3312 : \"anti_xi_m\",\n 3122 : \"lambda\",\n -3122 : \"anti_lambda\",\n 3334 : \"omega\",\n -3334 : \"anti_omega\",\n 333 : \"phi\",\n 221 : \"eta\",\n 331 : \"eta_prime\",\n 22 : \"gamma\",\n }\n\n #particle mass Dictionary (unit in GeV)\n self.masspidDict = {\n \"pion\" : 0.13957,\n \"pion_p\" : 0.13957,\n \"pion_0\" : 0.13498,\n \"pion_m\" : 0.13957,\n \"kaon\" : 0.49368,\n \"kaon_p\" : 0.49368,\n \"kaon_0\" : 0.49765,\n \"anti_kaon\" : 0.49368,\n \"kaon_m\" : 0.49368,\n \"anti_kaon_0\" : 0.49765,\n \"nucleon\" : 0.93827,\n \"proton\" : 0.93827,\n \"neutron\" : 0.93957,\n \"anti_nucleon\" : 0.93827,\n \"anti_proton\" : 0.93827,\n \"anit_neutron\" : 0.93957,\n \"sigma\" : 1.18937,\n \"sigma_p\" : 1.18937,\n \"sigma_0\" : 1.19264,\n \"sigma_m\" : 1.19745,\n \"anti_sigma\" : 1.18937,\n \"anti_sigma_p\" : 1.18937,\n \"anti_sigma_0\" : 1.19264,\n \"anti_sigma_m\" : 1.19745,\n \"xi\" : 1.31483,\n \"xi_0\" : 1.31483,\n \"xi_m\" : 1.32131,\n \"anti_xi\" : 1.31483,\n \"anti_xi_0\" : 1.31483,\n \"anti_xi_m\" : 1.32131,\n \"lambda\" : 1.11568,\n \"anti_lambda\" : 1.11568,\n \"omega\" : 1.67243,\n \"anti_omega\" : 1.67243,\n \"rho\" : 0.77580,\n \"rho_p\" : 0.77580,\n \"rho_0\" : 0.77580,\n \"rho_m\" : 0.77580,\n \"phi\" : 1.01946,\n \"eta\" : 0.54775,\n \"eta_prime\" : 0.95778,\n \"gamma\" : 0.0,\n }\n for aParticle in self.masspidDict.keys():\n self.masspidDict[aParticle+\"_hydro\"] = self.masspidDict[aParticle]\n self.masspidDict[aParticle+\"_thermal\"] = self.masspidDict[aParticle]\n\n # charged hadrons list\n self.charged_hadron_list = [\n \"pion_p\", \"pion_m\", \"kaon_p\", \"kaon_m\", \"proton\", \"anti_proton\",\n \"sigma_p\", \"sigma_m\", \"anti_sigma_p\", \"anti_sigma_m\",\n \"xi_m\", \"anti_xi_m\"]","def _PIDController__calculate(self): \n \n\t\tenabled = self.m_enabled\n\t\tpidInput = self.m_pidInput\n\n\t\tif enabled:\n\n\t\t input = pidInput.PIDGet()\n\n\t\t self.m_error = self.m_setpoint - input\n\t\t if self.m_continuous:\n\t\t \n\t\t if math.fabs(self.m_error) > (self.m_maximumInput - self.m_minimumInput) / 2:\n\t\t if self.m_error > 0:\n\t\t self.m_error = self.m_error - self.m_maximumInput + self.m_minimumInput\n\t\t else:\n\t\t self.m_error = self.m_error + self.m_maximumInput - self.m_minimumInput\n\n\t\t potentialIGain = (self.m_totalError + self.m_error) * self.m_I\n\t\t \n\t\t if potentialIGain < self.m_maximumOutput:\n\t\t if potentialIGain > self.m_minimumOutput:\n\t\t self.m_totalError += self.m_error\n\t\t else:\n\t\t self.m_totalError = self.m_minimumOutput / self.m_I\n\t\t else:\n\t\t self.m_totalError = self.m_maximumOutput / self.m_I\n\n\t\t self.m_result = self.m_P * self.m_error + self.m_I * self.m_totalError + self.m_D * (self.m_error - self.m_prevError)\n\t\t self.m_prevError = self.m_error\n\n\t\t if self.m_result > self.m_maximumOutput:\n\t\t self.m_result = self.m_maximumOutput\n\t\t elif self.m_result < self.m_minimumOutput:\n\t\t self.m_result = self.m_minimumOutput\n\n\t\t pidOutput = self.m_pidOutput\n\t\t result = self.m_result","def _PIDController__calculate(self): \n \n\t\tenabled = self.m_enabled\n\t\tpidInput = self.m_pidInput\n\t\tpidInput2 = self.source2\n\n\t\tif enabled:\n\n\t\t input = pidInput.PIDGet() - pidInput2.PIDGet()\n\n\t\t self.m_error = self.m_setpoint - input\n\t\t if self.m_continuous:\n\t\t \n\t\t if math.fabs(self.m_error) > (self.m_maximumInput - self.m_minimumInput) / 2:\n\t\t if self.m_error > 0:\n\t\t self.m_error = self.m_error - self.m_maximumInput + self.m_minimumInput\n\t\t else:\n\t\t self.m_error = self.m_error + self.m_maximumInput - self.m_minimumInput\n\n\t\t potentialIGain = (self.m_totalError + self.m_error) * self.m_I\n\t\t \n\t\t if potentialIGain < self.m_maximumOutput:\n\t\t if potentialIGain > self.m_minimumOutput:\n\t\t self.m_totalError += self.m_error\n\t\t else:\n\t\t self.m_totalError = self.m_minimumOutput / self.m_I\n\t\t else:\n\t\t self.m_totalError = self.m_maximumOutput / self.m_I\n\n\t\t self.m_result = self.m_P * self.m_error + self.m_I * self.m_totalError + self.m_D * (self.m_error - self.m_prevError)\n\t\t self.m_prevError = self.m_error\n\n\t\t if self.m_result > self.m_maximumOutput:\n\t\t self.m_result = self.m_maximumOutput\n\t\t elif self.m_result < self.m_minimumOutput:\n\t\t self.m_result = self.m_minimumOutput\n\n\t\t pidOutput = self.m_pidOutput\n\t\t result = self.m_result","def get_pmi_mvn(x, y, z):\n\n d = x.shape[1]\n hz = 0.5 * log((2 * np.pi * np.e)**d * det(np.cov(z.T)))\n hxz = 0.5 * log((2 * np.pi * np.e)**(2*d) * det(np.cov(x.T, y=z.T)))\n hyz = 0.5 * log((2 * np.pi * np.e)**(2*d) * det(np.cov(y.T, y=z.T)))\n hxyz = 0.5 * log((2 * np.pi * np.e)**(3*d) * det(np.cov(np.c_[x,y,z].T)))\n\n pmi = hxz + hyz - hxyz - hz\n return pmi","def pontos(self):\n \n self.sc = 1. \n self.x = self.sc*np.array([-155., -139.4, -124., -108.5, -93., -77.5, -62., -46.5, -31., -15.5, 0, 15.5, 31., 46.5, 62., 77.5, 93., 108.5, 124., 139.5, 155.])\n self.y = self.sc*np.array([ 9.23, 14.37, 18.98, 23.6, 23.6, 23.6, 23.6, 23.6, 23.6, 23.6, 23.6, 23.6, 23.6, 23.6, 23.6, 23.6, 23.6, 23.6, 21.55, 14.37, 3.59])\n self.px_index = len(self.x)\n #self.py_index = len(self.x)/2\n\n self.coord = np.array([self.x,self.y,np.full(len(self.x),self.z)])\n \n self.x = self.x[::-1]\n self.y = -self.y[::-1] \n self.new = np.array([self.x,self.y,np.full(len(self.x),self.z)])\n self.coord = np.array([np.append(self.coord[0],self.new[0]),np.append(self.coord[1],self.new[1]),np.append(self.coord[2],self.new[2])])\n self.coord = np.array([np.append(self.coord[0],self.coord[0,0]),np.append(self.coord[1],self.coord[1,0]),np.append(self.coord[2],self.coord[2,0])])\n\n self.coord[0] = self.coord[0] - (np.amax(self.coord[0])+np.amin(self.coord[0]))/2\n self.coord[1] = self.coord[1] + (np.amax(self.coord[1])-np.amin(self.coord[1]))/2 \n \n self.coordi = np.array(self.coord)\n \n self.cg = np.array([0 + self.dx, self.H/2 + self.dy, self.z]) \n self.cgi = np.array(self.cg)\n \n self.thi = 0. + self.dth \n self.th = float(self.thi) \n \n self.coordnav(self.dx,self.dy,self.dth)","def pidGet(self) -> float:\n ...","def pidGet(self) -> float:\n ...","def get_atomic_id_from_coord(self, x: int, y: int, z: int,\n parent_id: np.uint64, n_tries: int=5\n ) -> np.uint64:\n if self.get_chunk_layer(parent_id) == 1:\n return parent_id\n\n\n x /= 2**self.cv_mip\n y /= 2**self.cv_mip\n\n x = int(x)\n y = int(y)\n\n checked = []\n atomic_id = None\n root_id = self.get_root(parent_id)\n\n for i_try in range(n_tries):\n\n # Define block size -- increase by one each try\n x_l = x - (i_try - 1)**2\n y_l = y - (i_try - 1)**2\n z_l = z - (i_try - 1)**2\n\n x_h = x + 1 + (i_try - 1)**2\n y_h = y + 1 + (i_try - 1)**2\n z_h = z + 1 + (i_try - 1)**2\n\n if x_l < 0:\n x_l = 0\n\n if y_l < 0:\n y_l = 0\n\n if z_l < 0:\n z_l = 0\n\n # Get atomic ids from cloudvolume\n atomic_id_block = self.cv[x_l: x_h, y_l: y_h, z_l: z_h]\n atomic_ids, atomic_id_count = np.unique(atomic_id_block,\n return_counts=True)\n\n # sort by frequency and discard those ids that have been checked\n # previously\n sorted_atomic_ids = atomic_ids[np.argsort(atomic_id_count)]\n sorted_atomic_ids = sorted_atomic_ids[~np.in1d(sorted_atomic_ids,\n checked)]\n\n # For each candidate id check whether its root id corresponds to the\n # given root id\n for candidate_atomic_id in sorted_atomic_ids:\n ass_root_id = self.get_root(candidate_atomic_id)\n\n if ass_root_id == root_id:\n # atomic_id is not None will be our indicator that the\n # search was successful\n\n atomic_id = candidate_atomic_id\n break\n else:\n checked.append(candidate_atomic_id)\n\n if atomic_id is not None:\n break\n\n # Returns None if unsuccessful\n return atomic_id","def get_x_y_z(drone, p, q, r):\n num_cameras = 2\n camera_constants = [0,math.pi/2]\n rads = np.zeros(num_cameras)\n phis = np.zeros(num_cameras)\n d = np.zeros(num_cameras)\n theta = np.zeros(num_cameras)\n Hs = np.zeros(num_cameras)\n s = 12\n HFOV = math.pi/4\n VFOV = 5*math.pi/36\n HPIX = 1280\n VPIX = 720\n #loop one, where we increment over camera number, and\n # get new information\n\n cent = calculate_centroid(p,q,r)\n for camera_num in range(num_cameras):\n\n A,B = find_a_and_b(p[camera_num],q[camera_num],r[camera_num],cent[camera_num])\n a = find_a(A,B)\n d_in = find_inner_d(a, s)\n angle_c = find_angle_c(a)\n alpha = find_alpha(HFOV, HPIX, A)\n w = find_w(angle_c, s)\n d_out = find_outer_d(w,alpha,a)\n pointy_front = is_point_front(r[camera_num],q[camera_num],p[camera_num],cent[camera_num])\n d[camera_num] = find_d(d_in,d_out,pointy_front)\n theta[camera_num] = find_theta(angle_c,A,B,camera_constants[camera_num])\n k = find_k(drone[camera_num], cent[camera_num])\n angle_k = find_angle_k(k, HFOV, HPIX)\n phi = find_phi(theta[camera_num], angle_k)\n rad = find_r(d[camera_num], angle_k)\n phis[camera_num] = phi\n rads[camera_num] = rad\n\n # end of first loop\n\n cosphis = np.cos(phis)\n sinphis = np.sin(phis)\n big_matrix = np.column_stack((cosphis,sinphis))\n points = np.zeros((int(num_cameras*(num_cameras-1)/2),2))\n i = 0\n for pair in itertools.combinations(range(num_cameras), 2):\n matrix_a = np.vstack((big_matrix[pair[0]],big_matrix[pair[1]]))\n vec_b = np.hstack((rads[pair[0]],rads[pair[1]]))\n point = np.linalg.solve(matrix_a, vec_b)\n points[i] = point\n i += 1\n drone_pos = np.mean(points,axis=0)\n\n # start of third loop\n for camera_num in range(num_cameras):\n d_prime = find_d_prime(d[camera_num], theta[camera_num], drone_pos)\n P,Q,M,N = find_P_Q_M_N(p[camera_num],q[camera_num],r[camera_num])\n h = find_h(d[camera_num],P,Q,M,N)\n angle_4 = find_angle_4(h,d[camera_num])\n Y = find_Y(drone[camera_num], cent[camera_num])\n angle_5 = find_angle_5(Y, VFOV, VPIX)\n angle_6 = angle_5 - angle_4\n h_prime = find_h_prime(d_prime, angle_6)\n Hs[camera_num] = h + h_prime\n drone_h = np.mean(H)\n return np.append(drone_pos,drone_h)","def get_coord(self,x,y,z):\n a = 0\n b = 0\n c = 0\n \n distance = 0\n \n while (distance <= x):\n distance += SQUARE_SIZE\n if ( (x - distance) > - (SQUARE_SIZE / 2) ):\n a += 1\n distance = 0\n \n while (distance <= y):\n distance += SQUARE_SIZE\n if ( (y - distance) > - (SQUARE_SIZE / 2) ):\n b += 1\n distance = 0\n \n while (distance <= z):\n distance += SQUARE_SIZE\n if ( (z - distance) > - (SQUARE_SIZE / 2) ):\n c += 1\n distance = 0\n \n return(a,b,c)","def get_parameters():\n\n setpoint = [0., 0., 0., 0.]\n kp_param = [0., .0, 0., 0.]\n ki_param = [0., 0., 0., 0.]\n kd_param = [0, 0, 0, 0]\n inverted = [False, False, False, False]\n hold = [False, False, False, False]\n int_reset = [False, False, False, False]\n int_auto = [False, False, False, False]\n relock_min = [0., 0., 0., 0.]\n relock_max = [0., 0., 0., 0.]\n relock_slew_rate = [0., 0., 0., 0.]\n relock_enabled = [False, False, False, False]\n relock_input = [0, 0, 0, 0]\n for i in range(4):\n setpoint[i] = ctypes.c_float()\n retval = RP_LIB.rp_PIDGetSetpoint(i, ctypes.byref(setpoint[i]))\n if retval != 0:\n LOG.error(\"Failed to get PID setpoint. Error code: %s\", ERROR_CODES[retval])\n\n kp_param[i] = ctypes.c_float()\n retval = RP_LIB.rp_PIDGetKp(i, ctypes.byref(kp_param[i]))\n if retval != 0:\n LOG.error(\"Failed to get PID Kp parameter. Error code: %s\", ERROR_CODES[retval])\n\n ki_param[i] = ctypes.c_float()\n retval = RP_LIB.rp_PIDGetKi(i, ctypes.byref(ki_param[i]))\n if retval != 0:\n LOG.error(\"Failed to get PID Ki parameter. Error code: %s\", ERROR_CODES[retval])\n\n kd_param[i] = ctypes.c_int()\n retval = RP_LIB.rp_PIDGetKd(i, ctypes.byref(kd_param[i]))\n if retval != 0:\n LOG.error(\"Failed to get PID Kd parameter. Error code: %s\", ERROR_CODES[retval])\n\n inverted[i] = ctypes.c_bool()\n retval = RP_LIB.rp_PIDGetInverted(i, ctypes.byref(inverted[i]))\n if retval != 0:\n LOG.error(\"Failed to get PID feedback sign. Error code: %s\", ERROR_CODES[retval])\n\n hold[i] = ctypes.c_bool()\n retval = RP_LIB.rp_PIDGetHold(i, ctypes.byref(hold[i]))\n if retval != 0:\n LOG.error(\"Failed to get state of PID internal holding. Error code: %s\",\n ERROR_CODES[retval])\n\n int_reset[i] = ctypes.c_bool()\n retval = RP_LIB.rp_PIDGetIntReset(i, ctypes.byref(int_reset[i]))\n if retval != 0:\n LOG.error(\"Failed to get state of PID integrator reset. Error code: %s\",\n ERROR_CODES[retval])\n\n int_auto[i] = ctypes.c_bool()\n retval = RP_LIB.rp_PIDGetResetWhenRailed(i, ctypes.byref(int_auto[i]))\n if retval != 0:\n LOG.error(\"Failed to get state of PID automatical integrator reset. Error code: %s\",\n ERROR_CODES[retval])\n\n relock_min[i] = ctypes.c_float()\n retval = RP_LIB.rp_PIDGetRelockMinimum(i, ctypes.byref(relock_min[i]))\n if retval != 0:\n LOG.error(\"Failed to get PID minimum relock voltage. Error code: %s\",\n ERROR_CODES[retval])\n\n relock_max[i] = ctypes.c_float()\n retval = RP_LIB.rp_PIDGetRelockMaximum(i, ctypes.byref(relock_max[i]))\n if retval != 0:\n LOG.error(\"Failed to get PID maximum relock voltage. Error code: %s\",\n ERROR_CODES[retval])\n\n relock_slew_rate[i] = ctypes.c_float()\n retval = RP_LIB.rp_PIDGetRelockStepsize(i, ctypes.byref(relock_slew_rate[i]))\n if retval != 0:\n LOG.error(\"Failed to get PID relock slew rate. Error code: %s\",\n ERROR_CODES[retval])\n\n relock_enabled[i] = ctypes.c_bool()\n retval = RP_LIB.rp_PIDGetRelock(i, ctypes.byref(relock_enabled[i]))\n if retval != 0:\n LOG.error(\"Failed to get state of PID relock feature. Error code: %s\",\n ERROR_CODES[retval])\n\n relock_input[i] = ctypes.c_int()\n retval = RP_LIB.rp_PIDGetRelockInput(i, ctypes.byref(relock_input[i]))\n if retval != 0:\n LOG.error(\"Failed to get analog input of PID relock. Error code: %s\",\n ERROR_CODES[retval])\n\n limit_min_1 = ctypes.c_float()\n retval = RP_LIB.rp_LimitGetMin(0, ctypes.byref(limit_min_1))\n if retval != 0:\n LOG.error(\"Failed to get minimum output limit. Error code: %s\", ERROR_CODES[retval])\n limit_min_2 = ctypes.c_float()\n retval = RP_LIB.rp_LimitGetMin(1, ctypes.byref(limit_min_2))\n if retval != 0:\n LOG.error(\"Failed to get minimum output limit. Error code: %s\", ERROR_CODES[retval])\n\n limit_max_1 = ctypes.c_float()\n retval = RP_LIB.rp_LimitGetMax(0, ctypes.byref(limit_max_1))\n if retval != 0:\n LOG.error(\"Failed to get maximum output limit. Error code: %s\", ERROR_CODES[retval])\n limit_max_2 = ctypes.c_float()\n retval = RP_LIB.rp_LimitGetMax(1, ctypes.byref(limit_max_2))\n if retval != 0:\n LOG.error(\"Failed to get maximum output limit. Error code: %s\", ERROR_CODES[retval])\n\n sg_1_amp = ctypes.c_float()\n retval = RP_LIB.rp_GenGetAmp(0, ctypes.byref(sg_1_amp))\n if retval != 0:\n LOG.error(\"Failed to get signal generator amplitude. Error code: %s\", ERROR_CODES[retval])\n sg_2_amp = ctypes.c_float()\n retval = RP_LIB.rp_GenGetAmp(1, ctypes.byref(sg_2_amp))\n if retval != 0:\n LOG.error(\"Failed to get signal generator amplitude. Error code: %s\", ERROR_CODES[retval])\n\n sg_1_freq = ctypes.c_float()\n retval = RP_LIB.rp_GenGetFreq(0, ctypes.byref(sg_1_freq))\n if retval != 0:\n LOG.error(\"Failed to get signal generator frequency. Error code: %s\", ERROR_CODES[retval])\n sg_2_freq = ctypes.c_float()\n retval = RP_LIB.rp_GenGetFreq(1, ctypes.byref(sg_2_freq))\n if retval != 0:\n LOG.error(\"Failed to get signal generator frequency. Error code: %s\", ERROR_CODES[retval])\n\n sg_1_offset = ctypes.c_float()\n retval = RP_LIB.rp_GenGetOffset(0, ctypes.byref(sg_1_offset))\n if retval != 0:\n LOG.error(\"Failed to get signal generator offset. Error code: %s\", ERROR_CODES[retval])\n sg_2_offset = ctypes.c_float()\n retval = RP_LIB.rp_GenGetOffset(1, ctypes.byref(sg_2_offset))\n if retval != 0:\n LOG.error(\"Failed to get signal generator offset. Error code: %s\", ERROR_CODES[retval])\n\n sg_1_waveform = ctypes.c_int()\n retval = RP_LIB.rp_GenGetWaveform(0, ctypes.byref(sg_1_waveform))\n if retval != 0:\n LOG.error(\"Failed to get the waveform of the signal generator. Error code: %s\",\n ERROR_CODES[retval])\n sg_2_waveform = ctypes.c_int()\n retval = RP_LIB.rp_GenGetWaveform(1, ctypes.byref(sg_2_waveform))\n if retval != 0:\n LOG.error(\"Failed to get the waveform of the signal generator. Error code: %s\",\n ERROR_CODES[retval])\n\n sg_1_enabled = ctypes.c_bool()\n retval = RP_LIB.rp_GenOutIsEnabled(0, ctypes.byref(sg_1_enabled))\n if retval != 0:\n LOG.error(\"Failed to get if signal generator is enabled. Error code: %s\",\n ERROR_CODES[retval])\n sg_2_enabled = ctypes.c_bool()\n retval = RP_LIB.rp_GenOutIsEnabled(1, ctypes.byref(sg_2_enabled))\n if retval != 0:\n LOG.error(\"Failed to get if signal generator is enabled. Error code: %s\",\n ERROR_CODES[retval])\n\n parameters = {\n \"pid_11_setpoint\": setpoint[0].value,\n \"pid_12_setpoint\": setpoint[1].value,\n \"pid_21_setpoint\": setpoint[2].value,\n \"pid_22_setpoint\": setpoint[3].value,\n \"pid_11_kp\": kp_param[0].value,\n \"pid_12_kp\": kp_param[1].value,\n \"pid_21_kp\": kp_param[2].value,\n \"pid_22_kp\": kp_param[3].value,\n \"pid_11_ki\": ki_param[0].value,\n \"pid_12_ki\": ki_param[1].value,\n \"pid_21_ki\": ki_param[2].value,\n \"pid_22_ki\": ki_param[3].value,\n \"pid_11_kd\": kd_param[0].value,\n \"pid_12_kd\": kd_param[1].value,\n \"pid_21_kd\": kd_param[2].value,\n \"pid_22_kd\": kd_param[3].value,\n \"pid_11_inverted\": inverted[0].value,\n \"pid_12_inverted\": inverted[1].value,\n \"pid_21_inverted\": inverted[2].value,\n \"pid_22_inverted\": inverted[3].value,\n \"pid_11_hold\": hold[0].value,\n \"pid_12_hold\": hold[1].value,\n \"pid_21_hold\": hold[2].value,\n \"pid_22_hold\": hold[3].value,\n \"pid_11_int_res\": int_reset[0].value,\n \"pid_12_int_res\": int_reset[1].value,\n \"pid_21_int_res\": int_reset[2].value,\n \"pid_22_int_res\": int_reset[3].value,\n \"pid_11_int_auto_reset\": int_auto[0].value,\n \"pid_12_int_auto_reset\": int_auto[1].value,\n \"pid_21_int_auto_reset\": int_auto[2].value,\n \"pid_22_int_auto_reset\": int_auto[3].value,\n \"pid_11_relock_min\": relock_min[0].value,\n \"pid_12_relock_min\": relock_min[1].value,\n \"pid_21_relock_min\": relock_min[2].value,\n \"pid_22_relock_min\": relock_min[3].value,\n \"pid_11_relock_max\": relock_max[0].value,\n \"pid_12_relock_max\": relock_max[1].value,\n \"pid_21_relock_max\": relock_max[2].value,\n \"pid_22_relock_max\": relock_max[3].value,\n \"pid_11_relock_slew_rate\": relock_slew_rate[0].value,\n \"pid_12_relock_slew_rate\": relock_slew_rate[1].value,\n \"pid_21_relock_slew_rate\": relock_slew_rate[2].value,\n \"pid_22_relock_slew_rate\": relock_slew_rate[3].value,\n \"pid_11_relock_enabled\": relock_enabled[0].value,\n \"pid_12_relock_enabled\": relock_enabled[1].value,\n \"pid_21_relock_enabled\": relock_enabled[2].value,\n \"pid_22_relock_enabled\": relock_enabled[3].value,\n \"pid_11_relock_input\": relock_input[0].value,\n \"pid_12_relock_input\": relock_input[1].value,\n \"pid_21_relock_input\": relock_input[2].value,\n \"pid_22_relock_input\": relock_input[3].value,\n \"limit_min_1\": limit_min_1.value,\n \"limit_min_2\": limit_min_2.value,\n \"limit_max_1\": limit_max_1.value,\n \"limit_max_2\": limit_max_2.value,\n \"sg_1_waveform\": sg_1_waveform.value,\n \"sg_2_waveform\": sg_2_waveform.value,\n \"sg_1_enabled\": sg_1_enabled.value,\n \"sg_2_enabled\": sg_2_enabled.value,\n \"sg_1_amp\": sg_1_amp.value,\n \"sg_2_amp\": sg_2_amp.value,\n \"sg_1_freq\": sg_1_freq.value,\n \"sg_2_freq\": sg_2_freq.value,\n \"sg_1_offset\": sg_1_offset.value,\n \"sg_2_offset\": sg_2_offset.value\n }\n return json.dumps(parameters)","def calculate_potential_3D_parallel(true_csd, ele_xx, ele_yy, ele_zz, \n csd_x, csd_y, csd_z):\n\n xlin = csd_x[:,0,0]\n ylin = csd_y[0,:,0]\n zlin = csd_z[0,0,:]\n xlims = [xlin[0], xlin[-1]]\n ylims = [ylin[0], ylin[-1]]\n zlims = [zlin[0], zlin[-1]]\n sigma = 1.0\n #tic = time.time()\n pots = Parallel(n_jobs=num_cores)(delayed(integrate_3D)(ele_xx[ii],ele_yy[ii],ele_zz[ii],\n xlims, ylims, zlims, true_csd,\n xlin, ylin, zlin,\n csd_x, csd_y, csd_z) for ii in range(len(ele_xx)))\n pots = np.array(pots)\n pots /= 4*np.pi*sigma\n #toc = time.time() - tic\n #print toc, 'Total time taken - parallel, sims '\n return pots","def get_pid(self):\n return self.k_p, self.k_i, self.k_d","def _update_PID(self):\n self.pid = PID(p=self.paramP, i=self.paramI, d=self.paramD, setpoint=self.voltageSetpoint, memory=self.paramMemory)","def test_pointnum3():\n shape = paramak.CapsuleVacuumVessel(outer_start_point=(1000, -500), radius=5000, thickness=50)\n assert len(shape.points) == 12\n assert len(shape.processed_points) == 13","def cartesian_distance(x,y,z):\n\treturn math.sqrt(x**2 + y**2 + z**2)","def optimise_z(z, *args):\n x, y, elements, coordinates = args\n window_com = np.array([x, y, z])\n return pore_diameter(elements, coordinates, com=window_com)[0]","def _evaluate_xyz(self,x,y,z=0.):\n return -np.pi * self._rhoc_M /(self.n+1.)*self.a**3*self._b*self._c * \\\n _potInt(x, y, z, self._a2, self._b2*self._a2, self._c2*self._a2, self.n)","def calculatePosition(P1, P2, P3, DistA, DistB, DistC):\n #SEE wikipedia for why trilateralization : https://en.wikipedia.org/wiki/Trilateration\n ex = (P2 - P1)/(numpy.linalg.norm(P2 - P1))\n i = np.dot(ex, P3 - P1)\n ey = (P3 - P1 - i * ex)/(numpy.linalg.norm(P3 - P1 - i * ex))\n ez = numpy.cross(ex,ey)\n d = numpy.linalg.norm(P2 - P1)\n j = np.dot(ey, P3 - P1)\n \n x = (pow(DistA,2) - pow(DistB,2) + pow(d,2))/(2 * d)\n y = ((pow(DistA,2) - pow(DistC,2) + pow(i,2) + pow(j,2))/(2 * j)) - ((i/j)*x)\n\n z = cmath.sqrt(pow(DistA,2) - pow(x,2) - pow(y,2))\n\n if z.imag != 0.0:\n return [None, None, None]\n else:\n return np.real(P1 + x*ex + y*ey + z*ez)","def photons(self, depth=1):\n self.dx[:,:self.W-1] = self.z[:,1:] - self.z[:,:self.W-1]\n self.dy[:self.H-1,:] = self.z[1:,:] - self.z[:self.H-1,:]\n px = self.xv - self.dx*depth\n py = self.yv - self.dy*depth\n return px,py","def ci(x, y, z):\n\n return (x * 16 + z) * CHUNK_HEIGHT + y","def calc_positions(zpoints, dsq_list):\n\n pos_map = {}\n points_map = {}\n\n for z, p in zpoints.items():\n if z in dsq_list:\n p = -1\n if p not in points_map:\n points_map[p] = set()\n points_map[p].add(z)\n\n i = 1\n for p in sorted(list(points_map.keys()), reverse = True):\n pos_map[i] = points_map[p]\n i += len(points_map[p])\n\n return pos_map","def __init__(self,E,px,py,pz):\n Particle.__init__(self)\n self.E=float(E)\n self.px=float(px)\n self.py=float(py)\n self.pz=float(pz)\n self.cal_pt()\n self.cal_phi()\n self.cal_eta()\n #self.cal_mass()\n #print self.E,self.px,self.py,self.pz\n #print self.pt,self.phi,self.eta","def immoment3D(X, Y, Z, p, q, r):\n assert len(X) == len(Y)\n assert len(Y) == len(Z)\n return (X ** p * Y ** q * Z ** r).sum()","def ion1_position(self,x,y,z):\n axes_vector = np.array([self.a,self.b,self.c])\n self.ion1 = x*self.a + y*self.b + z*self.c\n self.position['1A'] = np.dot(self.position_map[1],axes_vector) + self.ion1\n self.position['2A'] = np.dot(self.position_map[2],axes_vector) + self.ion1\n self.position['3A'] = np.dot(self.position_map[3],axes_vector) + self.ion1\n self.position['4A'] = np.dot(self.position_map[4],axes_vector) + self.ion1\n self.position['5A'] = np.dot(self.position_map[5],axes_vector) + self.ion1\n self.position['6A'] = np.dot(self.position_map[6],axes_vector) + self.ion1\n self.position['7A'] = np.dot(self.position_map[7],axes_vector) + self.ion1\n self.position['8A'] = np.dot(self.position_map[8],axes_vector) + self.ion1","def ion1_position(self,x,y,z):\n axes_vector = np.array([self.a,self.b,self.c])\n self.ion1 = x*self.a + y*self.b + z*self.c\n self.position['1A'] = np.dot(self.position_map[1],axes_vector) + self.ion1\n self.position['2A'] = np.dot(self.position_map[2],axes_vector) + self.ion1\n self.position['3A'] = np.dot(self.position_map[3],axes_vector) + self.ion1\n self.position['4A'] = np.dot(self.position_map[4],axes_vector) + self.ion1\n self.position['5A'] = np.dot(self.position_map[5],axes_vector) + self.ion1\n self.position['6A'] = np.dot(self.position_map[6],axes_vector) + self.ion1\n self.position['7A'] = np.dot(self.position_map[7],axes_vector) + self.ion1\n self.position['8A'] = np.dot(self.position_map[8],axes_vector) + self.ion1","def calculate_percid(\n pos_total, length_query, length_subject, length_total, option_pid=\"mean\"\n):\n if option_pid == \"mean\":\n pid = pos_total / ((length_query + length_subject) / 2.0)\n elif option_pid == \"subject\":\n pid = pos_total / length_subject\n elif option_pid == \"query\":\n pid = pos_total / length_query\n elif option_pid == \"shortest\":\n pid = pos_total / min(length_query, length_subject)\n elif option_pid == \"longest\":\n pid = pos_total / max(length_query, length_subject)\n elif option_pid == \"HSP\":\n pid = pos_total / length_total\n\n return pid","def set_position(self, x, y, z):\n for sec in self.all:\n for i in range(int(nrn.n3d())):\n nrn.pt3dchange(i, \\\n x-self.x+nrn.x3d(i), \\\n y-self.y+nrn.y3d(i), \\\n z-self.z+nrn.z3d(i), \\\n nrn.diam3d(i))\n self.x = x; self.y = y; self.z = z","def kinect_transform(self, x, y, z):\n xposition = x\n yposition = y\n zposition = z\n\n return zposition, xposition, yposition","def PIDdata(time,temperature,setp):\n from scipy import polyfit\n from matplotlib.pyplot import figure,subplot,plot,xlabel,ylabel,title\n\n l=len(temperature)\n Pdat = zeros(l)\n Idat = zeros(l)\n Ddat = zeros(l)\n\n Pdat[0] = setp-temperature[0]\n for i in range(1,l):\n epsilon = setp - temperature[i]\n Pdat[i] = epsilon\n Idat[i] = Idat[i-1] + epsilon\n\n for i in range(2,l-2):\n j=range(i-2,i+3)\n (a,b)=polyfit(time[j],temperature[j],1)\n Ddat[i] = a\n\n figure()\n subplot(411)\n plot(time,temperature)\n ylabel(r'Temperature $ \\left( ^{\\circ} C \\right) $')\n subplot(412)\n plot(time,Pdat)\n ylabel(r'$ \\epsilon = T_{set}-T_{meas} \\left( ^{\\circ}C \\right) $')\n subplot(413)\n plot(time,Idat)\n ylabel(r'$ \\int_0^t \\epsilon dt $')\n subplot(414)\n plot(time,Ddat)\n xlabel('Time (s)')\n ylabel(r' $ \\frac{d \\epsilon}{dt} $')\n\n return Pdat,Idat,Ddat","def test_variables(x, y, z):\n a = x * y\n b = y * a\n c = a + b\n return c / z","def findpc(self):\n u = -(-can.C.len() + self.P.len() + can.R)/self.V.len()\n if u >= 0:\n return self.P + self.V.scale(u), u\n else:\n u = (can.C.len() - self.P.len() + can.R)/self.V.len()\n return self.P + self.V.scale(u), u","def get_pmi(x, y, z, k=1, normalize=None, norm=np.inf, estimator='fp'):\n\n if normalize:\n x = normalize(x)\n y = normalize(y)\n z = normalize(z)\n\n # construct state array for the joint processes:\n xz = np.c_[x,z]\n yz = np.c_[y,z]\n xyz = np.c_[x,y,z]\n\n if estimator == 'naive':\n # compute individual entropies\n # TODO: pass in min_dist\n hz = get_h(z, k=k, norm=norm)\n hxz = get_h(xz, k=k, norm=norm)\n hyz = get_h(yz, k=k, norm=norm)\n hxyz = get_h(xyz, k=k, norm=norm)\n\n pmi = hxz + hyz - hxyz - hz\n\n elif estimator == 'fp':\n\n # construct k-d trees\n z_tree = cKDTree(z)\n xz_tree = cKDTree(xz)\n yz_tree = cKDTree(yz)\n xyz_tree = cKDTree(xyz)\n\n # kth nearest neighbour distances for every state\n # query with k=k+1 to return the nearest neighbour, not the data point itself\n # dist, idx = xyz_tree.query(xyz, k=k+1, p=norm)\n dist, idx = xyz_tree.query(xyz, k=k+1, p=np.inf)\n epsilon = dist[:, -1]\n\n # for each point, count the number of neighbours\n # whose distance in the relevant subspace is strictly < epsilon\n n = len(x)\n nxz = np.empty(n, dtype=np.int)\n nyz = np.empty(n, dtype=np.int)\n nz = np.empty(n, dtype=np.int)\n\n for ii in range(n):\n # nz[ii] = len( z_tree.query_ball_point( z_tree.data[ii], r=epsilon[ii], p=norm)) - 1\n # nxz[ii] = len(xz_tree.query_ball_point(xz_tree.data[ii], r=epsilon[ii], p=norm)) - 1\n # nyz[ii] = len(yz_tree.query_ball_point(yz_tree.data[ii], r=epsilon[ii], p=norm)) - 1\n nz[ii] = len( z_tree.query_ball_point( z_tree.data[ii], r=epsilon[ii], p=np.inf)) - 1\n nxz[ii] = len(xz_tree.query_ball_point(xz_tree.data[ii], r=epsilon[ii], p=np.inf)) - 1\n nyz[ii] = len(yz_tree.query_ball_point(yz_tree.data[ii], r=epsilon[ii], p=np.inf)) - 1\n\n pmi = digamma(k) + np.mean(digamma(nz +1) -digamma(nxz +1) -digamma(nyz +1))\n\n elif estimator == 'ps':\n # (I am fairly sure that) this is the correct implementation of the estimator,\n # but the estimators is just crap.\n\n # construct k-d trees\n xz_tree = cKDTree(xz, leafsize=2*k)\n yz_tree = cKDTree(yz, leafsize=2*k)\n\n # determine k-nn distances\n n = len(x)\n rxz = np.empty(n, dtype=np.int)\n ryz = np.empty(n, dtype=np.int)\n\n # rxz, dummy = xz_tree.query(xz, k=k+1, p=norm) # +1 to account for distance to itself\n # ryz, dummy = yz_tree.query(xz, k=k+1, p=norm) # +1 to account for distance to itself; xz NOT a typo\n rxz, dummy = xz_tree.query(xz, k=k+1, p=np.inf) # +1 to account for distance to itself\n ryz, dummy = yz_tree.query(xz, k=k+1, p=np.inf) # +1 to account for distance to itself; xz NOT a typo\n\n pmi = yz.shape[1] * np.mean(log(ryz[:,-1]) - log(rxz[:,-1])) # + log(n) -log(n-1) -1.\n\n else:\n raise NotImplementedError(\"Estimator one of 'naive', 'fp', 'ps'; currently: {}\".format(estimator))\n\n return pmi","def nParticle(*args, attribute: Union[AnyStr, bool]=\"\", cache: bool=True, conserve: Union[float,\n bool]=0.0, count: bool=True, deleteCache: bool=True, dynamicAttrList: bool=True,\n floatValue: float=0.0, gridSpacing: Union[float, List[float], bool]=0.0, inherit:\n Union[float, bool]=0.0, jitterBasePoint: Union[List[float, float, float],\n List[List[float, float, float]], bool]=None, jitterRadius: Union[float,\n List[float], bool]=0.0, lowerLeft: Union[List[float, float, float],\n List[List[float, float, float]], bool]=None, name: Union[AnyStr, bool]=\"\",\n numJitters: Union[int, List[int], bool]=0, order: Union[int, bool]=0, particleId:\n Union[int, bool]=0, perParticleDouble: bool=True, perParticleVector: bool=True,\n position: Union[List[float, float, float], List[List[float, float, float]]]=None,\n shapeName: Union[AnyStr, bool]=\"\", upperRight: Union[List[float, float, float],\n List[List[float, float, float]], bool]=None, vectorValue: List[float, float,\n float]=None, q=True, query=True, e=True, edit=True, **kwargs)->Union[AnyStr,\n Any]:\n pass","def test_pid_ccs2():\n d = trivariates['anddup']\n pid = PID_CCS(d, [[0], [1], [2]], [3])\n for atom in pid._lattice:\n if atom == ((0,), (1,), (2,)):\n assert pid[atom] == pytest.approx(0.10375937481971094)\n elif atom in [((0,), (2,)), ((1,),)]:\n assert pid[atom] == pytest.approx(0.20751874963942191)\n elif atom in [((2,), (0, 1)), ((0,), (1, 2)), ((0, 1), (0, 2)), ((0, 1), (1, 2)), ((0, 2), (1, 2)), ((0, 1, 2),)]:\n assert pid[atom] == pytest.approx(0.14624062518028902)\n elif atom in [((2,),), ((0,),), ((0, 1), (0, 2), (1, 2)), ((0, 2),)]:\n assert pid[atom] == pytest.approx(-0.14624062518028902)\n else:\n assert pid[atom] == pytest.approx(0.0)","def placeParticle(self, x, y, z, count):\n self._sim.placeNumber(self, x, y, z, count)\n return self","def pid(self, drive, p=None, i=None, d=None):\n if p is None:\n # get proportional band\n self.__ser__.write(\"RP{}\\r\".format(drive).encode())\n self.__ser__.flush()\n p = str2float(self.__ser__.read_until('\\r'))\n else:\n # set proportional band\n self.__ser__.write(\"SP{} {}\\r\".format(drive, p).encode())\n self.__ser__.flush()\n p = self.rcvd_ok()\n if i is None:\n # get integral band\n self.__ser__.write(\"RI{}\\r\".format(drive).encode())\n self.__ser__.flush()\n i = str2float(self.__ser__.read_until('\\r'))\n else:\n # set integral band\n self.__ser__.write(\"SI{} {}\\r\".format(drive, i).encode())\n self.__ser__.flush()\n i = self.rcvd_ok()\n if d is None:\n # get derivative band\n self.__ser__.write(\"RD{}\\r\".format(drive).encode())\n self.__ser__.flush()\n d = str2float(self.__ser__.read_until('\\r'))\n else:\n # set derivative band\n self.__ser__.write(\"SD{} {}\\r\".format(drive, d).encode())\n self.__ser__.flush()\n d = self.rcvd_ok()\n return((p, i, d))","def define_particle(self,line):\n\n pattern=re.compile(r'''^\\s*\n (?P<pid>-?\\d+)\\s+ #PID\n (?P<status>1)\\s+ #status (1 for output particle)\n (?P<mother>-?\\d+)\\s+ #mother\n (?P<dum3>-?\\d+)\\s+ #mother\n (?P<color1>[+-e.\\d]*)\\s+ #color1\n (?P<color2>[+-e.\\d]*)\\s+ #color2\n (?P<px>[+-e.\\d]*)\\s+ #px\n (?P<py>[+-e.\\d]*)\\s+ #py\n (?P<pz>[+-e.\\d]*)\\s+ #pz\n (?P<E>[+-e.\\d]*)\\s+ #E\n (?P<mass>[+-e.\\d]*)\\s+ #mass\n (?P<dum1>[+-e.\\d]*)\\s+ #dummy1\n (?P<dum2>[+-e.\\d]*)\\s* #dummy2\n $ #end of string\n ''',66) #verbose+ignore case\n if pattern.search(line):\n obj=pattern.search(line)\n E=obj.group('E')\n px=obj.group('px')\n py=obj.group('py')\n pz=obj.group('pz')\n particle=part_quadvec(E,px,py,pz)\n particle.def_mass(obj.group('mass'))\n particle.def_pid(obj.group('pid'))\n return particle\n else:\n return 0","def _get_data_on_3d_points(self, varname, record, points):\n if self.get_mesh_dimension() != 3:\n raise TelemacException(\"Action possible only on 3d mesh\")\n\n res = float('nan')*np.ones((len(points)), dtype=np.float64)\n for i, point in enumerate(points):\n elev = self.get_data_on_vertical_segment(\\\n 'ELEVATION Z', record, point[:-1])\n values = self.get_data_on_vertical_segment(\\\n varname, record, point[:-1])\n for plan in range(self.nplan-1):\n if elev[plan] <= point[-1] and point[-1] <= elev[plan+1]:\n shz = (point[-1]-elev[plan])/max((elev[plan+1]\\\n -elev[plan]), 1.e-6)\n res[i] = (1.0-shz)*values[plan]+shz*values[plan+1]\n return res","def calc_msd(pos_x, pos_y, pos_z):\n particles = pos_x.shape[0]\n N = pos_x.shape[1] \n tamsd = np.zeros(shape = (particles, N - 1)) \n\n for p in np.arange(start = 0, stop = particles, step = 1): \n for n in np.arange(start = 1, stop = N, step = 1): \n sumdis = np.array([((pos_x[p, i + n] - pos_x[p, i]) ** 2 + (pos_y[p, i + n] - pos_y[p, i]) ** 2 + (pos_z[p, i + n] - pos_z[p, i]) ** 2) for i in np.arange(start = 1, stop = N - n, step = 1)]).sum()\n tamsd[p, n] = sumdis / (N - n) \n return tamsd","def index ( self, x, y, z ):\n if x < self.x_min or x > self.x_max:\n raise ValueError(\"x-value out of range %f (%f, %f)\" % \\\n (x,self.x_min,self.x_max))\n if y < self.y_min or y > self.y_max:\n raise ValueError(\"y-value out of range %f (%f, %f)\" % \\\n (y,self.y_min,self.y_max))\n if z < self.z_min or z > self.z_max:\n raise ValueError(\"z-value out of range %f (%f, %f)\" % \\\n (z,self.z_min,self.z_max))\n xi = int(round((x-self.x_min)/self.increment3D[0]))\n yi = int(round((y-self.y_min)/self.increment3D[1]))\n zi = int(round((z-self.z_min)/self.increment3D[2]))\n return xi, yi, zi","def prob4(d = 500): \n #import the plane data\n planeData = np.load(\"plane.npy\")\n \n tplane = planeData[:,0]\n alpha = np.deg2rad(planeData[:,1])\n beta = np.deg2rad(planeData[:,2])\n \n l = len(tplane)\n \n #define x and y functions\n def x(n):\n# Gives x position\n return d * np.tan(beta[n]) / (np.tan(beta[n]) - np.tan(alpha[n]))\n def y(n):\n# Gives y position\n return d * np.tan(beta[n]) * np.tan(alpha[n]) / (np.tan(beta[n]) - np.tan(alpha[n]))\n \n #define x and y prime as we will see them\n def xprime(n):\n# Gives the approximate derivative of x\n if n == 0:\n return fdq1(x, n, h = 1)\n elif n == l-1:\n return bdq1(x, n, h = 1)\n elif n > 0 and n < l:\n return cdq2(x, n, h = 1)\n else:\n return 0\n \n def yprime(n):\n# Gives the approximate derivative of y\n if n == 0:\n return fdq1(y, n, h = 1)\n elif n == l-1:\n return bdq1(y, n, h = 1)\n elif n > 0 and n < l:\n return cdq2(y, n, h = 1)\n else:\n return 0\n \n #define speed from x and y prime\n def speed(n):\n# print(\"speed(n) where n = \" + str(n))\n return np.sqrt((xprime(n))**2 + (yprime(n))**2)\n \n #Finally get the speed from the information we have\n spd = []\n X = []\n Y = []\n for i in range(0, l):\n spd.append(speed(i))\n X.append(x(i))\n Y.append(y(i))\n \n return spd\n \n raise NotImplementedError(\"Problem 4 Incomplete\")","def get_distance(self, x, y, z):\n\n up = [abs((p % self.unitcell) - self.unitcell/2) for p in (x,y,z)]\n dmin = 9999999.\n for l in self.types[self.type]:\n sp = [self.pointlist[l[0]][i] * self.unitcell for i in range(3)]\n ep = [self.pointlist[l[1]][i] * self.unitcell for i in range(3)]\n v = [ep[i]-sp[i] for i in range(3)]\n d = [up[i]-sp[i] for i in range(3)]\n # dot products\n c2 = sum([i*j for (i, j) in zip(v, v)])\n c1 = sum([i*j for (i, j) in zip(d, v)])\n\n b = c1/c2\n p = [sp[i] + b * v[i] for i in range(3)]\n dmin = min(dmin, sum([(up[i]-p[i])**2 for i in range(3)]))\n return math.sqrt(dmin) - self.thickness/2.0","def nxz(PAxz,PBxz,Npulse,P_times_Dj):\n return PAxz*PBxz*Npulse*P_times_Dj","def test_pid_ccs1():\n d = bivariates['gband']\n pid = PID_CCS(d, ((0,), (1,)), (2,))\n assert pid[((0,), (1,))] == pytest.approx(0.81127812445913283)\n assert pid[((0,),)] == pytest.approx(0.5)\n assert pid[((1,),)] == pytest.approx(0.5)\n assert pid[((0, 1),)] == pytest.approx(0.0)","def kp(self, x: float, y: float, z: float) -> int:\n result = self._read_inline(f\"kp({x},{y},{z})\")\n # todo: raise exception, if result == 0 (no node found)\n return int(result)","def point_count(N, S):\n\n x, y = make_grid(N)\n\n xc, yc = np.zeros_like(x), np.zeros_like(y)\n # grids for holding result of mandelbrot check\n \n z_binary = np.zeros( (N, N) )\n z_density = np.zeros( (N, N) )\n\n for (xi, i) in zip(x, xrange(N)):\n for (yi, j) in zip(y, xrange(N)):\n\n z = 0 ; s = 0\n c = complex( xi , yi ) \n abs_z = np.sqrt( z*z.conjugate() )\n # initial values for z, c, |z|, and step count\n\n for k in xrange(S):\n\n if abs_z > 2:\n break\n else:\n z_prim = z*z + c\n abs_z = np.sqrt( z_prim*z_prim.conjugate() )\n z = z_prim \n s += 1\n z_density[j, i] += 1\n \n\n\n if abs_z < 2:\n z_binary[j, i] = 1\n \n return z_binary, z_density","def __init__(self,\n p_xi: float, p_yi: float, p_zi: float,\n p_xx: float, p_yx: float, p_zx: float,\n p_xy: float, p_yy: float, p_zy: float,\n p_xz: float, p_yz: float, p_zz: float,\n p_ix: float, p_iy: float, p_iz: float) -> None:\n self._p_xi = value.validate_probability(p_xi, 'p_xi')\n self._p_yi = value.validate_probability(p_yi, 'p_yi')\n self._p_zi = value.validate_probability(p_zi, 'p_zi')\n self._p_xx = value.validate_probability(p_xx, 'p_xx')\n self._p_yx = value.validate_probability(p_yx, 'p_yx')\n self._p_zx = value.validate_probability(p_zx, 'p_zx')\n self._p_xy = value.validate_probability(p_xy, 'p_xy')\n self._p_yy = value.validate_probability(p_yy, 'p_yy')\n self._p_zy = value.validate_probability(p_zy, 'p_zy')\n self._p_xz = value.validate_probability(p_xz, 'p_xz')\n self._p_yz = value.validate_probability(p_yz, 'p_yz')\n self._p_zz = value.validate_probability(p_zz, 'p_zz')\n self._p_ix = value.validate_probability(p_ix, 'p_ix')\n self._p_iy = value.validate_probability(p_iy, 'p_iy')\n self._p_iz = value.validate_probability(p_iz, 'p_iz')\n self._p_ii = 1 - value.validate_probability(p_xi + p_yi + p_zi +\n p_xx + p_yx + p_zx +\n p_xy + p_yy + p_zy +\n p_xz + p_yz + p_zz +\n p_ix + p_iy + p_iz, 'p_ii')","def FindDistributedPoints(self, p_int, , vtkIdList, p_int_1):\n ...","def test(self, x, y, z):\n return self.a*x + self.b*y + self.c*z + self.d","def centerOfMass(data):\r\n dd = []\r\n for d in data:\r\n dd.append(d.coordinate)\r\n\r\n data = dd\r\n data = np.array(data)\r\n n = len(data)\r\n x = sum(data[:,0])\r\n y = sum(data[:,1])\r\n z = sum(data[:,2])\r\n x/=n\r\n y/=n\r\n z/=n\r\n return x,y,z,n","def three_dimensional(self, z): # Maybe I misunderstood the task. My method looks weird\n return (self.x, self.y, z)","def ppid(self):","def calcSpotCoordinates(self, A, B, C, D):\n pass","def _evaluate_xyz(self, x, y, z):\n return (\n 2.0\n * numpy.pi\n * self._b\n * self._c\n * _potInt(\n x, y, z, self._psi, self._b2, self._c2, glx=self._glx, glw=self._glw\n )\n )","def _pid_control(self, waypoint, vehicle_location, vehicle_rotation):\n ## Vehicle transform should be [x,y,z, roll, pitch, yaw]\n\n v_begin = np.array(vehicle_location)\n v_end = v_begin + np.array([math.cos(math.radians(vehicle_rotation)),\n math.sin(math.radians(vehicle_rotation)),0])\n # print(\"vbegin\"+str(v_begin)+\"vend\"+ str(v_end)+\"waypoint\"+str(waypoint))\n v_vec = np.array([v_end[0] - v_begin[0], v_end[1] - v_begin[1], 0.0])\n w_vec = np.array([waypoint[0] -\n v_begin[0], waypoint[1] -\n v_begin[1], 0.0])\n _dot = math.acos(np.clip(np.dot(w_vec, v_vec) /\n (np.linalg.norm(w_vec) * np.linalg.norm(v_vec)), -1.0, 1.0))\n\n _cross = np.cross(v_vec, w_vec)\n if _cross[2] < 0:\n _dot *= -1.0\n\n self._e_buffer.append(_dot)\n if len(self._e_buffer) >= 2:\n _de = (self._e_buffer[-1] - self._e_buffer[-2]) / self._dt\n _ie = sum(self._e_buffer) * self._dt\n else:\n _de = 0.0\n _ie = 0.0\n # print(\"dot\"+str(_dot)+\"de\"+str(_de)+\"ie\"+str(_ie))\n return np.clip((self._K_P * _dot) + (self._K_D * _de /\n self._dt) + (self._K_I * _ie * self._dt), -1.0, 1.0)","def computeCenters3d(self, data):\n\n\n for i in range(self.nPoints):\n print(\"Label of point \", i, \" is \", self.labels[i])\n for j in range(3):\n self.centers[self.labels[i]][j] += data[i][j]\n\n for c in range(self.n):\n for j in range(3):\n self.centers[c][j] /= self.tots[c]","def compute(self, *args, **kwargs):\n vertices = args[0]\n xpts = vertices[2] # z plays the 'x' part\n ypts = vertices[0] # x plays the 'y' part\n #zpts = vertices[1]\n #********************************************\n # switcharoo: using z in place of x\n # using x in place of y\n # i.e.\n #\n # y <- x\n # x <- z\n #\n qxdot = np.dot(xpts,self.localBasis[1])\n qxddot = np.dot(xpts,self.localBasis[2])\n qydot = np.dot(ypts,self.localBasis[1])\n qyddot = np.dot(ypts,self.localBasis[2])\n store = (qxdot*qyddot - qydot*qxddot)\n temp = np.sqrt(qxdot**2 + qydot**2)\n if isinstance(temp, ia):\n if temp.inf<=0:\n temp.inf = 0.\n denom = temp*((temp)**2)#**.5## #problem foud with sqrt\n #\n curvature = store/denom#((np.sqrt(qxdot*qxdot + qydot*qydot))**3.)\n return curvature","def _xforce_xyz(self,x,y,z):\n return -2.*np.pi*self._rhoc_M * self.a**3*self._b*self._c * \\\n _forceInt(x, y, z, self._a2, self._b2*self._a2, self._c2*self._a2, self.n, 0)","def calculate_potential_3D(true_csd, ele_xx, ele_yy, ele_zz, \n csd_x, csd_y, csd_z):\n xlin = csd_x[:,0,0]\n ylin = csd_y[0,:,0]\n zlin = csd_z[0,0,:]\n xlims = [xlin[0], xlin[-1]]\n ylims = [ylin[0], ylin[-1]]\n zlims = [zlin[0], zlin[-1]]\n sigma = 1.0\n pots = np.zeros(len(ele_xx))\n tic = time.time()\n for ii in range(len(ele_xx)):\n pots[ii] = integrate_3D(ele_xx[ii], ele_yy[ii], ele_zz[ii],\n xlims, ylims, zlims, true_csd, \n xlin, ylin, zlin, \n csd_x, csd_y, csd_z)\n print 'Electrode:', ii\n pots /= 4*np.pi*sigma\n toc = time.time() - tic\n print toc, 'Total time taken - series, sims'\n return pots","def _vorticity(vds) -> np.ndarray:\n from vector_calculus import Polar\n\n vorticity_z = Polar.curl(\n v_r=vds[\"v1\"],\n v_phi=vds[\"v2\"],\n r_coords=vds.get_ticks(axis=0),\n phi_coords=vds.get_ticks(axis=1),\n )\n return vorticity_z","def particle(*args, attribute: Union[AnyStr, bool]=\"\", cache: bool=True, conserve: Union[float,\n bool]=0.0, count: bool=True, deleteCache: bool=True, dynamicAttrList: bool=True,\n floatValue: float=0.0, gridSpacing: Union[float, List[float], bool]=0.0, inherit:\n Union[float, bool]=0.0, jitterBasePoint: Union[List[float, float, float],\n List[List[float, float, float]], bool]=None, jitterRadius: Union[float,\n List[float], bool]=0.0, lowerLeft: Union[List[float, float, float],\n List[List[float, float, float]], bool]=None, name: Union[AnyStr, bool]=\"\",\n numJitters: Union[int, List[int], bool]=0, order: Union[int, bool]=0, particleId:\n Union[int, bool]=0, perParticleDouble: bool=True, perParticleVector: bool=True,\n position: Union[List[float, float, float], List[List[float, float, float]]]=None,\n shapeName: Union[AnyStr, bool]=\"\", upperRight: Union[List[float, float, float],\n List[List[float, float, float]], bool]=None, vectorValue: List[float, float,\n float]=None, q=True, query=True, e=True, edit=True, **kwargs)->Union[AnyStr, Any]:\n pass","def parade(p:dict, x:Union[List[SupportsFloat],None], y:Union[SupportsFloat,None]):\n # Initialize\n if not p:\n k = len(x)\n p = {'predictions': [[] for _ in range(k)], # Holds the cavalcade\n 'moments': [var_init() for _ in range(k)]} # Could use kurtosis_init here for more moment\n else:\n assert len(x) == len(p['predictions']) # 'k' is immutable\n\n if x is None and y is None:\n # \"reset\" the running moments but keep prediction parade\n p_mean, p_std = parade_mean(p), parade_std(p)\n p['moments'] = [var_init() for _ in range(k)]\n return p_mean, p_std, p\n else:\n assessable = p['predictions'].pop(0)\n if assessable:\n for j,xi in assessable:\n p['moments'][j] = var_update(p['moments'][j], y - xi)\n\n p['predictions'].append(list())\n for j, xj in enumerate(x):\n p['predictions'][j].append((j, xj))\n\n return parade_mean(p), parade_std(p), p","def distance((x,y,z),(x0,y0,z0)):\n return sqrt((x-x0)**2+(y-y0)**2+(z-z0)**2)","def make_parabola(self, x1, y1, x2, y2, x3, y3, static_var, static_val):\r\n denom = 1.0 * (x1 - x2) * (x1 - x3) * (x2 - x3)\r\n if denom == 0:\r\n denom = 0.000000000000001\r\n # TODO this feels hacky - is it ok?\r\n a = (x3 * (y2 - y1) + x2 * (y1 - y3) + x1 * (y3 - y2)) / denom\r\n b = (x3 * x3 * (y1 - y2) + x2 * x2 * (y3 - y1) + x1 * x1 * (y2 - y3)) / denom\r\n c = (x2 * x3 * (x2 - x3) * y1 + x3 * x1 * (x3 - x1) * y2 + x1 * x2 * (x1 - x2) * y3) / denom\r\n x_pos = np.arange(x1, x2, self.step_size) # x is the nonstatic var so this should be the range\r\n z_pos = [] # stored so if we wanted to do something with the coordinate pairs we could\r\n # Calculate y values\r\n for x in range(len(x_pos)):\r\n x_val = x_pos[x]\r\n z = +1 * (a * (x_val ** 2)) + (b * x_val) + c\r\n z = abs(z)\r\n z_pos.append(z)\r\n if static_var == \"x\":\r\n self.print_command([static_val, x_val, z]) # If x is static it never changes\r\n elif static_var == \"y\":\r\n self.print_command([x_val, static_val, z]) # If y is static it never changes\r\n else:\r\n if self.print_to_terminal == True:\r\n print(\"; make_parabola() can only create parabolas in the xz and yz planes. \\n\")\r\n if self.output_file is not None:\r\n file = open(self.output_file, \"a\")\r\n file.write(\"; make_parabola() can only create parabolas in the xz and yz planes. \\n\")\r\n file.close()\r\n break","def compute_pe(X, bl, ip, box):\n N = len(X)\n inv_box = np.zeros((3, 3))\n for i in range(3): inv_box[i, i] = 1.0 / box[i, i]\n rij = np.zeros(3)\n g = np.zeros(3)\n a = 0.0\n\n PE = 0.0\n for i in range(N):\n for j in range(i):\n rij = X[i] - X[j]\n g = matvecmul(inv_box, rij)\n g = g - round_numba(g)\n rij = matvecmul(box, g)\n a = ip[bl[i]-1, bl[j]-1]\n PE += a * wr(norm_numba(rij))**2 / 2.0\n return PE","def threeptscurv(x, y):\n length = x.size\n R = np.zeros(length)\n cur = np.zeros(length)\n for i in range(1, length-1):\n a = np.sqrt((x[i+1]-x[i])**2 + (y[i+1]-y[i])**2)\n b = np.sqrt((x[i+1]-x[i-1])**2 + (y[i+1]-y[i-1])**2)\n c = np.sqrt((x[i]-x[i-1])**2 + (y[i]-y[i-1])**2)\n p = (a+b+c)/2\n R[i] = a*b*c/4/np.sqrt(p*(p-a)*(p-b)*(p-c))\n cur[i] = 1/R[i]\n if R[i] > 1/ZERO or np.isnan(R[i]):\n cur[i] = 0\n return cur","def hamiltonian_dp_components(Nx, Ny):\n N = Nx * Ny\n nearest, second, third = _generate_bonds(Nx, Ny)\n H_pm1, H_z1 = _gen_z_pm_ops(N, nearest)\n H_pm2, H_z2 = _gen_z_pm_ops(N, second)\n H_pm3, H_z3 = _gen_z_pm_ops(N, third)\n\n H_ppmm = H_pmz = 0\n p_mats, m_mats, z_mats = _gen_full_ops(N)\n for bond in nearest:\n site1, site2 = bond\n i, j = site1.lattice_index, site2.lattice_index\n γ = np.exp(1j * site1.angle_with(site2))\n\n H_ppmm += \\\n γ * p_mats[i].dot(p_mats[j]) + \\\n γ.conj() * m_mats[i].dot(m_mats[j])\n\n H_pmz += 1j * (γ.conj() * z_mats[i].dot(p_mats[j]) -\n γ * z_mats[i].dot(m_mats[j]) +\n γ.conj() * p_mats[i].dot(z_mats[j]) -\n γ * m_mats[i].dot(z_mats[j]))\n\n return H_pm1, H_z1, H_ppmm, H_pmz, H_pm2, H_z2, H_z3, H_pm3","def createThreePoints(cls, x1, y1, z1, x2, y2, z2, x3, y3, z3):\n d = np.array([x2 - x1, y2 - y1, z2 - z1])\n p0 = np.array([x1, y1, z1])\n return cls(p0, d)","def normalize(x: float, y: float, z: float) -> Point3D:\n mag = math.sqrt(x*x + y*y + z*z)\n return x/mag, y/mag, z/mag","def compute_bulk_z(xy, NL, KL, BL):\n NP = len(xy)\n boundary = extract_boundary(xy, NL, KL, BL)\n bulk = np.setdiff1d(np.arange(NP), boundary)\n # Compute the starting z in the bulk\n countKL = [KL[jj] for jj in bulk]\n # print 'found = ', np.count_nonzero(countKL), ' connections for ', NP_bulk, ' bulk particles...'\n z = float(np.count_nonzero(countKL)) / float(len(bulk))\n return z","def _zforce_xyz(self,x,y,z):\n return -2.*np.pi*self._rhoc_M * self.a**3*self._b*self._c * \\\n _forceInt(x, y, z, self._a2, self._b2*self._a2, self._c2*self._a2, self.n, 2)","def processParticles(self,imgdata,partdatas,shiftdata):\n\t\traise NotImplementedError()","def get_3d_points(preds_3d):\n for i,p in enumerate(preds_3d):\n preds_3d[i] = preds_3d[i] - preds_3d[i].mean(0)*np.ones((16,1));\n return preds_3d;","def extractCoords(self):\n if not self.rank:\n logging.info('Extracting atomic poitions')\n\n # Extract coordinates from liggghts\n self.lmp.command('variable x atom x')\n x = Rxn.lmp.extract_variable(\"x\", \"group1\", 1)\n\n self.lmp.command('variable y atom y')\n y = Rxn.lmp.extract_variable(\"y\", \"group1\", 1)\n\n self.lmp.command('variable z atom z')\n z = Rxn.lmp.extract_variable(\"z\", \"group1\", 1)\n\n coords = np.zeros((self.lmp.get_natoms(),3))\n\n for i in range(self.lmp.get_natoms()):\n coords[i,:] = x[i], y[i], z[i]\n\n self.lmp.command('variable x delete')\n self.lmp.command('variable y delete')\n self.lmp.command('variable z delete')\n\n return coords","def point3D(self, plan, sequence, imgnum, pts):\n xs, ys, zs = list(), list(), list()\n\n if imgnum < 10:\n img = pydicom.dcmread(\"{}/{}/{}/{}/IM_0000{}.dcm\".format(\n DIR_DICOM, self.patient, plan, sequence, imgnum))\n # img = dicom.read_file(\"{}/{}/{}/{}/IM_0000{}.dcm\".format(\n # DIR_DICOM, self.patient, plan, sequence, imgnum))\n else:\n img = pydicom.dcmread(\"{}/{}/{}/{}/IM_000{}.dcm\".format(\n DIR_DICOM, self.patient, plan, sequence, imgnum))\n # img = dicom.read_file(\"{}/{}/{}/{}/IM_000{}.dcm\".format(\n # DIR_DICOM, self.patient, plan, sequence, imgnum))\n\n xx_s7 = img.ImageOrientationPatient[0]\n xy_s7 = img.ImageOrientationPatient[1]\n xz_s7 = img.ImageOrientationPatient[2]\n\n yx_s7 = img.ImageOrientationPatient[3]\n yy_s7 = img.ImageOrientationPatient[4]\n yz_s7 = img.ImageOrientationPatient[5]\n\n delta_i_s7 = img.PixelSpacing[0]\n delta_j_s7 = img.PixelSpacing[1]\n\n sx_s7 = img.ImagePositionPatient[0]\n sy_s7 = img.ImagePositionPatient[1]\n sz_s7 = img.ImagePositionPatient[2]\n\n m = np.matrix([\n [xx_s7 * delta_i_s7, yx_s7 * delta_j_s7, 0.0, sx_s7],\n [xy_s7 * delta_i_s7, yy_s7 * delta_j_s7, 0.0, sy_s7],\n [xz_s7 * delta_i_s7, yz_s7 * delta_j_s7, 0.0, sz_s7],\n [0.0, 0.0, 0.0, 1.0]\n ])\n\n for p in pts:\n m2 = np.matrix([\n [p[0]],\n [p[1]],\n [0.0],\n [1.0]\n ])\n\n m_res = np.dot(m, m2)\n\n xs.append(m_res.item((0, 0)))\n ys.append(m_res.item((1, 0)))\n zs.append(m_res.item((2, 0)))\n\n return xs, ys, zs","def ion2_position(self,x,y,z):\n axes_vector = np.array([self.a,self.b,self.c])\n self.ion2 = x*self.a + y*self.b + z*self.c\n self.position['1B'] = np.dot(self.position_map[1],axes_vector) + self.ion2\n self.position['2B'] = np.dot(self.position_map[2],axes_vector) + self.ion2\n self.position['3B'] = np.dot(self.position_map[3],axes_vector) + self.ion2\n self.position['4B'] = np.dot(self.position_map[4],axes_vector) + self.ion2\n self.position['5B'] = np.dot(self.position_map[5],axes_vector) + self.ion2\n self.position['6B'] = np.dot(self.position_map[6],axes_vector) + self.ion2\n self.position['7B'] = np.dot(self.position_map[7],axes_vector) + self.ion2\n self.position['8B'] = np.dot(self.position_map[8],axes_vector) + self.ion2","def box_collision_info(self):\r\n position = np.zeros((self.Npart,3)) # antall part, dim, iterasjoner\r\n position[:,:] = np.random.uniform(0,1e-6, size = (self.Npart,3))\r\n velocity = np.zeros((self.Npart,3))\r\n velocity[:,:] = np.random.normal(0,self.sigma,size = (self.Npart,3))\r\n\r\n part_collided = 0\r\n part_escaped = 0\r\n momentum = 0\r\n\r\n print 'engine started'\r\n for i in xrange(1,self.n):\r\n #collision\r\n position += velocity*dt\r\n l_hole = position[:,0:2] > self.L/4\r\n h_hole = position[:,0:2] < (3*self.L)/4\r\n pos_xy = np.logical_and(l_hole, h_hole)\r\n pos_xy = np.logical_and(pos_xy[:,0], pos_xy[:,1])\r\n pos_z = position[:,2] < 0\r\n esc_part = np.logical_and(pos_z, pos_xy)\r\n\r\n #velocity[esc_part] = velocity[esc_part]\r\n part_escaped += np.sum(esc_part)\r\n\r\n for j in xrange(0,3):\r\n impact_wall_pos = np.logical_and(position[:,j] > 0,\r\n position[:,j] < self.L)\r\n velocity[np.logical_not(impact_wall_pos),j] = -velocity[\r\n np.logical_not(impact_wall_pos),j]\r\n\r\n\r\n if j == 0:\r\n part_collided += np.sum(np.logical_not(impact_wall_pos),j)\r\n momentum += np.sum(2*self.m*abs(velocity[np.logical_not(\r\n impact_wall_pos),j]))\r\n\r\n\r\n\r\n position[position < 0] = 0\r\n position[position >self.L] = self.L\r\n\r\n particle_collided = part_collided/2\r\n return position, velocity,part_escaped, impact_wall_pos, particle_collided, momentum","def plot_results_3d(p_x, p_y, p_z, h_exp = 0.5):\n plt.figure(figsize = (10, 10))\n ax3d = plt.axes(projection = '3d') \n\n color=iter(cm.rainbow(np.linspace(0,1,p_x.shape[0]))) # (1)\n labels = ['Particle ' + str(pl+1) for pl in np.arange(0, p_x.shape[0], step = 1)]\n \n for p in np.arange(0, p_x.shape[0], step = 1): \n c = next(color) # (1)\n for t in np.arange(0, p_x.shape[1], step = 1): \n ax3d.plot3D(p_x[p, t], p_y[p, t], p_z[p, t], 'x', c = c, label = labels[p]) \n legend_without_duplicate_labels(ax3d)\n ax3d.set_xlabel('X (pixels)') \n ax3d.set_ylabel('Y (pixels') \n ax3d.set_zlabel('Z (pixels)') \n ax3d.set_xlim([origin-150,origin+150])\n ax3d.set_ylim([origin-150,origin+150])\n ax3d.set_zlim([origin-150,origin+150])\n ax3d.set_title('3D particle trajectories - H = ' + str(h_exp))","def h(pos,obj):\n return D(pos)*(distancia_nodos(pos,obj))","def setParams(self, p = 2):\n self.p = p\n self.l = p - 1\n self.id_ntot = {}\n self.id_y = {}\n self.id_W = {}\n self.id_X = {}\n for i in self.uniids:\n tracker = (self.data['id'] == i)\n self.id_ntot.update({i: np.sum(tracker)})\n self.id_y.update({i:\n self.data['weight'][tracker].reshape(np.sum(tracker), 1)})\n self.id_W.update({i: self._designMatrix_(p, tracker)})\n self.id_X.update({i:\n self._designMatrix_(self.l+1,tracker,is_X=True)})\n self.id_Z = self.id_W.copy()","def num_particles(self) -> Tuple[int, int]:\n return (self.num_alpha, self.num_beta)","def point_from_rays(self):\n print \"generating the 3d point from given clicked points\"\n \n #gather cams and points clicked \n uvs = []\n cams = []\n for iFrame in self.frames:\n if iFrame.lastClick : \n uv = numpy.multiply(iFrame.lastClick,self.reduceFactor)\n uvs.append(uv)\n cam = load_perspective_camera(self.camList[iFrame.currImg])\n cams.append(cam)\n point = get_3d_from_cams(cams, uvs)\n self.point3d = point;\n self.pointLabel.set(\"3d Point: \" + str(self.point3d))\n\n # project 3d point into each image, and gather intensities \n values = []\n ims = []\n for idx, img in enumerate(self.imgList):\n cam = load_perspective_camera(self.camList[idx])\n imgPoint = project_point(cam, point[0], point[1], point[2])\n imgPoint = numpy.divide(imgPoint, self.reduceFactor)\n self.allUVs.append(imgPoint)\n \n #grab float intensity value at this point \n imgView,ni,nj = load_image(img)\n val = pixel(imgView, imgPoint)\n if val > 0.0:\n values.append(val)\n ims.append(idx)\n \n #cleanup\n remove_from_db([imgView, cam])\n \n\n #write mean/std of intensities \n self.meanLabel.set(\"Mean: \" + str(numpy.mean(values)) )\n self.stdLabel.set(\"Std Dev: \" + str(numpy.std(values)) )\n #plot the intensities by image number \n self.f.clf();\n self.a = self.f.add_subplot(311)\n self.a.set_xlabel(\"img #\")\n self.a.set_ylabel(\"intensity\")\n self.a.plot(ims, values)\n #plot the histogram of intensities by image number \n pdf, bins, patches = plt.hist(values)\n self.b = self.f.add_subplot(313)\n self.b.set_xlabel(\"bin val\")\n self.b.set_ylabel(\"freq\")\n self.b.hist(values, 15, normed=1, facecolor=\"green\" )\n self.canvas.show();","def get_coord_val(self, x, y, z):\n if self.is_4d():\n #return self._data[y, x, z, self._time_point]\n return self._data[self._y_shift - y, x, z, self._time_point]\n else:\n #return self._data[y, x, z]\n return self._data[self._y_shift - y, x, z]","def x_add_particles():\n particle_count_list = np.zeros(7)","def optimise_xy(xy, *args):\n z, elements, coordinates = args\n window_com = np.array([xy[0], xy[1], z])\n return -pore_diameter(elements, coordinates, com=window_com)[0]","def get_xyz_in_coord_vectorized(self, model, cid=0, fdtype='float32'):\n xyz_cid0 = None\n nid_cp_cd = None\n if self.gui.nnodes > 0:\n #xyz_cid0 = {}\n #nid_cp_cd = {}\n\n out = model.get_displacement_index_xyz_cp_cd(\n fdtype=fdtype, idtype='int32')\n icd_transform, icp_transform, xyz_cp, nid_cp_cd = out\n self.icd_transform = icd_transform\n\n #print(\"transform_xyzcp_to_xyz_cid\")\n #model.nodes.cp = nid_cp_cd[:, 1]\n xyz_cid0 = model.transform_xyzcp_to_xyz_cid(\n xyz_cp, nid_cp_cd[:, 0], icp_transform, cid=cid,\n in_place=False)\n model.nodes.xyz_cid0 = xyz_cid0\n model.nodes.nids = nid_cp_cd[:, 0]\n\n nid_map = self.gui.nid_map\n for i, nid in enumerate(nid_cp_cd[:, 0]):\n nid_map[nid] = i\n\n self._add_nastran_spoints_to_grid(model.spoints, nid_map)\n return xyz_cid0, nid_cp_cd","def setupParticles(self):\n\n for ss in self.pargs['species']:\n\n # Make sure we are setting up particles, not walls (so we check for id existence)\n if 'id' in ss and 'wall' not in ss:\n if not self.rank:\n logging.info('Setting up particles for group{id}'.format(**ss))\n\n randName = np.random.randint(10**5,10**8)\n pddName = 'pdd' + '{}'.format(np.random.randint(10**5,10**8))\n\n if 'vol_lim' not in ss:\n ss['vol_lim'] = 1e-20\n\n id = ss['id'] - 1\n self.lmp.command('group group{} type {}'.format(id, ss['id']))\n\n if 'args'in ss:\n args = ss['args']\n else:\n args = ()\n\n if 'radius' in ss:\n radius = ss['radius']\n\n if not isinstance(radius, tuple):\n radius = ('constant', radius)\n\n self.lmp.command('fix {} '.format(randName) + 'group{}'.format(id) + ' particletemplate/{style} 15485867 volume_limit {vol_lim} atom_type {id} density constant {density} radius'.format(**ss) + (' {}' * len(radius)).format(*radius) \\\n + (' {}' * len(args)).format(*args))\n else:\n self.lmp.command('fix {} '.format(randName) + 'group{}'.format(id) + ' particletemplate/{style} 15485867 volume_limit {vol_lim} atom_type {id} density constant {density}'.format(**ss) + (' {}' * len(args)).format(*args))\n \n self.lmp.command('fix {} '.format(pddName) + 'group{}'.format(id) + ' particledistribution/discrete 67867967 1'.format(**ss) + ' {} 1.0'.format(randName))\n\n if ss['style'] is 'multisphere':\n itype = ss['style']\n else:\n itype = 'nve/{style}'.format(**ss)\n\n #Do NOT unfix randName! Will cause a memory corruption error\n self.pddName.append(pddName)","def calculate_dimensions(self):\n x_coordinates = np.sort(self.grid['x'][:, 0]) # first x node\n self.nr_nodes_z = np.where(x_coordinates == x_coordinates[0])[0].size\n self.nr_elements_x = self.elements.shape[0] / (self.nr_nodes_z - 1)\n self.nr_nodes_x = self.nr_elements_x + 1\n self.nr_elements_z = self.nr_nodes_z - 1","def test_pid_proj2():\n d = bivariates['reduced or']\n pid = PID_IG(d, [[0], [1]], [2])\n assert pid[((0,), (1,))] == pytest.approx(-0.03122, abs=1e-4)\n assert pid[((0,),)] == pytest.approx(0.34250, abs=1e-4)\n assert pid[((1,),)] == pytest.approx(0.34250, abs=1e-4)\n assert pid[((0, 1),)] == pytest.approx(0.34622, abs=1e-4)","def _derX(self, x, y, z):\n if _isscalar(x):\n x_pos = max(min(self.xSearchFunc(self.x_list, x), self.x_n - 1), 1)\n y_pos = max(min(self.ySearchFunc(self.y_list, y), self.y_n - 1), 1)\n z_pos = max(min(self.zSearchFunc(self.z_list, z), self.z_n - 1), 1)\n else:\n x_pos = self.xSearchFunc(self.x_list, x)\n x_pos[x_pos < 1] = 1\n x_pos[x_pos > self.x_n - 1] = self.x_n - 1\n y_pos = self.ySearchFunc(self.y_list, y)\n y_pos[y_pos < 1] = 1\n y_pos[y_pos > self.y_n - 1] = self.y_n - 1\n z_pos = self.zSearchFunc(self.z_list, z)\n z_pos[z_pos < 1] = 1\n z_pos[z_pos > self.z_n - 1] = self.z_n - 1\n beta = (y - self.y_list[y_pos - 1]) / (\n self.y_list[y_pos] - self.y_list[y_pos - 1]\n )\n gamma = (z - self.z_list[z_pos - 1]) / (\n self.z_list[z_pos] - self.z_list[z_pos - 1]\n )\n dfdx = (\n (\n (1 - beta) * (1 - gamma) * self.f_values[x_pos, y_pos - 1, z_pos - 1]\n + (1 - beta) * gamma * self.f_values[x_pos, y_pos - 1, z_pos]\n + beta * (1 - gamma) * self.f_values[x_pos, y_pos, z_pos - 1]\n + beta * gamma * self.f_values[x_pos, y_pos, z_pos]\n )\n - (\n (1 - beta)\n * (1 - gamma)\n * self.f_values[x_pos - 1, y_pos - 1, z_pos - 1]\n + (1 - beta) * gamma * self.f_values[x_pos - 1, y_pos - 1, z_pos]\n + beta * (1 - gamma) * self.f_values[x_pos - 1, y_pos, z_pos - 1]\n + beta * gamma * self.f_values[x_pos - 1, y_pos, z_pos]\n )\n ) / (self.x_list[x_pos] - self.x_list[x_pos - 1])\n return dfdx","def assignPositions(self):\n n = int(math.ceil(self.numAtoms**(1.0/3.0))) # Number of atoms in a direction\n particle = 0 # Particles placed so far\n \n for x in range(0, n):\n for y in range(0, n):\n for z in range(0, n):\n if (particle < self.numAtoms):\n self.atoms[particle].x = x * self.sigma\n self.atoms[particle].y = y * self.sigma \n self.atoms[particle].z = z * self.sigma\n particle += 1","def _get_pid(split_data, sensor):\n prot, ip_dst, port_dst, timestamp = split_data\n prot = prot.lower()\n\n if not sanitizer.check_get_pid_params(prot, ip_dst, port_dst, timestamp):\n return '-1,error checking input'\n\n return sensor.search_process(prot, ip_dst, port_dst, timestamp)","def _compute_ptdfs(self):\n z = self._compute_z()\n s = np.zeros([self.n_nodes, self.n_nodes, self.n_nodes])\n for k in range(self.n_nodes):\n for L in range(self.n_nodes):\n for i in range(self.n_nodes):\n if k == 0 and L != 0:\n s[k, L, i] = -1 * z[L-1, i-1]\n elif k != 0 and L == 0:\n s[k, L, i] = z[k-1, i-1]\n elif k != 0 and L != 0 and k != L:\n s[k, L, i] = z[k-1, i-1] - z[L-1, i-1]\n return s","def FindPointsWithinRadius(self, p_float, , vtkIdList):\n ...","def pairCorrelationFunction_3D(x, y, z, S, rMax, dr):\n from numpy import zeros, sqrt, where, pi, mean, arange, histogram\n\n # Find particles which are close enough to the cube center that a sphere of radius\n # rMax will not cross any face of the cube\n bools1 = x > rMax\n bools2 = x < (S - rMax)\n bools3 = y > rMax\n bools4 = y < (S - rMax)\n bools5 = z > rMax\n bools6 = z < (S - rMax)\n\n interior_indices, = where(bools1 * bools2 * bools3 * bools4 * bools5 * bools6)\n num_interior_particles = len(interior_indices)\n\n if num_interior_particles < 1:\n raise RuntimeError (\"No particles found for which a sphere of radius rMax\\\n will lie entirely within a cube of side length S. Decrease rMax\\\n or increase the size of the cube.\")\n\n edges = arange(0., rMax + 1.1 * dr, dr)\n num_increments = len(edges) - 1\n g = zeros([num_interior_particles, num_increments])\n radii = zeros(num_increments)\n numberDensity = len(x) / S**3\n\n # Compute pairwise correlation for each interior particle\n for p in range(num_interior_particles):\n index = interior_indices[p]\n d = sqrt((x[index] - x)**2 + (y[index] - y)**2 + (z[index] - z)**2)\n d[index] = 2 * rMax\n\n (result, bins) = histogram(d, bins=edges, normed=False)\n g[p,:] = result / numberDensity\n\n # Average g(r) for all interior particles and compute radii\n g_average = zeros(num_increments)\n for i in range(num_increments):\n radii[i] = (edges[i] + edges[i+1]) / 2.\n rOuter = edges[i + 1]\n rInner = edges[i]\n g_average[i] = mean(g[:, i]) / (4.0 / 3.0 * pi * (rOuter**3 - rInner**3))\n\n return (g_average, radii, interior_indices)\n # Number of particles in shell/total number of particles/volume of shell/number density\n # shell volume = 4/3*pi(r_outer**3-r_inner**3)"],"string":"[\n \"def elec_p_xyz_loop(x, y, z):\\n U = 0.\\n\\n r = np.sqrt(x**2 + y**2 + z**2)\\n x = x/r\\n y = y/r\\n z = z/r\\n\\n npts = x.size\\n for i in range(npts-1):\\n for j in range(i+1, npts):\\n dsq = (x[i]-x[j])**2 + (y[i]-y[j])**2 + (z[i]-z[j])**2\\n U += 1./np.sqrt(dsq)\\n return U\",\n \"def cal_pt(self):\\n\\n if not self.check_def(['E','px','py','pz']):\\n sys.exit('Particle error: Quadri impulsion not define (error for pt routine)')\\n\\n self.pt =math.sqrt(self.px**2+self.py**2)\",\n \"def computePID(setpoint,\\n _input, last_error, prev_time):\\n kp = 0.5\\n kd = 5\\n ki = 0.02\\n\\n current_time = time.time()\\n d_time = current_time - prev_time\\n \\n error = setpoint - _input\\n #print(\\\"error\\\", error)\\n\\n #error_sum += (error * d_time)\\n \\n d_error = (error - last_error) / d_time\\n\\n output = kp * error #+ kd * d_error#ki * error_sum + kd * d_error\\n last_error = error\\n prev_time = current_time\\n \\n return output, last_error, prev_time\",\n \"def test_pid_ccs3():\\n d = trivariates['anddup']\\n pid = PID_CCS(d)\\n for atom in pid._lattice:\\n if atom == ((0,), (1,), (2,)):\\n assert pid[atom] == pytest.approx(0.10375937481971094)\\n elif atom in [((0,), (2,)), ((1,),)]:\\n assert pid[atom] == pytest.approx(0.20751874963942191)\\n elif atom in [((2,), (0, 1)), ((0,), (1, 2)), ((0, 1), (0, 2)), ((0, 1), (1, 2)), ((0, 2), (1, 2)), ((0, 1, 2),)]:\\n assert pid[atom] == pytest.approx(0.14624062518028902)\\n elif atom in [((2,),), ((0,),), ((0, 1), (0, 2), (1, 2)), ((0, 2),)]:\\n assert pid[atom] == pytest.approx(-0.14624062518028902)\\n else:\\n assert pid[atom] == pytest.approx(0.0)\",\n \"def __init__(self):\\n self.pidDict = { # particle_name, pid\\n \\\"total\\\" : 0,\\n \\\"charged\\\" : 1,\\n \\\"charged_eta\\\" : 2,\\n \\\"pion\\\" : 6, # sum(7, 8, -7)\\n \\\"pion_p\\\" : 7,\\n \\\"pion_0\\\" : 8,\\n \\\"pion_m\\\" : -7,\\n \\\"kaon\\\" : 11, # sum(12, 13)\\n \\\"kaon_p\\\" : 12,\\n \\\"kaon_0\\\" : 13,\\n \\\"anti_kaon\\\" : -11, # sum(-12, -13)\\n \\\"kaon_m\\\" : -12,\\n \\\"anti_kaon_0\\\" : -13,\\n \\\"nucleon\\\" : 16, # sum(17, 18)\\n \\\"proton\\\" : 17,\\n \\\"neutron\\\" : 18,\\n \\\"anti_nucleon\\\" : -16, # sum(-17, -18)\\n \\\"anti_proton\\\" : -17,\\n \\\"anti_neutron\\\" : -18,\\n \\\"sigma\\\" : 21, # sum(22, 23, 24)\\n \\\"sigma_p\\\" : 22,\\n \\\"sigma_0\\\" : 23,\\n \\\"sigma_m\\\" : 24,\\n \\\"anti_sigma\\\" : -21,\\n \\\"anti_sigma_p\\\" : -22,\\n \\\"anti_sigma_0\\\" : -23,\\n \\\"anti_sigma_m\\\" : -24,\\n \\\"xi\\\" : 26, # sum(27, 28)\\n \\\"xi_0\\\" : 27,\\n \\\"xi_m\\\" : 28,\\n \\\"anti_xi\\\" : -26,\\n \\\"anti_xi_0\\\" : -27,\\n \\\"anti_xi_m\\\" : -28,\\n \\\"lambda\\\" : 31,\\n \\\"anti_lambda\\\" : -31,\\n \\\"omega\\\" : 36,\\n \\\"anti_omega\\\" : -36,\\n \\\"phi\\\" : 41,\\n \\\"rho\\\" : 46, #sum(47, 48, -47)\\n \\\"rho_p\\\" : 47,\\n \\\"rho_0\\\" : 48,\\n \\\"rho_m\\\" : -47,\\n \\\"eta\\\" : 51,\\n \\\"eta_prime\\\" : 52,\\n \\\"gamma\\\" : 61,\\n \\\"omega782\\\" : 65,\\n \\\"eta\\\" : 71,\\n \\\"etap\\\" : 72,\\n }\\n\\n for aParticle in self.pidDict.keys():\\n if self.pidDict[aParticle]>=0:\\n self.pidDict[aParticle+\\\"_hydro\\\"] = self.pidDict[aParticle]+1000\\n else:\\n self.pidDict[aParticle+\\\"_hydro\\\"] = self.pidDict[aParticle]-1000\\n if self.pidDict[aParticle]>=0:\\n self.pidDict[aParticle+\\\"_thermal\\\"] = self.pidDict[aParticle]+2000\\n else:\\n self.pidDict[aParticle+\\\"_thermal\\\"] = self.pidDict[aParticle]-2000\\n\\n self.pidDict.update({\\n \\\"photon_total\\\" : 9000,\\n \\\"photon_total_eq\\\" : 9001,\\n \\\"photon_QGP_tot\\\" : 9002,\\n \\\"photon_QGP_eq\\\" : 9003,\\n \\\"photon_HG_tot\\\" : 9004,\\n \\\"photon_HG_eq\\\" : 9005,\\n \\\"direct_gamma_shortdecay_hydro\\\" : 9006,\\n \\\"decay_gamma_pi0_hydro\\\" : 9007,\\n \\\"decay_gamma_eta_hydro\\\" : 9008,\\n \\\"decay_gamma_omega_hydro\\\" : 9009,\\n \\\"decay_gamma_phi_hydro\\\" : 9010,\\n \\\"decay_gamma_etap_hydro\\\" : 9011,\\n \\\"decay_gamma_Sigma0_hydro\\\" : 9012,\\n })\\n\\n #UrQMD pid Dictionary, name conversion defined as in binUtility\\n self.UrQMDpidDict = { #particle name, UrQMD id# : isospin*2000 + pid\\n 2101 : \\\"pion_p\\\",\\n -1899 : \\\"pion_m\\\",\\n 101 : \\\"pion_0\\\",\\n 1106 : \\\"kaon_p\\\",\\n -894 : \\\"kaon_0\\\",\\n -1106 : \\\"kaon_m\\\",\\n 894 : \\\"anti_kaon_0\\\",\\n 1001 : \\\"proton\\\",\\n -999 : \\\"neutron\\\",\\n -1001 : \\\"anti_proton\\\",\\n 999 : \\\"anti_neutron\\\",\\n 2040 : \\\"sigma_p\\\",\\n -1960 : \\\"sigma_m\\\",\\n 40 : \\\"sigma_0\\\",\\n -2040 : \\\"anti_sigma_p\\\",\\n 1960 : \\\"anti_sigma_m\\\",\\n -40 : \\\"anti_sigma_0\\\",\\n 1049 : \\\"xi_0\\\",\\n -951 : \\\"xi_m\\\",\\n -1049 : \\\"anti_xi_0\\\",\\n 951 : \\\"anti_xi_m\\\",\\n 27 : \\\"lambda\\\",\\n -27 : \\\"anti_lambda\\\",\\n 55 : \\\"omega\\\",\\n -55 : \\\"anti_omega\\\",\\n 109 : \\\"phi\\\",\\n 102 : \\\"eta\\\",\\n 107 : \\\"eta_prime\\\",\\n 100 : \\\"gamma\\\",\\n }\\n\\n #pdg pid Dictionary\\n self.PDGpidDict = { #pdg id#, particle name\\n 211 : \\\"pion_p\\\",\\n -211 : \\\"pion_m\\\",\\n 111 : \\\"pion_0\\\",\\n 321 : \\\"kaon_p\\\",\\n 311 : \\\"kaon_0\\\",\\n -321 : \\\"kaon_m\\\",\\n -311 : \\\"anti_kaon_0\\\",\\n 2212 : \\\"proton\\\",\\n 2112 : \\\"neutron\\\",\\n -2212 : \\\"anti_proton\\\",\\n -2112 : \\\"anti_neutron\\\",\\n 3222 : \\\"sigma_p\\\",\\n 3112 : \\\"sigma_m\\\",\\n 3212 : \\\"sigma_0\\\",\\n -3222 : \\\"anti_sigma_p\\\",\\n -3112 : \\\"anti_sigma_m\\\",\\n -3212 : \\\"anti_sigma_0\\\",\\n 3322 : \\\"xi_0\\\",\\n 3312 : \\\"xi_m\\\",\\n -3322 : \\\"anti_xi_0\\\",\\n -3312 : \\\"anti_xi_m\\\",\\n 3122 : \\\"lambda\\\",\\n -3122 : \\\"anti_lambda\\\",\\n 3334 : \\\"omega\\\",\\n -3334 : \\\"anti_omega\\\",\\n 333 : \\\"phi\\\",\\n 221 : \\\"eta\\\",\\n 331 : \\\"eta_prime\\\",\\n 22 : \\\"gamma\\\",\\n }\\n\\n #particle mass Dictionary (unit in GeV)\\n self.masspidDict = {\\n \\\"pion\\\" : 0.13957,\\n \\\"pion_p\\\" : 0.13957,\\n \\\"pion_0\\\" : 0.13498,\\n \\\"pion_m\\\" : 0.13957,\\n \\\"kaon\\\" : 0.49368,\\n \\\"kaon_p\\\" : 0.49368,\\n \\\"kaon_0\\\" : 0.49765,\\n \\\"anti_kaon\\\" : 0.49368,\\n \\\"kaon_m\\\" : 0.49368,\\n \\\"anti_kaon_0\\\" : 0.49765,\\n \\\"nucleon\\\" : 0.93827,\\n \\\"proton\\\" : 0.93827,\\n \\\"neutron\\\" : 0.93957,\\n \\\"anti_nucleon\\\" : 0.93827,\\n \\\"anti_proton\\\" : 0.93827,\\n \\\"anit_neutron\\\" : 0.93957,\\n \\\"sigma\\\" : 1.18937,\\n \\\"sigma_p\\\" : 1.18937,\\n \\\"sigma_0\\\" : 1.19264,\\n \\\"sigma_m\\\" : 1.19745,\\n \\\"anti_sigma\\\" : 1.18937,\\n \\\"anti_sigma_p\\\" : 1.18937,\\n \\\"anti_sigma_0\\\" : 1.19264,\\n \\\"anti_sigma_m\\\" : 1.19745,\\n \\\"xi\\\" : 1.31483,\\n \\\"xi_0\\\" : 1.31483,\\n \\\"xi_m\\\" : 1.32131,\\n \\\"anti_xi\\\" : 1.31483,\\n \\\"anti_xi_0\\\" : 1.31483,\\n \\\"anti_xi_m\\\" : 1.32131,\\n \\\"lambda\\\" : 1.11568,\\n \\\"anti_lambda\\\" : 1.11568,\\n \\\"omega\\\" : 1.67243,\\n \\\"anti_omega\\\" : 1.67243,\\n \\\"rho\\\" : 0.77580,\\n \\\"rho_p\\\" : 0.77580,\\n \\\"rho_0\\\" : 0.77580,\\n \\\"rho_m\\\" : 0.77580,\\n \\\"phi\\\" : 1.01946,\\n \\\"eta\\\" : 0.54775,\\n \\\"eta_prime\\\" : 0.95778,\\n \\\"gamma\\\" : 0.0,\\n }\\n for aParticle in self.masspidDict.keys():\\n self.masspidDict[aParticle+\\\"_hydro\\\"] = self.masspidDict[aParticle]\\n self.masspidDict[aParticle+\\\"_thermal\\\"] = self.masspidDict[aParticle]\\n\\n # charged hadrons list\\n self.charged_hadron_list = [\\n \\\"pion_p\\\", \\\"pion_m\\\", \\\"kaon_p\\\", \\\"kaon_m\\\", \\\"proton\\\", \\\"anti_proton\\\",\\n \\\"sigma_p\\\", \\\"sigma_m\\\", \\\"anti_sigma_p\\\", \\\"anti_sigma_m\\\",\\n \\\"xi_m\\\", \\\"anti_xi_m\\\"]\",\n \"def _PIDController__calculate(self): \\n \\n\\t\\tenabled = self.m_enabled\\n\\t\\tpidInput = self.m_pidInput\\n\\n\\t\\tif enabled:\\n\\n\\t\\t input = pidInput.PIDGet()\\n\\n\\t\\t self.m_error = self.m_setpoint - input\\n\\t\\t if self.m_continuous:\\n\\t\\t \\n\\t\\t if math.fabs(self.m_error) > (self.m_maximumInput - self.m_minimumInput) / 2:\\n\\t\\t if self.m_error > 0:\\n\\t\\t self.m_error = self.m_error - self.m_maximumInput + self.m_minimumInput\\n\\t\\t else:\\n\\t\\t self.m_error = self.m_error + self.m_maximumInput - self.m_minimumInput\\n\\n\\t\\t potentialIGain = (self.m_totalError + self.m_error) * self.m_I\\n\\t\\t \\n\\t\\t if potentialIGain < self.m_maximumOutput:\\n\\t\\t if potentialIGain > self.m_minimumOutput:\\n\\t\\t self.m_totalError += self.m_error\\n\\t\\t else:\\n\\t\\t self.m_totalError = self.m_minimumOutput / self.m_I\\n\\t\\t else:\\n\\t\\t self.m_totalError = self.m_maximumOutput / self.m_I\\n\\n\\t\\t self.m_result = self.m_P * self.m_error + self.m_I * self.m_totalError + self.m_D * (self.m_error - self.m_prevError)\\n\\t\\t self.m_prevError = self.m_error\\n\\n\\t\\t if self.m_result > self.m_maximumOutput:\\n\\t\\t self.m_result = self.m_maximumOutput\\n\\t\\t elif self.m_result < self.m_minimumOutput:\\n\\t\\t self.m_result = self.m_minimumOutput\\n\\n\\t\\t pidOutput = self.m_pidOutput\\n\\t\\t result = self.m_result\",\n \"def _PIDController__calculate(self): \\n \\n\\t\\tenabled = self.m_enabled\\n\\t\\tpidInput = self.m_pidInput\\n\\t\\tpidInput2 = self.source2\\n\\n\\t\\tif enabled:\\n\\n\\t\\t input = pidInput.PIDGet() - pidInput2.PIDGet()\\n\\n\\t\\t self.m_error = self.m_setpoint - input\\n\\t\\t if self.m_continuous:\\n\\t\\t \\n\\t\\t if math.fabs(self.m_error) > (self.m_maximumInput - self.m_minimumInput) / 2:\\n\\t\\t if self.m_error > 0:\\n\\t\\t self.m_error = self.m_error - self.m_maximumInput + self.m_minimumInput\\n\\t\\t else:\\n\\t\\t self.m_error = self.m_error + self.m_maximumInput - self.m_minimumInput\\n\\n\\t\\t potentialIGain = (self.m_totalError + self.m_error) * self.m_I\\n\\t\\t \\n\\t\\t if potentialIGain < self.m_maximumOutput:\\n\\t\\t if potentialIGain > self.m_minimumOutput:\\n\\t\\t self.m_totalError += self.m_error\\n\\t\\t else:\\n\\t\\t self.m_totalError = self.m_minimumOutput / self.m_I\\n\\t\\t else:\\n\\t\\t self.m_totalError = self.m_maximumOutput / self.m_I\\n\\n\\t\\t self.m_result = self.m_P * self.m_error + self.m_I * self.m_totalError + self.m_D * (self.m_error - self.m_prevError)\\n\\t\\t self.m_prevError = self.m_error\\n\\n\\t\\t if self.m_result > self.m_maximumOutput:\\n\\t\\t self.m_result = self.m_maximumOutput\\n\\t\\t elif self.m_result < self.m_minimumOutput:\\n\\t\\t self.m_result = self.m_minimumOutput\\n\\n\\t\\t pidOutput = self.m_pidOutput\\n\\t\\t result = self.m_result\",\n \"def get_pmi_mvn(x, y, z):\\n\\n d = x.shape[1]\\n hz = 0.5 * log((2 * np.pi * np.e)**d * det(np.cov(z.T)))\\n hxz = 0.5 * log((2 * np.pi * np.e)**(2*d) * det(np.cov(x.T, y=z.T)))\\n hyz = 0.5 * log((2 * np.pi * np.e)**(2*d) * det(np.cov(y.T, y=z.T)))\\n hxyz = 0.5 * log((2 * np.pi * np.e)**(3*d) * det(np.cov(np.c_[x,y,z].T)))\\n\\n pmi = hxz + hyz - hxyz - hz\\n return pmi\",\n \"def pontos(self):\\n \\n self.sc = 1. \\n self.x = self.sc*np.array([-155., -139.4, -124., -108.5, -93., -77.5, -62., -46.5, -31., -15.5, 0, 15.5, 31., 46.5, 62., 77.5, 93., 108.5, 124., 139.5, 155.])\\n self.y = self.sc*np.array([ 9.23, 14.37, 18.98, 23.6, 23.6, 23.6, 23.6, 23.6, 23.6, 23.6, 23.6, 23.6, 23.6, 23.6, 23.6, 23.6, 23.6, 23.6, 21.55, 14.37, 3.59])\\n self.px_index = len(self.x)\\n #self.py_index = len(self.x)/2\\n\\n self.coord = np.array([self.x,self.y,np.full(len(self.x),self.z)])\\n \\n self.x = self.x[::-1]\\n self.y = -self.y[::-1] \\n self.new = np.array([self.x,self.y,np.full(len(self.x),self.z)])\\n self.coord = np.array([np.append(self.coord[0],self.new[0]),np.append(self.coord[1],self.new[1]),np.append(self.coord[2],self.new[2])])\\n self.coord = np.array([np.append(self.coord[0],self.coord[0,0]),np.append(self.coord[1],self.coord[1,0]),np.append(self.coord[2],self.coord[2,0])])\\n\\n self.coord[0] = self.coord[0] - (np.amax(self.coord[0])+np.amin(self.coord[0]))/2\\n self.coord[1] = self.coord[1] + (np.amax(self.coord[1])-np.amin(self.coord[1]))/2 \\n \\n self.coordi = np.array(self.coord)\\n \\n self.cg = np.array([0 + self.dx, self.H/2 + self.dy, self.z]) \\n self.cgi = np.array(self.cg)\\n \\n self.thi = 0. + self.dth \\n self.th = float(self.thi) \\n \\n self.coordnav(self.dx,self.dy,self.dth)\",\n \"def pidGet(self) -> float:\\n ...\",\n \"def pidGet(self) -> float:\\n ...\",\n \"def get_atomic_id_from_coord(self, x: int, y: int, z: int,\\n parent_id: np.uint64, n_tries: int=5\\n ) -> np.uint64:\\n if self.get_chunk_layer(parent_id) == 1:\\n return parent_id\\n\\n\\n x /= 2**self.cv_mip\\n y /= 2**self.cv_mip\\n\\n x = int(x)\\n y = int(y)\\n\\n checked = []\\n atomic_id = None\\n root_id = self.get_root(parent_id)\\n\\n for i_try in range(n_tries):\\n\\n # Define block size -- increase by one each try\\n x_l = x - (i_try - 1)**2\\n y_l = y - (i_try - 1)**2\\n z_l = z - (i_try - 1)**2\\n\\n x_h = x + 1 + (i_try - 1)**2\\n y_h = y + 1 + (i_try - 1)**2\\n z_h = z + 1 + (i_try - 1)**2\\n\\n if x_l < 0:\\n x_l = 0\\n\\n if y_l < 0:\\n y_l = 0\\n\\n if z_l < 0:\\n z_l = 0\\n\\n # Get atomic ids from cloudvolume\\n atomic_id_block = self.cv[x_l: x_h, y_l: y_h, z_l: z_h]\\n atomic_ids, atomic_id_count = np.unique(atomic_id_block,\\n return_counts=True)\\n\\n # sort by frequency and discard those ids that have been checked\\n # previously\\n sorted_atomic_ids = atomic_ids[np.argsort(atomic_id_count)]\\n sorted_atomic_ids = sorted_atomic_ids[~np.in1d(sorted_atomic_ids,\\n checked)]\\n\\n # For each candidate id check whether its root id corresponds to the\\n # given root id\\n for candidate_atomic_id in sorted_atomic_ids:\\n ass_root_id = self.get_root(candidate_atomic_id)\\n\\n if ass_root_id == root_id:\\n # atomic_id is not None will be our indicator that the\\n # search was successful\\n\\n atomic_id = candidate_atomic_id\\n break\\n else:\\n checked.append(candidate_atomic_id)\\n\\n if atomic_id is not None:\\n break\\n\\n # Returns None if unsuccessful\\n return atomic_id\",\n \"def get_x_y_z(drone, p, q, r):\\n num_cameras = 2\\n camera_constants = [0,math.pi/2]\\n rads = np.zeros(num_cameras)\\n phis = np.zeros(num_cameras)\\n d = np.zeros(num_cameras)\\n theta = np.zeros(num_cameras)\\n Hs = np.zeros(num_cameras)\\n s = 12\\n HFOV = math.pi/4\\n VFOV = 5*math.pi/36\\n HPIX = 1280\\n VPIX = 720\\n #loop one, where we increment over camera number, and\\n # get new information\\n\\n cent = calculate_centroid(p,q,r)\\n for camera_num in range(num_cameras):\\n\\n A,B = find_a_and_b(p[camera_num],q[camera_num],r[camera_num],cent[camera_num])\\n a = find_a(A,B)\\n d_in = find_inner_d(a, s)\\n angle_c = find_angle_c(a)\\n alpha = find_alpha(HFOV, HPIX, A)\\n w = find_w(angle_c, s)\\n d_out = find_outer_d(w,alpha,a)\\n pointy_front = is_point_front(r[camera_num],q[camera_num],p[camera_num],cent[camera_num])\\n d[camera_num] = find_d(d_in,d_out,pointy_front)\\n theta[camera_num] = find_theta(angle_c,A,B,camera_constants[camera_num])\\n k = find_k(drone[camera_num], cent[camera_num])\\n angle_k = find_angle_k(k, HFOV, HPIX)\\n phi = find_phi(theta[camera_num], angle_k)\\n rad = find_r(d[camera_num], angle_k)\\n phis[camera_num] = phi\\n rads[camera_num] = rad\\n\\n # end of first loop\\n\\n cosphis = np.cos(phis)\\n sinphis = np.sin(phis)\\n big_matrix = np.column_stack((cosphis,sinphis))\\n points = np.zeros((int(num_cameras*(num_cameras-1)/2),2))\\n i = 0\\n for pair in itertools.combinations(range(num_cameras), 2):\\n matrix_a = np.vstack((big_matrix[pair[0]],big_matrix[pair[1]]))\\n vec_b = np.hstack((rads[pair[0]],rads[pair[1]]))\\n point = np.linalg.solve(matrix_a, vec_b)\\n points[i] = point\\n i += 1\\n drone_pos = np.mean(points,axis=0)\\n\\n # start of third loop\\n for camera_num in range(num_cameras):\\n d_prime = find_d_prime(d[camera_num], theta[camera_num], drone_pos)\\n P,Q,M,N = find_P_Q_M_N(p[camera_num],q[camera_num],r[camera_num])\\n h = find_h(d[camera_num],P,Q,M,N)\\n angle_4 = find_angle_4(h,d[camera_num])\\n Y = find_Y(drone[camera_num], cent[camera_num])\\n angle_5 = find_angle_5(Y, VFOV, VPIX)\\n angle_6 = angle_5 - angle_4\\n h_prime = find_h_prime(d_prime, angle_6)\\n Hs[camera_num] = h + h_prime\\n drone_h = np.mean(H)\\n return np.append(drone_pos,drone_h)\",\n \"def get_coord(self,x,y,z):\\n a = 0\\n b = 0\\n c = 0\\n \\n distance = 0\\n \\n while (distance <= x):\\n distance += SQUARE_SIZE\\n if ( (x - distance) > - (SQUARE_SIZE / 2) ):\\n a += 1\\n distance = 0\\n \\n while (distance <= y):\\n distance += SQUARE_SIZE\\n if ( (y - distance) > - (SQUARE_SIZE / 2) ):\\n b += 1\\n distance = 0\\n \\n while (distance <= z):\\n distance += SQUARE_SIZE\\n if ( (z - distance) > - (SQUARE_SIZE / 2) ):\\n c += 1\\n distance = 0\\n \\n return(a,b,c)\",\n \"def get_parameters():\\n\\n setpoint = [0., 0., 0., 0.]\\n kp_param = [0., .0, 0., 0.]\\n ki_param = [0., 0., 0., 0.]\\n kd_param = [0, 0, 0, 0]\\n inverted = [False, False, False, False]\\n hold = [False, False, False, False]\\n int_reset = [False, False, False, False]\\n int_auto = [False, False, False, False]\\n relock_min = [0., 0., 0., 0.]\\n relock_max = [0., 0., 0., 0.]\\n relock_slew_rate = [0., 0., 0., 0.]\\n relock_enabled = [False, False, False, False]\\n relock_input = [0, 0, 0, 0]\\n for i in range(4):\\n setpoint[i] = ctypes.c_float()\\n retval = RP_LIB.rp_PIDGetSetpoint(i, ctypes.byref(setpoint[i]))\\n if retval != 0:\\n LOG.error(\\\"Failed to get PID setpoint. Error code: %s\\\", ERROR_CODES[retval])\\n\\n kp_param[i] = ctypes.c_float()\\n retval = RP_LIB.rp_PIDGetKp(i, ctypes.byref(kp_param[i]))\\n if retval != 0:\\n LOG.error(\\\"Failed to get PID Kp parameter. Error code: %s\\\", ERROR_CODES[retval])\\n\\n ki_param[i] = ctypes.c_float()\\n retval = RP_LIB.rp_PIDGetKi(i, ctypes.byref(ki_param[i]))\\n if retval != 0:\\n LOG.error(\\\"Failed to get PID Ki parameter. Error code: %s\\\", ERROR_CODES[retval])\\n\\n kd_param[i] = ctypes.c_int()\\n retval = RP_LIB.rp_PIDGetKd(i, ctypes.byref(kd_param[i]))\\n if retval != 0:\\n LOG.error(\\\"Failed to get PID Kd parameter. Error code: %s\\\", ERROR_CODES[retval])\\n\\n inverted[i] = ctypes.c_bool()\\n retval = RP_LIB.rp_PIDGetInverted(i, ctypes.byref(inverted[i]))\\n if retval != 0:\\n LOG.error(\\\"Failed to get PID feedback sign. Error code: %s\\\", ERROR_CODES[retval])\\n\\n hold[i] = ctypes.c_bool()\\n retval = RP_LIB.rp_PIDGetHold(i, ctypes.byref(hold[i]))\\n if retval != 0:\\n LOG.error(\\\"Failed to get state of PID internal holding. Error code: %s\\\",\\n ERROR_CODES[retval])\\n\\n int_reset[i] = ctypes.c_bool()\\n retval = RP_LIB.rp_PIDGetIntReset(i, ctypes.byref(int_reset[i]))\\n if retval != 0:\\n LOG.error(\\\"Failed to get state of PID integrator reset. Error code: %s\\\",\\n ERROR_CODES[retval])\\n\\n int_auto[i] = ctypes.c_bool()\\n retval = RP_LIB.rp_PIDGetResetWhenRailed(i, ctypes.byref(int_auto[i]))\\n if retval != 0:\\n LOG.error(\\\"Failed to get state of PID automatical integrator reset. Error code: %s\\\",\\n ERROR_CODES[retval])\\n\\n relock_min[i] = ctypes.c_float()\\n retval = RP_LIB.rp_PIDGetRelockMinimum(i, ctypes.byref(relock_min[i]))\\n if retval != 0:\\n LOG.error(\\\"Failed to get PID minimum relock voltage. Error code: %s\\\",\\n ERROR_CODES[retval])\\n\\n relock_max[i] = ctypes.c_float()\\n retval = RP_LIB.rp_PIDGetRelockMaximum(i, ctypes.byref(relock_max[i]))\\n if retval != 0:\\n LOG.error(\\\"Failed to get PID maximum relock voltage. Error code: %s\\\",\\n ERROR_CODES[retval])\\n\\n relock_slew_rate[i] = ctypes.c_float()\\n retval = RP_LIB.rp_PIDGetRelockStepsize(i, ctypes.byref(relock_slew_rate[i]))\\n if retval != 0:\\n LOG.error(\\\"Failed to get PID relock slew rate. Error code: %s\\\",\\n ERROR_CODES[retval])\\n\\n relock_enabled[i] = ctypes.c_bool()\\n retval = RP_LIB.rp_PIDGetRelock(i, ctypes.byref(relock_enabled[i]))\\n if retval != 0:\\n LOG.error(\\\"Failed to get state of PID relock feature. Error code: %s\\\",\\n ERROR_CODES[retval])\\n\\n relock_input[i] = ctypes.c_int()\\n retval = RP_LIB.rp_PIDGetRelockInput(i, ctypes.byref(relock_input[i]))\\n if retval != 0:\\n LOG.error(\\\"Failed to get analog input of PID relock. Error code: %s\\\",\\n ERROR_CODES[retval])\\n\\n limit_min_1 = ctypes.c_float()\\n retval = RP_LIB.rp_LimitGetMin(0, ctypes.byref(limit_min_1))\\n if retval != 0:\\n LOG.error(\\\"Failed to get minimum output limit. Error code: %s\\\", ERROR_CODES[retval])\\n limit_min_2 = ctypes.c_float()\\n retval = RP_LIB.rp_LimitGetMin(1, ctypes.byref(limit_min_2))\\n if retval != 0:\\n LOG.error(\\\"Failed to get minimum output limit. Error code: %s\\\", ERROR_CODES[retval])\\n\\n limit_max_1 = ctypes.c_float()\\n retval = RP_LIB.rp_LimitGetMax(0, ctypes.byref(limit_max_1))\\n if retval != 0:\\n LOG.error(\\\"Failed to get maximum output limit. Error code: %s\\\", ERROR_CODES[retval])\\n limit_max_2 = ctypes.c_float()\\n retval = RP_LIB.rp_LimitGetMax(1, ctypes.byref(limit_max_2))\\n if retval != 0:\\n LOG.error(\\\"Failed to get maximum output limit. Error code: %s\\\", ERROR_CODES[retval])\\n\\n sg_1_amp = ctypes.c_float()\\n retval = RP_LIB.rp_GenGetAmp(0, ctypes.byref(sg_1_amp))\\n if retval != 0:\\n LOG.error(\\\"Failed to get signal generator amplitude. Error code: %s\\\", ERROR_CODES[retval])\\n sg_2_amp = ctypes.c_float()\\n retval = RP_LIB.rp_GenGetAmp(1, ctypes.byref(sg_2_amp))\\n if retval != 0:\\n LOG.error(\\\"Failed to get signal generator amplitude. Error code: %s\\\", ERROR_CODES[retval])\\n\\n sg_1_freq = ctypes.c_float()\\n retval = RP_LIB.rp_GenGetFreq(0, ctypes.byref(sg_1_freq))\\n if retval != 0:\\n LOG.error(\\\"Failed to get signal generator frequency. Error code: %s\\\", ERROR_CODES[retval])\\n sg_2_freq = ctypes.c_float()\\n retval = RP_LIB.rp_GenGetFreq(1, ctypes.byref(sg_2_freq))\\n if retval != 0:\\n LOG.error(\\\"Failed to get signal generator frequency. Error code: %s\\\", ERROR_CODES[retval])\\n\\n sg_1_offset = ctypes.c_float()\\n retval = RP_LIB.rp_GenGetOffset(0, ctypes.byref(sg_1_offset))\\n if retval != 0:\\n LOG.error(\\\"Failed to get signal generator offset. Error code: %s\\\", ERROR_CODES[retval])\\n sg_2_offset = ctypes.c_float()\\n retval = RP_LIB.rp_GenGetOffset(1, ctypes.byref(sg_2_offset))\\n if retval != 0:\\n LOG.error(\\\"Failed to get signal generator offset. Error code: %s\\\", ERROR_CODES[retval])\\n\\n sg_1_waveform = ctypes.c_int()\\n retval = RP_LIB.rp_GenGetWaveform(0, ctypes.byref(sg_1_waveform))\\n if retval != 0:\\n LOG.error(\\\"Failed to get the waveform of the signal generator. Error code: %s\\\",\\n ERROR_CODES[retval])\\n sg_2_waveform = ctypes.c_int()\\n retval = RP_LIB.rp_GenGetWaveform(1, ctypes.byref(sg_2_waveform))\\n if retval != 0:\\n LOG.error(\\\"Failed to get the waveform of the signal generator. Error code: %s\\\",\\n ERROR_CODES[retval])\\n\\n sg_1_enabled = ctypes.c_bool()\\n retval = RP_LIB.rp_GenOutIsEnabled(0, ctypes.byref(sg_1_enabled))\\n if retval != 0:\\n LOG.error(\\\"Failed to get if signal generator is enabled. Error code: %s\\\",\\n ERROR_CODES[retval])\\n sg_2_enabled = ctypes.c_bool()\\n retval = RP_LIB.rp_GenOutIsEnabled(1, ctypes.byref(sg_2_enabled))\\n if retval != 0:\\n LOG.error(\\\"Failed to get if signal generator is enabled. Error code: %s\\\",\\n ERROR_CODES[retval])\\n\\n parameters = {\\n \\\"pid_11_setpoint\\\": setpoint[0].value,\\n \\\"pid_12_setpoint\\\": setpoint[1].value,\\n \\\"pid_21_setpoint\\\": setpoint[2].value,\\n \\\"pid_22_setpoint\\\": setpoint[3].value,\\n \\\"pid_11_kp\\\": kp_param[0].value,\\n \\\"pid_12_kp\\\": kp_param[1].value,\\n \\\"pid_21_kp\\\": kp_param[2].value,\\n \\\"pid_22_kp\\\": kp_param[3].value,\\n \\\"pid_11_ki\\\": ki_param[0].value,\\n \\\"pid_12_ki\\\": ki_param[1].value,\\n \\\"pid_21_ki\\\": ki_param[2].value,\\n \\\"pid_22_ki\\\": ki_param[3].value,\\n \\\"pid_11_kd\\\": kd_param[0].value,\\n \\\"pid_12_kd\\\": kd_param[1].value,\\n \\\"pid_21_kd\\\": kd_param[2].value,\\n \\\"pid_22_kd\\\": kd_param[3].value,\\n \\\"pid_11_inverted\\\": inverted[0].value,\\n \\\"pid_12_inverted\\\": inverted[1].value,\\n \\\"pid_21_inverted\\\": inverted[2].value,\\n \\\"pid_22_inverted\\\": inverted[3].value,\\n \\\"pid_11_hold\\\": hold[0].value,\\n \\\"pid_12_hold\\\": hold[1].value,\\n \\\"pid_21_hold\\\": hold[2].value,\\n \\\"pid_22_hold\\\": hold[3].value,\\n \\\"pid_11_int_res\\\": int_reset[0].value,\\n \\\"pid_12_int_res\\\": int_reset[1].value,\\n \\\"pid_21_int_res\\\": int_reset[2].value,\\n \\\"pid_22_int_res\\\": int_reset[3].value,\\n \\\"pid_11_int_auto_reset\\\": int_auto[0].value,\\n \\\"pid_12_int_auto_reset\\\": int_auto[1].value,\\n \\\"pid_21_int_auto_reset\\\": int_auto[2].value,\\n \\\"pid_22_int_auto_reset\\\": int_auto[3].value,\\n \\\"pid_11_relock_min\\\": relock_min[0].value,\\n \\\"pid_12_relock_min\\\": relock_min[1].value,\\n \\\"pid_21_relock_min\\\": relock_min[2].value,\\n \\\"pid_22_relock_min\\\": relock_min[3].value,\\n \\\"pid_11_relock_max\\\": relock_max[0].value,\\n \\\"pid_12_relock_max\\\": relock_max[1].value,\\n \\\"pid_21_relock_max\\\": relock_max[2].value,\\n \\\"pid_22_relock_max\\\": relock_max[3].value,\\n \\\"pid_11_relock_slew_rate\\\": relock_slew_rate[0].value,\\n \\\"pid_12_relock_slew_rate\\\": relock_slew_rate[1].value,\\n \\\"pid_21_relock_slew_rate\\\": relock_slew_rate[2].value,\\n \\\"pid_22_relock_slew_rate\\\": relock_slew_rate[3].value,\\n \\\"pid_11_relock_enabled\\\": relock_enabled[0].value,\\n \\\"pid_12_relock_enabled\\\": relock_enabled[1].value,\\n \\\"pid_21_relock_enabled\\\": relock_enabled[2].value,\\n \\\"pid_22_relock_enabled\\\": relock_enabled[3].value,\\n \\\"pid_11_relock_input\\\": relock_input[0].value,\\n \\\"pid_12_relock_input\\\": relock_input[1].value,\\n \\\"pid_21_relock_input\\\": relock_input[2].value,\\n \\\"pid_22_relock_input\\\": relock_input[3].value,\\n \\\"limit_min_1\\\": limit_min_1.value,\\n \\\"limit_min_2\\\": limit_min_2.value,\\n \\\"limit_max_1\\\": limit_max_1.value,\\n \\\"limit_max_2\\\": limit_max_2.value,\\n \\\"sg_1_waveform\\\": sg_1_waveform.value,\\n \\\"sg_2_waveform\\\": sg_2_waveform.value,\\n \\\"sg_1_enabled\\\": sg_1_enabled.value,\\n \\\"sg_2_enabled\\\": sg_2_enabled.value,\\n \\\"sg_1_amp\\\": sg_1_amp.value,\\n \\\"sg_2_amp\\\": sg_2_amp.value,\\n \\\"sg_1_freq\\\": sg_1_freq.value,\\n \\\"sg_2_freq\\\": sg_2_freq.value,\\n \\\"sg_1_offset\\\": sg_1_offset.value,\\n \\\"sg_2_offset\\\": sg_2_offset.value\\n }\\n return json.dumps(parameters)\",\n \"def calculate_potential_3D_parallel(true_csd, ele_xx, ele_yy, ele_zz, \\n csd_x, csd_y, csd_z):\\n\\n xlin = csd_x[:,0,0]\\n ylin = csd_y[0,:,0]\\n zlin = csd_z[0,0,:]\\n xlims = [xlin[0], xlin[-1]]\\n ylims = [ylin[0], ylin[-1]]\\n zlims = [zlin[0], zlin[-1]]\\n sigma = 1.0\\n #tic = time.time()\\n pots = Parallel(n_jobs=num_cores)(delayed(integrate_3D)(ele_xx[ii],ele_yy[ii],ele_zz[ii],\\n xlims, ylims, zlims, true_csd,\\n xlin, ylin, zlin,\\n csd_x, csd_y, csd_z) for ii in range(len(ele_xx)))\\n pots = np.array(pots)\\n pots /= 4*np.pi*sigma\\n #toc = time.time() - tic\\n #print toc, 'Total time taken - parallel, sims '\\n return pots\",\n \"def get_pid(self):\\n return self.k_p, self.k_i, self.k_d\",\n \"def _update_PID(self):\\n self.pid = PID(p=self.paramP, i=self.paramI, d=self.paramD, setpoint=self.voltageSetpoint, memory=self.paramMemory)\",\n \"def test_pointnum3():\\n shape = paramak.CapsuleVacuumVessel(outer_start_point=(1000, -500), radius=5000, thickness=50)\\n assert len(shape.points) == 12\\n assert len(shape.processed_points) == 13\",\n \"def cartesian_distance(x,y,z):\\n\\treturn math.sqrt(x**2 + y**2 + z**2)\",\n \"def optimise_z(z, *args):\\n x, y, elements, coordinates = args\\n window_com = np.array([x, y, z])\\n return pore_diameter(elements, coordinates, com=window_com)[0]\",\n \"def _evaluate_xyz(self,x,y,z=0.):\\n return -np.pi * self._rhoc_M /(self.n+1.)*self.a**3*self._b*self._c * \\\\\\n _potInt(x, y, z, self._a2, self._b2*self._a2, self._c2*self._a2, self.n)\",\n \"def calculatePosition(P1, P2, P3, DistA, DistB, DistC):\\n #SEE wikipedia for why trilateralization : https://en.wikipedia.org/wiki/Trilateration\\n ex = (P2 - P1)/(numpy.linalg.norm(P2 - P1))\\n i = np.dot(ex, P3 - P1)\\n ey = (P3 - P1 - i * ex)/(numpy.linalg.norm(P3 - P1 - i * ex))\\n ez = numpy.cross(ex,ey)\\n d = numpy.linalg.norm(P2 - P1)\\n j = np.dot(ey, P3 - P1)\\n \\n x = (pow(DistA,2) - pow(DistB,2) + pow(d,2))/(2 * d)\\n y = ((pow(DistA,2) - pow(DistC,2) + pow(i,2) + pow(j,2))/(2 * j)) - ((i/j)*x)\\n\\n z = cmath.sqrt(pow(DistA,2) - pow(x,2) - pow(y,2))\\n\\n if z.imag != 0.0:\\n return [None, None, None]\\n else:\\n return np.real(P1 + x*ex + y*ey + z*ez)\",\n \"def photons(self, depth=1):\\n self.dx[:,:self.W-1] = self.z[:,1:] - self.z[:,:self.W-1]\\n self.dy[:self.H-1,:] = self.z[1:,:] - self.z[:self.H-1,:]\\n px = self.xv - self.dx*depth\\n py = self.yv - self.dy*depth\\n return px,py\",\n \"def ci(x, y, z):\\n\\n return (x * 16 + z) * CHUNK_HEIGHT + y\",\n \"def calc_positions(zpoints, dsq_list):\\n\\n pos_map = {}\\n points_map = {}\\n\\n for z, p in zpoints.items():\\n if z in dsq_list:\\n p = -1\\n if p not in points_map:\\n points_map[p] = set()\\n points_map[p].add(z)\\n\\n i = 1\\n for p in sorted(list(points_map.keys()), reverse = True):\\n pos_map[i] = points_map[p]\\n i += len(points_map[p])\\n\\n return pos_map\",\n \"def __init__(self,E,px,py,pz):\\n Particle.__init__(self)\\n self.E=float(E)\\n self.px=float(px)\\n self.py=float(py)\\n self.pz=float(pz)\\n self.cal_pt()\\n self.cal_phi()\\n self.cal_eta()\\n #self.cal_mass()\\n #print self.E,self.px,self.py,self.pz\\n #print self.pt,self.phi,self.eta\",\n \"def immoment3D(X, Y, Z, p, q, r):\\n assert len(X) == len(Y)\\n assert len(Y) == len(Z)\\n return (X ** p * Y ** q * Z ** r).sum()\",\n \"def ion1_position(self,x,y,z):\\n axes_vector = np.array([self.a,self.b,self.c])\\n self.ion1 = x*self.a + y*self.b + z*self.c\\n self.position['1A'] = np.dot(self.position_map[1],axes_vector) + self.ion1\\n self.position['2A'] = np.dot(self.position_map[2],axes_vector) + self.ion1\\n self.position['3A'] = np.dot(self.position_map[3],axes_vector) + self.ion1\\n self.position['4A'] = np.dot(self.position_map[4],axes_vector) + self.ion1\\n self.position['5A'] = np.dot(self.position_map[5],axes_vector) + self.ion1\\n self.position['6A'] = np.dot(self.position_map[6],axes_vector) + self.ion1\\n self.position['7A'] = np.dot(self.position_map[7],axes_vector) + self.ion1\\n self.position['8A'] = np.dot(self.position_map[8],axes_vector) + self.ion1\",\n \"def ion1_position(self,x,y,z):\\n axes_vector = np.array([self.a,self.b,self.c])\\n self.ion1 = x*self.a + y*self.b + z*self.c\\n self.position['1A'] = np.dot(self.position_map[1],axes_vector) + self.ion1\\n self.position['2A'] = np.dot(self.position_map[2],axes_vector) + self.ion1\\n self.position['3A'] = np.dot(self.position_map[3],axes_vector) + self.ion1\\n self.position['4A'] = np.dot(self.position_map[4],axes_vector) + self.ion1\\n self.position['5A'] = np.dot(self.position_map[5],axes_vector) + self.ion1\\n self.position['6A'] = np.dot(self.position_map[6],axes_vector) + self.ion1\\n self.position['7A'] = np.dot(self.position_map[7],axes_vector) + self.ion1\\n self.position['8A'] = np.dot(self.position_map[8],axes_vector) + self.ion1\",\n \"def calculate_percid(\\n pos_total, length_query, length_subject, length_total, option_pid=\\\"mean\\\"\\n):\\n if option_pid == \\\"mean\\\":\\n pid = pos_total / ((length_query + length_subject) / 2.0)\\n elif option_pid == \\\"subject\\\":\\n pid = pos_total / length_subject\\n elif option_pid == \\\"query\\\":\\n pid = pos_total / length_query\\n elif option_pid == \\\"shortest\\\":\\n pid = pos_total / min(length_query, length_subject)\\n elif option_pid == \\\"longest\\\":\\n pid = pos_total / max(length_query, length_subject)\\n elif option_pid == \\\"HSP\\\":\\n pid = pos_total / length_total\\n\\n return pid\",\n \"def set_position(self, x, y, z):\\n for sec in self.all:\\n for i in range(int(nrn.n3d())):\\n nrn.pt3dchange(i, \\\\\\n x-self.x+nrn.x3d(i), \\\\\\n y-self.y+nrn.y3d(i), \\\\\\n z-self.z+nrn.z3d(i), \\\\\\n nrn.diam3d(i))\\n self.x = x; self.y = y; self.z = z\",\n \"def kinect_transform(self, x, y, z):\\n xposition = x\\n yposition = y\\n zposition = z\\n\\n return zposition, xposition, yposition\",\n \"def PIDdata(time,temperature,setp):\\n from scipy import polyfit\\n from matplotlib.pyplot import figure,subplot,plot,xlabel,ylabel,title\\n\\n l=len(temperature)\\n Pdat = zeros(l)\\n Idat = zeros(l)\\n Ddat = zeros(l)\\n\\n Pdat[0] = setp-temperature[0]\\n for i in range(1,l):\\n epsilon = setp - temperature[i]\\n Pdat[i] = epsilon\\n Idat[i] = Idat[i-1] + epsilon\\n\\n for i in range(2,l-2):\\n j=range(i-2,i+3)\\n (a,b)=polyfit(time[j],temperature[j],1)\\n Ddat[i] = a\\n\\n figure()\\n subplot(411)\\n plot(time,temperature)\\n ylabel(r'Temperature $ \\\\left( ^{\\\\circ} C \\\\right) $')\\n subplot(412)\\n plot(time,Pdat)\\n ylabel(r'$ \\\\epsilon = T_{set}-T_{meas} \\\\left( ^{\\\\circ}C \\\\right) $')\\n subplot(413)\\n plot(time,Idat)\\n ylabel(r'$ \\\\int_0^t \\\\epsilon dt $')\\n subplot(414)\\n plot(time,Ddat)\\n xlabel('Time (s)')\\n ylabel(r' $ \\\\frac{d \\\\epsilon}{dt} $')\\n\\n return Pdat,Idat,Ddat\",\n \"def test_variables(x, y, z):\\n a = x * y\\n b = y * a\\n c = a + b\\n return c / z\",\n \"def findpc(self):\\n u = -(-can.C.len() + self.P.len() + can.R)/self.V.len()\\n if u >= 0:\\n return self.P + self.V.scale(u), u\\n else:\\n u = (can.C.len() - self.P.len() + can.R)/self.V.len()\\n return self.P + self.V.scale(u), u\",\n \"def get_pmi(x, y, z, k=1, normalize=None, norm=np.inf, estimator='fp'):\\n\\n if normalize:\\n x = normalize(x)\\n y = normalize(y)\\n z = normalize(z)\\n\\n # construct state array for the joint processes:\\n xz = np.c_[x,z]\\n yz = np.c_[y,z]\\n xyz = np.c_[x,y,z]\\n\\n if estimator == 'naive':\\n # compute individual entropies\\n # TODO: pass in min_dist\\n hz = get_h(z, k=k, norm=norm)\\n hxz = get_h(xz, k=k, norm=norm)\\n hyz = get_h(yz, k=k, norm=norm)\\n hxyz = get_h(xyz, k=k, norm=norm)\\n\\n pmi = hxz + hyz - hxyz - hz\\n\\n elif estimator == 'fp':\\n\\n # construct k-d trees\\n z_tree = cKDTree(z)\\n xz_tree = cKDTree(xz)\\n yz_tree = cKDTree(yz)\\n xyz_tree = cKDTree(xyz)\\n\\n # kth nearest neighbour distances for every state\\n # query with k=k+1 to return the nearest neighbour, not the data point itself\\n # dist, idx = xyz_tree.query(xyz, k=k+1, p=norm)\\n dist, idx = xyz_tree.query(xyz, k=k+1, p=np.inf)\\n epsilon = dist[:, -1]\\n\\n # for each point, count the number of neighbours\\n # whose distance in the relevant subspace is strictly < epsilon\\n n = len(x)\\n nxz = np.empty(n, dtype=np.int)\\n nyz = np.empty(n, dtype=np.int)\\n nz = np.empty(n, dtype=np.int)\\n\\n for ii in range(n):\\n # nz[ii] = len( z_tree.query_ball_point( z_tree.data[ii], r=epsilon[ii], p=norm)) - 1\\n # nxz[ii] = len(xz_tree.query_ball_point(xz_tree.data[ii], r=epsilon[ii], p=norm)) - 1\\n # nyz[ii] = len(yz_tree.query_ball_point(yz_tree.data[ii], r=epsilon[ii], p=norm)) - 1\\n nz[ii] = len( z_tree.query_ball_point( z_tree.data[ii], r=epsilon[ii], p=np.inf)) - 1\\n nxz[ii] = len(xz_tree.query_ball_point(xz_tree.data[ii], r=epsilon[ii], p=np.inf)) - 1\\n nyz[ii] = len(yz_tree.query_ball_point(yz_tree.data[ii], r=epsilon[ii], p=np.inf)) - 1\\n\\n pmi = digamma(k) + np.mean(digamma(nz +1) -digamma(nxz +1) -digamma(nyz +1))\\n\\n elif estimator == 'ps':\\n # (I am fairly sure that) this is the correct implementation of the estimator,\\n # but the estimators is just crap.\\n\\n # construct k-d trees\\n xz_tree = cKDTree(xz, leafsize=2*k)\\n yz_tree = cKDTree(yz, leafsize=2*k)\\n\\n # determine k-nn distances\\n n = len(x)\\n rxz = np.empty(n, dtype=np.int)\\n ryz = np.empty(n, dtype=np.int)\\n\\n # rxz, dummy = xz_tree.query(xz, k=k+1, p=norm) # +1 to account for distance to itself\\n # ryz, dummy = yz_tree.query(xz, k=k+1, p=norm) # +1 to account for distance to itself; xz NOT a typo\\n rxz, dummy = xz_tree.query(xz, k=k+1, p=np.inf) # +1 to account for distance to itself\\n ryz, dummy = yz_tree.query(xz, k=k+1, p=np.inf) # +1 to account for distance to itself; xz NOT a typo\\n\\n pmi = yz.shape[1] * np.mean(log(ryz[:,-1]) - log(rxz[:,-1])) # + log(n) -log(n-1) -1.\\n\\n else:\\n raise NotImplementedError(\\\"Estimator one of 'naive', 'fp', 'ps'; currently: {}\\\".format(estimator))\\n\\n return pmi\",\n \"def nParticle(*args, attribute: Union[AnyStr, bool]=\\\"\\\", cache: bool=True, conserve: Union[float,\\n bool]=0.0, count: bool=True, deleteCache: bool=True, dynamicAttrList: bool=True,\\n floatValue: float=0.0, gridSpacing: Union[float, List[float], bool]=0.0, inherit:\\n Union[float, bool]=0.0, jitterBasePoint: Union[List[float, float, float],\\n List[List[float, float, float]], bool]=None, jitterRadius: Union[float,\\n List[float], bool]=0.0, lowerLeft: Union[List[float, float, float],\\n List[List[float, float, float]], bool]=None, name: Union[AnyStr, bool]=\\\"\\\",\\n numJitters: Union[int, List[int], bool]=0, order: Union[int, bool]=0, particleId:\\n Union[int, bool]=0, perParticleDouble: bool=True, perParticleVector: bool=True,\\n position: Union[List[float, float, float], List[List[float, float, float]]]=None,\\n shapeName: Union[AnyStr, bool]=\\\"\\\", upperRight: Union[List[float, float, float],\\n List[List[float, float, float]], bool]=None, vectorValue: List[float, float,\\n float]=None, q=True, query=True, e=True, edit=True, **kwargs)->Union[AnyStr,\\n Any]:\\n pass\",\n \"def test_pid_ccs2():\\n d = trivariates['anddup']\\n pid = PID_CCS(d, [[0], [1], [2]], [3])\\n for atom in pid._lattice:\\n if atom == ((0,), (1,), (2,)):\\n assert pid[atom] == pytest.approx(0.10375937481971094)\\n elif atom in [((0,), (2,)), ((1,),)]:\\n assert pid[atom] == pytest.approx(0.20751874963942191)\\n elif atom in [((2,), (0, 1)), ((0,), (1, 2)), ((0, 1), (0, 2)), ((0, 1), (1, 2)), ((0, 2), (1, 2)), ((0, 1, 2),)]:\\n assert pid[atom] == pytest.approx(0.14624062518028902)\\n elif atom in [((2,),), ((0,),), ((0, 1), (0, 2), (1, 2)), ((0, 2),)]:\\n assert pid[atom] == pytest.approx(-0.14624062518028902)\\n else:\\n assert pid[atom] == pytest.approx(0.0)\",\n \"def placeParticle(self, x, y, z, count):\\n self._sim.placeNumber(self, x, y, z, count)\\n return self\",\n \"def pid(self, drive, p=None, i=None, d=None):\\n if p is None:\\n # get proportional band\\n self.__ser__.write(\\\"RP{}\\\\r\\\".format(drive).encode())\\n self.__ser__.flush()\\n p = str2float(self.__ser__.read_until('\\\\r'))\\n else:\\n # set proportional band\\n self.__ser__.write(\\\"SP{} {}\\\\r\\\".format(drive, p).encode())\\n self.__ser__.flush()\\n p = self.rcvd_ok()\\n if i is None:\\n # get integral band\\n self.__ser__.write(\\\"RI{}\\\\r\\\".format(drive).encode())\\n self.__ser__.flush()\\n i = str2float(self.__ser__.read_until('\\\\r'))\\n else:\\n # set integral band\\n self.__ser__.write(\\\"SI{} {}\\\\r\\\".format(drive, i).encode())\\n self.__ser__.flush()\\n i = self.rcvd_ok()\\n if d is None:\\n # get derivative band\\n self.__ser__.write(\\\"RD{}\\\\r\\\".format(drive).encode())\\n self.__ser__.flush()\\n d = str2float(self.__ser__.read_until('\\\\r'))\\n else:\\n # set derivative band\\n self.__ser__.write(\\\"SD{} {}\\\\r\\\".format(drive, d).encode())\\n self.__ser__.flush()\\n d = self.rcvd_ok()\\n return((p, i, d))\",\n \"def define_particle(self,line):\\n\\n pattern=re.compile(r'''^\\\\s*\\n (?P<pid>-?\\\\d+)\\\\s+ #PID\\n (?P<status>1)\\\\s+ #status (1 for output particle)\\n (?P<mother>-?\\\\d+)\\\\s+ #mother\\n (?P<dum3>-?\\\\d+)\\\\s+ #mother\\n (?P<color1>[+-e.\\\\d]*)\\\\s+ #color1\\n (?P<color2>[+-e.\\\\d]*)\\\\s+ #color2\\n (?P<px>[+-e.\\\\d]*)\\\\s+ #px\\n (?P<py>[+-e.\\\\d]*)\\\\s+ #py\\n (?P<pz>[+-e.\\\\d]*)\\\\s+ #pz\\n (?P<E>[+-e.\\\\d]*)\\\\s+ #E\\n (?P<mass>[+-e.\\\\d]*)\\\\s+ #mass\\n (?P<dum1>[+-e.\\\\d]*)\\\\s+ #dummy1\\n (?P<dum2>[+-e.\\\\d]*)\\\\s* #dummy2\\n $ #end of string\\n ''',66) #verbose+ignore case\\n if pattern.search(line):\\n obj=pattern.search(line)\\n E=obj.group('E')\\n px=obj.group('px')\\n py=obj.group('py')\\n pz=obj.group('pz')\\n particle=part_quadvec(E,px,py,pz)\\n particle.def_mass(obj.group('mass'))\\n particle.def_pid(obj.group('pid'))\\n return particle\\n else:\\n return 0\",\n \"def _get_data_on_3d_points(self, varname, record, points):\\n if self.get_mesh_dimension() != 3:\\n raise TelemacException(\\\"Action possible only on 3d mesh\\\")\\n\\n res = float('nan')*np.ones((len(points)), dtype=np.float64)\\n for i, point in enumerate(points):\\n elev = self.get_data_on_vertical_segment(\\\\\\n 'ELEVATION Z', record, point[:-1])\\n values = self.get_data_on_vertical_segment(\\\\\\n varname, record, point[:-1])\\n for plan in range(self.nplan-1):\\n if elev[plan] <= point[-1] and point[-1] <= elev[plan+1]:\\n shz = (point[-1]-elev[plan])/max((elev[plan+1]\\\\\\n -elev[plan]), 1.e-6)\\n res[i] = (1.0-shz)*values[plan]+shz*values[plan+1]\\n return res\",\n \"def calc_msd(pos_x, pos_y, pos_z):\\n particles = pos_x.shape[0]\\n N = pos_x.shape[1] \\n tamsd = np.zeros(shape = (particles, N - 1)) \\n\\n for p in np.arange(start = 0, stop = particles, step = 1): \\n for n in np.arange(start = 1, stop = N, step = 1): \\n sumdis = np.array([((pos_x[p, i + n] - pos_x[p, i]) ** 2 + (pos_y[p, i + n] - pos_y[p, i]) ** 2 + (pos_z[p, i + n] - pos_z[p, i]) ** 2) for i in np.arange(start = 1, stop = N - n, step = 1)]).sum()\\n tamsd[p, n] = sumdis / (N - n) \\n return tamsd\",\n \"def index ( self, x, y, z ):\\n if x < self.x_min or x > self.x_max:\\n raise ValueError(\\\"x-value out of range %f (%f, %f)\\\" % \\\\\\n (x,self.x_min,self.x_max))\\n if y < self.y_min or y > self.y_max:\\n raise ValueError(\\\"y-value out of range %f (%f, %f)\\\" % \\\\\\n (y,self.y_min,self.y_max))\\n if z < self.z_min or z > self.z_max:\\n raise ValueError(\\\"z-value out of range %f (%f, %f)\\\" % \\\\\\n (z,self.z_min,self.z_max))\\n xi = int(round((x-self.x_min)/self.increment3D[0]))\\n yi = int(round((y-self.y_min)/self.increment3D[1]))\\n zi = int(round((z-self.z_min)/self.increment3D[2]))\\n return xi, yi, zi\",\n \"def prob4(d = 500): \\n #import the plane data\\n planeData = np.load(\\\"plane.npy\\\")\\n \\n tplane = planeData[:,0]\\n alpha = np.deg2rad(planeData[:,1])\\n beta = np.deg2rad(planeData[:,2])\\n \\n l = len(tplane)\\n \\n #define x and y functions\\n def x(n):\\n# Gives x position\\n return d * np.tan(beta[n]) / (np.tan(beta[n]) - np.tan(alpha[n]))\\n def y(n):\\n# Gives y position\\n return d * np.tan(beta[n]) * np.tan(alpha[n]) / (np.tan(beta[n]) - np.tan(alpha[n]))\\n \\n #define x and y prime as we will see them\\n def xprime(n):\\n# Gives the approximate derivative of x\\n if n == 0:\\n return fdq1(x, n, h = 1)\\n elif n == l-1:\\n return bdq1(x, n, h = 1)\\n elif n > 0 and n < l:\\n return cdq2(x, n, h = 1)\\n else:\\n return 0\\n \\n def yprime(n):\\n# Gives the approximate derivative of y\\n if n == 0:\\n return fdq1(y, n, h = 1)\\n elif n == l-1:\\n return bdq1(y, n, h = 1)\\n elif n > 0 and n < l:\\n return cdq2(y, n, h = 1)\\n else:\\n return 0\\n \\n #define speed from x and y prime\\n def speed(n):\\n# print(\\\"speed(n) where n = \\\" + str(n))\\n return np.sqrt((xprime(n))**2 + (yprime(n))**2)\\n \\n #Finally get the speed from the information we have\\n spd = []\\n X = []\\n Y = []\\n for i in range(0, l):\\n spd.append(speed(i))\\n X.append(x(i))\\n Y.append(y(i))\\n \\n return spd\\n \\n raise NotImplementedError(\\\"Problem 4 Incomplete\\\")\",\n \"def get_distance(self, x, y, z):\\n\\n up = [abs((p % self.unitcell) - self.unitcell/2) for p in (x,y,z)]\\n dmin = 9999999.\\n for l in self.types[self.type]:\\n sp = [self.pointlist[l[0]][i] * self.unitcell for i in range(3)]\\n ep = [self.pointlist[l[1]][i] * self.unitcell for i in range(3)]\\n v = [ep[i]-sp[i] for i in range(3)]\\n d = [up[i]-sp[i] for i in range(3)]\\n # dot products\\n c2 = sum([i*j for (i, j) in zip(v, v)])\\n c1 = sum([i*j for (i, j) in zip(d, v)])\\n\\n b = c1/c2\\n p = [sp[i] + b * v[i] for i in range(3)]\\n dmin = min(dmin, sum([(up[i]-p[i])**2 for i in range(3)]))\\n return math.sqrt(dmin) - self.thickness/2.0\",\n \"def nxz(PAxz,PBxz,Npulse,P_times_Dj):\\n return PAxz*PBxz*Npulse*P_times_Dj\",\n \"def test_pid_ccs1():\\n d = bivariates['gband']\\n pid = PID_CCS(d, ((0,), (1,)), (2,))\\n assert pid[((0,), (1,))] == pytest.approx(0.81127812445913283)\\n assert pid[((0,),)] == pytest.approx(0.5)\\n assert pid[((1,),)] == pytest.approx(0.5)\\n assert pid[((0, 1),)] == pytest.approx(0.0)\",\n \"def kp(self, x: float, y: float, z: float) -> int:\\n result = self._read_inline(f\\\"kp({x},{y},{z})\\\")\\n # todo: raise exception, if result == 0 (no node found)\\n return int(result)\",\n \"def point_count(N, S):\\n\\n x, y = make_grid(N)\\n\\n xc, yc = np.zeros_like(x), np.zeros_like(y)\\n # grids for holding result of mandelbrot check\\n \\n z_binary = np.zeros( (N, N) )\\n z_density = np.zeros( (N, N) )\\n\\n for (xi, i) in zip(x, xrange(N)):\\n for (yi, j) in zip(y, xrange(N)):\\n\\n z = 0 ; s = 0\\n c = complex( xi , yi ) \\n abs_z = np.sqrt( z*z.conjugate() )\\n # initial values for z, c, |z|, and step count\\n\\n for k in xrange(S):\\n\\n if abs_z > 2:\\n break\\n else:\\n z_prim = z*z + c\\n abs_z = np.sqrt( z_prim*z_prim.conjugate() )\\n z = z_prim \\n s += 1\\n z_density[j, i] += 1\\n \\n\\n\\n if abs_z < 2:\\n z_binary[j, i] = 1\\n \\n return z_binary, z_density\",\n \"def __init__(self,\\n p_xi: float, p_yi: float, p_zi: float,\\n p_xx: float, p_yx: float, p_zx: float,\\n p_xy: float, p_yy: float, p_zy: float,\\n p_xz: float, p_yz: float, p_zz: float,\\n p_ix: float, p_iy: float, p_iz: float) -> None:\\n self._p_xi = value.validate_probability(p_xi, 'p_xi')\\n self._p_yi = value.validate_probability(p_yi, 'p_yi')\\n self._p_zi = value.validate_probability(p_zi, 'p_zi')\\n self._p_xx = value.validate_probability(p_xx, 'p_xx')\\n self._p_yx = value.validate_probability(p_yx, 'p_yx')\\n self._p_zx = value.validate_probability(p_zx, 'p_zx')\\n self._p_xy = value.validate_probability(p_xy, 'p_xy')\\n self._p_yy = value.validate_probability(p_yy, 'p_yy')\\n self._p_zy = value.validate_probability(p_zy, 'p_zy')\\n self._p_xz = value.validate_probability(p_xz, 'p_xz')\\n self._p_yz = value.validate_probability(p_yz, 'p_yz')\\n self._p_zz = value.validate_probability(p_zz, 'p_zz')\\n self._p_ix = value.validate_probability(p_ix, 'p_ix')\\n self._p_iy = value.validate_probability(p_iy, 'p_iy')\\n self._p_iz = value.validate_probability(p_iz, 'p_iz')\\n self._p_ii = 1 - value.validate_probability(p_xi + p_yi + p_zi +\\n p_xx + p_yx + p_zx +\\n p_xy + p_yy + p_zy +\\n p_xz + p_yz + p_zz +\\n p_ix + p_iy + p_iz, 'p_ii')\",\n \"def FindDistributedPoints(self, p_int, , vtkIdList, p_int_1):\\n ...\",\n \"def test(self, x, y, z):\\n return self.a*x + self.b*y + self.c*z + self.d\",\n \"def centerOfMass(data):\\r\\n dd = []\\r\\n for d in data:\\r\\n dd.append(d.coordinate)\\r\\n\\r\\n data = dd\\r\\n data = np.array(data)\\r\\n n = len(data)\\r\\n x = sum(data[:,0])\\r\\n y = sum(data[:,1])\\r\\n z = sum(data[:,2])\\r\\n x/=n\\r\\n y/=n\\r\\n z/=n\\r\\n return x,y,z,n\",\n \"def three_dimensional(self, z): # Maybe I misunderstood the task. My method looks weird\\n return (self.x, self.y, z)\",\n \"def ppid(self):\",\n \"def calcSpotCoordinates(self, A, B, C, D):\\n pass\",\n \"def _evaluate_xyz(self, x, y, z):\\n return (\\n 2.0\\n * numpy.pi\\n * self._b\\n * self._c\\n * _potInt(\\n x, y, z, self._psi, self._b2, self._c2, glx=self._glx, glw=self._glw\\n )\\n )\",\n \"def _pid_control(self, waypoint, vehicle_location, vehicle_rotation):\\n ## Vehicle transform should be [x,y,z, roll, pitch, yaw]\\n\\n v_begin = np.array(vehicle_location)\\n v_end = v_begin + np.array([math.cos(math.radians(vehicle_rotation)),\\n math.sin(math.radians(vehicle_rotation)),0])\\n # print(\\\"vbegin\\\"+str(v_begin)+\\\"vend\\\"+ str(v_end)+\\\"waypoint\\\"+str(waypoint))\\n v_vec = np.array([v_end[0] - v_begin[0], v_end[1] - v_begin[1], 0.0])\\n w_vec = np.array([waypoint[0] -\\n v_begin[0], waypoint[1] -\\n v_begin[1], 0.0])\\n _dot = math.acos(np.clip(np.dot(w_vec, v_vec) /\\n (np.linalg.norm(w_vec) * np.linalg.norm(v_vec)), -1.0, 1.0))\\n\\n _cross = np.cross(v_vec, w_vec)\\n if _cross[2] < 0:\\n _dot *= -1.0\\n\\n self._e_buffer.append(_dot)\\n if len(self._e_buffer) >= 2:\\n _de = (self._e_buffer[-1] - self._e_buffer[-2]) / self._dt\\n _ie = sum(self._e_buffer) * self._dt\\n else:\\n _de = 0.0\\n _ie = 0.0\\n # print(\\\"dot\\\"+str(_dot)+\\\"de\\\"+str(_de)+\\\"ie\\\"+str(_ie))\\n return np.clip((self._K_P * _dot) + (self._K_D * _de /\\n self._dt) + (self._K_I * _ie * self._dt), -1.0, 1.0)\",\n \"def computeCenters3d(self, data):\\n\\n\\n for i in range(self.nPoints):\\n print(\\\"Label of point \\\", i, \\\" is \\\", self.labels[i])\\n for j in range(3):\\n self.centers[self.labels[i]][j] += data[i][j]\\n\\n for c in range(self.n):\\n for j in range(3):\\n self.centers[c][j] /= self.tots[c]\",\n \"def compute(self, *args, **kwargs):\\n vertices = args[0]\\n xpts = vertices[2] # z plays the 'x' part\\n ypts = vertices[0] # x plays the 'y' part\\n #zpts = vertices[1]\\n #********************************************\\n # switcharoo: using z in place of x\\n # using x in place of y\\n # i.e.\\n #\\n # y <- x\\n # x <- z\\n #\\n qxdot = np.dot(xpts,self.localBasis[1])\\n qxddot = np.dot(xpts,self.localBasis[2])\\n qydot = np.dot(ypts,self.localBasis[1])\\n qyddot = np.dot(ypts,self.localBasis[2])\\n store = (qxdot*qyddot - qydot*qxddot)\\n temp = np.sqrt(qxdot**2 + qydot**2)\\n if isinstance(temp, ia):\\n if temp.inf<=0:\\n temp.inf = 0.\\n denom = temp*((temp)**2)#**.5## #problem foud with sqrt\\n #\\n curvature = store/denom#((np.sqrt(qxdot*qxdot + qydot*qydot))**3.)\\n return curvature\",\n \"def _xforce_xyz(self,x,y,z):\\n return -2.*np.pi*self._rhoc_M * self.a**3*self._b*self._c * \\\\\\n _forceInt(x, y, z, self._a2, self._b2*self._a2, self._c2*self._a2, self.n, 0)\",\n \"def calculate_potential_3D(true_csd, ele_xx, ele_yy, ele_zz, \\n csd_x, csd_y, csd_z):\\n xlin = csd_x[:,0,0]\\n ylin = csd_y[0,:,0]\\n zlin = csd_z[0,0,:]\\n xlims = [xlin[0], xlin[-1]]\\n ylims = [ylin[0], ylin[-1]]\\n zlims = [zlin[0], zlin[-1]]\\n sigma = 1.0\\n pots = np.zeros(len(ele_xx))\\n tic = time.time()\\n for ii in range(len(ele_xx)):\\n pots[ii] = integrate_3D(ele_xx[ii], ele_yy[ii], ele_zz[ii],\\n xlims, ylims, zlims, true_csd, \\n xlin, ylin, zlin, \\n csd_x, csd_y, csd_z)\\n print 'Electrode:', ii\\n pots /= 4*np.pi*sigma\\n toc = time.time() - tic\\n print toc, 'Total time taken - series, sims'\\n return pots\",\n \"def _vorticity(vds) -> np.ndarray:\\n from vector_calculus import Polar\\n\\n vorticity_z = Polar.curl(\\n v_r=vds[\\\"v1\\\"],\\n v_phi=vds[\\\"v2\\\"],\\n r_coords=vds.get_ticks(axis=0),\\n phi_coords=vds.get_ticks(axis=1),\\n )\\n return vorticity_z\",\n \"def particle(*args, attribute: Union[AnyStr, bool]=\\\"\\\", cache: bool=True, conserve: Union[float,\\n bool]=0.0, count: bool=True, deleteCache: bool=True, dynamicAttrList: bool=True,\\n floatValue: float=0.0, gridSpacing: Union[float, List[float], bool]=0.0, inherit:\\n Union[float, bool]=0.0, jitterBasePoint: Union[List[float, float, float],\\n List[List[float, float, float]], bool]=None, jitterRadius: Union[float,\\n List[float], bool]=0.0, lowerLeft: Union[List[float, float, float],\\n List[List[float, float, float]], bool]=None, name: Union[AnyStr, bool]=\\\"\\\",\\n numJitters: Union[int, List[int], bool]=0, order: Union[int, bool]=0, particleId:\\n Union[int, bool]=0, perParticleDouble: bool=True, perParticleVector: bool=True,\\n position: Union[List[float, float, float], List[List[float, float, float]]]=None,\\n shapeName: Union[AnyStr, bool]=\\\"\\\", upperRight: Union[List[float, float, float],\\n List[List[float, float, float]], bool]=None, vectorValue: List[float, float,\\n float]=None, q=True, query=True, e=True, edit=True, **kwargs)->Union[AnyStr, Any]:\\n pass\",\n \"def parade(p:dict, x:Union[List[SupportsFloat],None], y:Union[SupportsFloat,None]):\\n # Initialize\\n if not p:\\n k = len(x)\\n p = {'predictions': [[] for _ in range(k)], # Holds the cavalcade\\n 'moments': [var_init() for _ in range(k)]} # Could use kurtosis_init here for more moment\\n else:\\n assert len(x) == len(p['predictions']) # 'k' is immutable\\n\\n if x is None and y is None:\\n # \\\"reset\\\" the running moments but keep prediction parade\\n p_mean, p_std = parade_mean(p), parade_std(p)\\n p['moments'] = [var_init() for _ in range(k)]\\n return p_mean, p_std, p\\n else:\\n assessable = p['predictions'].pop(0)\\n if assessable:\\n for j,xi in assessable:\\n p['moments'][j] = var_update(p['moments'][j], y - xi)\\n\\n p['predictions'].append(list())\\n for j, xj in enumerate(x):\\n p['predictions'][j].append((j, xj))\\n\\n return parade_mean(p), parade_std(p), p\",\n \"def distance((x,y,z),(x0,y0,z0)):\\n return sqrt((x-x0)**2+(y-y0)**2+(z-z0)**2)\",\n \"def make_parabola(self, x1, y1, x2, y2, x3, y3, static_var, static_val):\\r\\n denom = 1.0 * (x1 - x2) * (x1 - x3) * (x2 - x3)\\r\\n if denom == 0:\\r\\n denom = 0.000000000000001\\r\\n # TODO this feels hacky - is it ok?\\r\\n a = (x3 * (y2 - y1) + x2 * (y1 - y3) + x1 * (y3 - y2)) / denom\\r\\n b = (x3 * x3 * (y1 - y2) + x2 * x2 * (y3 - y1) + x1 * x1 * (y2 - y3)) / denom\\r\\n c = (x2 * x3 * (x2 - x3) * y1 + x3 * x1 * (x3 - x1) * y2 + x1 * x2 * (x1 - x2) * y3) / denom\\r\\n x_pos = np.arange(x1, x2, self.step_size) # x is the nonstatic var so this should be the range\\r\\n z_pos = [] # stored so if we wanted to do something with the coordinate pairs we could\\r\\n # Calculate y values\\r\\n for x in range(len(x_pos)):\\r\\n x_val = x_pos[x]\\r\\n z = +1 * (a * (x_val ** 2)) + (b * x_val) + c\\r\\n z = abs(z)\\r\\n z_pos.append(z)\\r\\n if static_var == \\\"x\\\":\\r\\n self.print_command([static_val, x_val, z]) # If x is static it never changes\\r\\n elif static_var == \\\"y\\\":\\r\\n self.print_command([x_val, static_val, z]) # If y is static it never changes\\r\\n else:\\r\\n if self.print_to_terminal == True:\\r\\n print(\\\"; make_parabola() can only create parabolas in the xz and yz planes. \\\\n\\\")\\r\\n if self.output_file is not None:\\r\\n file = open(self.output_file, \\\"a\\\")\\r\\n file.write(\\\"; make_parabola() can only create parabolas in the xz and yz planes. \\\\n\\\")\\r\\n file.close()\\r\\n break\",\n \"def compute_pe(X, bl, ip, box):\\n N = len(X)\\n inv_box = np.zeros((3, 3))\\n for i in range(3): inv_box[i, i] = 1.0 / box[i, i]\\n rij = np.zeros(3)\\n g = np.zeros(3)\\n a = 0.0\\n\\n PE = 0.0\\n for i in range(N):\\n for j in range(i):\\n rij = X[i] - X[j]\\n g = matvecmul(inv_box, rij)\\n g = g - round_numba(g)\\n rij = matvecmul(box, g)\\n a = ip[bl[i]-1, bl[j]-1]\\n PE += a * wr(norm_numba(rij))**2 / 2.0\\n return PE\",\n \"def threeptscurv(x, y):\\n length = x.size\\n R = np.zeros(length)\\n cur = np.zeros(length)\\n for i in range(1, length-1):\\n a = np.sqrt((x[i+1]-x[i])**2 + (y[i+1]-y[i])**2)\\n b = np.sqrt((x[i+1]-x[i-1])**2 + (y[i+1]-y[i-1])**2)\\n c = np.sqrt((x[i]-x[i-1])**2 + (y[i]-y[i-1])**2)\\n p = (a+b+c)/2\\n R[i] = a*b*c/4/np.sqrt(p*(p-a)*(p-b)*(p-c))\\n cur[i] = 1/R[i]\\n if R[i] > 1/ZERO or np.isnan(R[i]):\\n cur[i] = 0\\n return cur\",\n \"def hamiltonian_dp_components(Nx, Ny):\\n N = Nx * Ny\\n nearest, second, third = _generate_bonds(Nx, Ny)\\n H_pm1, H_z1 = _gen_z_pm_ops(N, nearest)\\n H_pm2, H_z2 = _gen_z_pm_ops(N, second)\\n H_pm3, H_z3 = _gen_z_pm_ops(N, third)\\n\\n H_ppmm = H_pmz = 0\\n p_mats, m_mats, z_mats = _gen_full_ops(N)\\n for bond in nearest:\\n site1, site2 = bond\\n i, j = site1.lattice_index, site2.lattice_index\\n γ = np.exp(1j * site1.angle_with(site2))\\n\\n H_ppmm += \\\\\\n γ * p_mats[i].dot(p_mats[j]) + \\\\\\n γ.conj() * m_mats[i].dot(m_mats[j])\\n\\n H_pmz += 1j * (γ.conj() * z_mats[i].dot(p_mats[j]) -\\n γ * z_mats[i].dot(m_mats[j]) +\\n γ.conj() * p_mats[i].dot(z_mats[j]) -\\n γ * m_mats[i].dot(z_mats[j]))\\n\\n return H_pm1, H_z1, H_ppmm, H_pmz, H_pm2, H_z2, H_z3, H_pm3\",\n \"def createThreePoints(cls, x1, y1, z1, x2, y2, z2, x3, y3, z3):\\n d = np.array([x2 - x1, y2 - y1, z2 - z1])\\n p0 = np.array([x1, y1, z1])\\n return cls(p0, d)\",\n \"def normalize(x: float, y: float, z: float) -> Point3D:\\n mag = math.sqrt(x*x + y*y + z*z)\\n return x/mag, y/mag, z/mag\",\n \"def compute_bulk_z(xy, NL, KL, BL):\\n NP = len(xy)\\n boundary = extract_boundary(xy, NL, KL, BL)\\n bulk = np.setdiff1d(np.arange(NP), boundary)\\n # Compute the starting z in the bulk\\n countKL = [KL[jj] for jj in bulk]\\n # print 'found = ', np.count_nonzero(countKL), ' connections for ', NP_bulk, ' bulk particles...'\\n z = float(np.count_nonzero(countKL)) / float(len(bulk))\\n return z\",\n \"def _zforce_xyz(self,x,y,z):\\n return -2.*np.pi*self._rhoc_M * self.a**3*self._b*self._c * \\\\\\n _forceInt(x, y, z, self._a2, self._b2*self._a2, self._c2*self._a2, self.n, 2)\",\n \"def processParticles(self,imgdata,partdatas,shiftdata):\\n\\t\\traise NotImplementedError()\",\n \"def get_3d_points(preds_3d):\\n for i,p in enumerate(preds_3d):\\n preds_3d[i] = preds_3d[i] - preds_3d[i].mean(0)*np.ones((16,1));\\n return preds_3d;\",\n \"def extractCoords(self):\\n if not self.rank:\\n logging.info('Extracting atomic poitions')\\n\\n # Extract coordinates from liggghts\\n self.lmp.command('variable x atom x')\\n x = Rxn.lmp.extract_variable(\\\"x\\\", \\\"group1\\\", 1)\\n\\n self.lmp.command('variable y atom y')\\n y = Rxn.lmp.extract_variable(\\\"y\\\", \\\"group1\\\", 1)\\n\\n self.lmp.command('variable z atom z')\\n z = Rxn.lmp.extract_variable(\\\"z\\\", \\\"group1\\\", 1)\\n\\n coords = np.zeros((self.lmp.get_natoms(),3))\\n\\n for i in range(self.lmp.get_natoms()):\\n coords[i,:] = x[i], y[i], z[i]\\n\\n self.lmp.command('variable x delete')\\n self.lmp.command('variable y delete')\\n self.lmp.command('variable z delete')\\n\\n return coords\",\n \"def point3D(self, plan, sequence, imgnum, pts):\\n xs, ys, zs = list(), list(), list()\\n\\n if imgnum < 10:\\n img = pydicom.dcmread(\\\"{}/{}/{}/{}/IM_0000{}.dcm\\\".format(\\n DIR_DICOM, self.patient, plan, sequence, imgnum))\\n # img = dicom.read_file(\\\"{}/{}/{}/{}/IM_0000{}.dcm\\\".format(\\n # DIR_DICOM, self.patient, plan, sequence, imgnum))\\n else:\\n img = pydicom.dcmread(\\\"{}/{}/{}/{}/IM_000{}.dcm\\\".format(\\n DIR_DICOM, self.patient, plan, sequence, imgnum))\\n # img = dicom.read_file(\\\"{}/{}/{}/{}/IM_000{}.dcm\\\".format(\\n # DIR_DICOM, self.patient, plan, sequence, imgnum))\\n\\n xx_s7 = img.ImageOrientationPatient[0]\\n xy_s7 = img.ImageOrientationPatient[1]\\n xz_s7 = img.ImageOrientationPatient[2]\\n\\n yx_s7 = img.ImageOrientationPatient[3]\\n yy_s7 = img.ImageOrientationPatient[4]\\n yz_s7 = img.ImageOrientationPatient[5]\\n\\n delta_i_s7 = img.PixelSpacing[0]\\n delta_j_s7 = img.PixelSpacing[1]\\n\\n sx_s7 = img.ImagePositionPatient[0]\\n sy_s7 = img.ImagePositionPatient[1]\\n sz_s7 = img.ImagePositionPatient[2]\\n\\n m = np.matrix([\\n [xx_s7 * delta_i_s7, yx_s7 * delta_j_s7, 0.0, sx_s7],\\n [xy_s7 * delta_i_s7, yy_s7 * delta_j_s7, 0.0, sy_s7],\\n [xz_s7 * delta_i_s7, yz_s7 * delta_j_s7, 0.0, sz_s7],\\n [0.0, 0.0, 0.0, 1.0]\\n ])\\n\\n for p in pts:\\n m2 = np.matrix([\\n [p[0]],\\n [p[1]],\\n [0.0],\\n [1.0]\\n ])\\n\\n m_res = np.dot(m, m2)\\n\\n xs.append(m_res.item((0, 0)))\\n ys.append(m_res.item((1, 0)))\\n zs.append(m_res.item((2, 0)))\\n\\n return xs, ys, zs\",\n \"def ion2_position(self,x,y,z):\\n axes_vector = np.array([self.a,self.b,self.c])\\n self.ion2 = x*self.a + y*self.b + z*self.c\\n self.position['1B'] = np.dot(self.position_map[1],axes_vector) + self.ion2\\n self.position['2B'] = np.dot(self.position_map[2],axes_vector) + self.ion2\\n self.position['3B'] = np.dot(self.position_map[3],axes_vector) + self.ion2\\n self.position['4B'] = np.dot(self.position_map[4],axes_vector) + self.ion2\\n self.position['5B'] = np.dot(self.position_map[5],axes_vector) + self.ion2\\n self.position['6B'] = np.dot(self.position_map[6],axes_vector) + self.ion2\\n self.position['7B'] = np.dot(self.position_map[7],axes_vector) + self.ion2\\n self.position['8B'] = np.dot(self.position_map[8],axes_vector) + self.ion2\",\n \"def box_collision_info(self):\\r\\n position = np.zeros((self.Npart,3)) # antall part, dim, iterasjoner\\r\\n position[:,:] = np.random.uniform(0,1e-6, size = (self.Npart,3))\\r\\n velocity = np.zeros((self.Npart,3))\\r\\n velocity[:,:] = np.random.normal(0,self.sigma,size = (self.Npart,3))\\r\\n\\r\\n part_collided = 0\\r\\n part_escaped = 0\\r\\n momentum = 0\\r\\n\\r\\n print 'engine started'\\r\\n for i in xrange(1,self.n):\\r\\n #collision\\r\\n position += velocity*dt\\r\\n l_hole = position[:,0:2] > self.L/4\\r\\n h_hole = position[:,0:2] < (3*self.L)/4\\r\\n pos_xy = np.logical_and(l_hole, h_hole)\\r\\n pos_xy = np.logical_and(pos_xy[:,0], pos_xy[:,1])\\r\\n pos_z = position[:,2] < 0\\r\\n esc_part = np.logical_and(pos_z, pos_xy)\\r\\n\\r\\n #velocity[esc_part] = velocity[esc_part]\\r\\n part_escaped += np.sum(esc_part)\\r\\n\\r\\n for j in xrange(0,3):\\r\\n impact_wall_pos = np.logical_and(position[:,j] > 0,\\r\\n position[:,j] < self.L)\\r\\n velocity[np.logical_not(impact_wall_pos),j] = -velocity[\\r\\n np.logical_not(impact_wall_pos),j]\\r\\n\\r\\n\\r\\n if j == 0:\\r\\n part_collided += np.sum(np.logical_not(impact_wall_pos),j)\\r\\n momentum += np.sum(2*self.m*abs(velocity[np.logical_not(\\r\\n impact_wall_pos),j]))\\r\\n\\r\\n\\r\\n\\r\\n position[position < 0] = 0\\r\\n position[position >self.L] = self.L\\r\\n\\r\\n particle_collided = part_collided/2\\r\\n return position, velocity,part_escaped, impact_wall_pos, particle_collided, momentum\",\n \"def plot_results_3d(p_x, p_y, p_z, h_exp = 0.5):\\n plt.figure(figsize = (10, 10))\\n ax3d = plt.axes(projection = '3d') \\n\\n color=iter(cm.rainbow(np.linspace(0,1,p_x.shape[0]))) # (1)\\n labels = ['Particle ' + str(pl+1) for pl in np.arange(0, p_x.shape[0], step = 1)]\\n \\n for p in np.arange(0, p_x.shape[0], step = 1): \\n c = next(color) # (1)\\n for t in np.arange(0, p_x.shape[1], step = 1): \\n ax3d.plot3D(p_x[p, t], p_y[p, t], p_z[p, t], 'x', c = c, label = labels[p]) \\n legend_without_duplicate_labels(ax3d)\\n ax3d.set_xlabel('X (pixels)') \\n ax3d.set_ylabel('Y (pixels') \\n ax3d.set_zlabel('Z (pixels)') \\n ax3d.set_xlim([origin-150,origin+150])\\n ax3d.set_ylim([origin-150,origin+150])\\n ax3d.set_zlim([origin-150,origin+150])\\n ax3d.set_title('3D particle trajectories - H = ' + str(h_exp))\",\n \"def h(pos,obj):\\n return D(pos)*(distancia_nodos(pos,obj))\",\n \"def setParams(self, p = 2):\\n self.p = p\\n self.l = p - 1\\n self.id_ntot = {}\\n self.id_y = {}\\n self.id_W = {}\\n self.id_X = {}\\n for i in self.uniids:\\n tracker = (self.data['id'] == i)\\n self.id_ntot.update({i: np.sum(tracker)})\\n self.id_y.update({i:\\n self.data['weight'][tracker].reshape(np.sum(tracker), 1)})\\n self.id_W.update({i: self._designMatrix_(p, tracker)})\\n self.id_X.update({i:\\n self._designMatrix_(self.l+1,tracker,is_X=True)})\\n self.id_Z = self.id_W.copy()\",\n \"def num_particles(self) -> Tuple[int, int]:\\n return (self.num_alpha, self.num_beta)\",\n \"def point_from_rays(self):\\n print \\\"generating the 3d point from given clicked points\\\"\\n \\n #gather cams and points clicked \\n uvs = []\\n cams = []\\n for iFrame in self.frames:\\n if iFrame.lastClick : \\n uv = numpy.multiply(iFrame.lastClick,self.reduceFactor)\\n uvs.append(uv)\\n cam = load_perspective_camera(self.camList[iFrame.currImg])\\n cams.append(cam)\\n point = get_3d_from_cams(cams, uvs)\\n self.point3d = point;\\n self.pointLabel.set(\\\"3d Point: \\\" + str(self.point3d))\\n\\n # project 3d point into each image, and gather intensities \\n values = []\\n ims = []\\n for idx, img in enumerate(self.imgList):\\n cam = load_perspective_camera(self.camList[idx])\\n imgPoint = project_point(cam, point[0], point[1], point[2])\\n imgPoint = numpy.divide(imgPoint, self.reduceFactor)\\n self.allUVs.append(imgPoint)\\n \\n #grab float intensity value at this point \\n imgView,ni,nj = load_image(img)\\n val = pixel(imgView, imgPoint)\\n if val > 0.0:\\n values.append(val)\\n ims.append(idx)\\n \\n #cleanup\\n remove_from_db([imgView, cam])\\n \\n\\n #write mean/std of intensities \\n self.meanLabel.set(\\\"Mean: \\\" + str(numpy.mean(values)) )\\n self.stdLabel.set(\\\"Std Dev: \\\" + str(numpy.std(values)) )\\n #plot the intensities by image number \\n self.f.clf();\\n self.a = self.f.add_subplot(311)\\n self.a.set_xlabel(\\\"img #\\\")\\n self.a.set_ylabel(\\\"intensity\\\")\\n self.a.plot(ims, values)\\n #plot the histogram of intensities by image number \\n pdf, bins, patches = plt.hist(values)\\n self.b = self.f.add_subplot(313)\\n self.b.set_xlabel(\\\"bin val\\\")\\n self.b.set_ylabel(\\\"freq\\\")\\n self.b.hist(values, 15, normed=1, facecolor=\\\"green\\\" )\\n self.canvas.show();\",\n \"def get_coord_val(self, x, y, z):\\n if self.is_4d():\\n #return self._data[y, x, z, self._time_point]\\n return self._data[self._y_shift - y, x, z, self._time_point]\\n else:\\n #return self._data[y, x, z]\\n return self._data[self._y_shift - y, x, z]\",\n \"def x_add_particles():\\n particle_count_list = np.zeros(7)\",\n \"def optimise_xy(xy, *args):\\n z, elements, coordinates = args\\n window_com = np.array([xy[0], xy[1], z])\\n return -pore_diameter(elements, coordinates, com=window_com)[0]\",\n \"def get_xyz_in_coord_vectorized(self, model, cid=0, fdtype='float32'):\\n xyz_cid0 = None\\n nid_cp_cd = None\\n if self.gui.nnodes > 0:\\n #xyz_cid0 = {}\\n #nid_cp_cd = {}\\n\\n out = model.get_displacement_index_xyz_cp_cd(\\n fdtype=fdtype, idtype='int32')\\n icd_transform, icp_transform, xyz_cp, nid_cp_cd = out\\n self.icd_transform = icd_transform\\n\\n #print(\\\"transform_xyzcp_to_xyz_cid\\\")\\n #model.nodes.cp = nid_cp_cd[:, 1]\\n xyz_cid0 = model.transform_xyzcp_to_xyz_cid(\\n xyz_cp, nid_cp_cd[:, 0], icp_transform, cid=cid,\\n in_place=False)\\n model.nodes.xyz_cid0 = xyz_cid0\\n model.nodes.nids = nid_cp_cd[:, 0]\\n\\n nid_map = self.gui.nid_map\\n for i, nid in enumerate(nid_cp_cd[:, 0]):\\n nid_map[nid] = i\\n\\n self._add_nastran_spoints_to_grid(model.spoints, nid_map)\\n return xyz_cid0, nid_cp_cd\",\n \"def setupParticles(self):\\n\\n for ss in self.pargs['species']:\\n\\n # Make sure we are setting up particles, not walls (so we check for id existence)\\n if 'id' in ss and 'wall' not in ss:\\n if not self.rank:\\n logging.info('Setting up particles for group{id}'.format(**ss))\\n\\n randName = np.random.randint(10**5,10**8)\\n pddName = 'pdd' + '{}'.format(np.random.randint(10**5,10**8))\\n\\n if 'vol_lim' not in ss:\\n ss['vol_lim'] = 1e-20\\n\\n id = ss['id'] - 1\\n self.lmp.command('group group{} type {}'.format(id, ss['id']))\\n\\n if 'args'in ss:\\n args = ss['args']\\n else:\\n args = ()\\n\\n if 'radius' in ss:\\n radius = ss['radius']\\n\\n if not isinstance(radius, tuple):\\n radius = ('constant', radius)\\n\\n self.lmp.command('fix {} '.format(randName) + 'group{}'.format(id) + ' particletemplate/{style} 15485867 volume_limit {vol_lim} atom_type {id} density constant {density} radius'.format(**ss) + (' {}' * len(radius)).format(*radius) \\\\\\n + (' {}' * len(args)).format(*args))\\n else:\\n self.lmp.command('fix {} '.format(randName) + 'group{}'.format(id) + ' particletemplate/{style} 15485867 volume_limit {vol_lim} atom_type {id} density constant {density}'.format(**ss) + (' {}' * len(args)).format(*args))\\n \\n self.lmp.command('fix {} '.format(pddName) + 'group{}'.format(id) + ' particledistribution/discrete 67867967 1'.format(**ss) + ' {} 1.0'.format(randName))\\n\\n if ss['style'] is 'multisphere':\\n itype = ss['style']\\n else:\\n itype = 'nve/{style}'.format(**ss)\\n\\n #Do NOT unfix randName! Will cause a memory corruption error\\n self.pddName.append(pddName)\",\n \"def calculate_dimensions(self):\\n x_coordinates = np.sort(self.grid['x'][:, 0]) # first x node\\n self.nr_nodes_z = np.where(x_coordinates == x_coordinates[0])[0].size\\n self.nr_elements_x = self.elements.shape[0] / (self.nr_nodes_z - 1)\\n self.nr_nodes_x = self.nr_elements_x + 1\\n self.nr_elements_z = self.nr_nodes_z - 1\",\n \"def test_pid_proj2():\\n d = bivariates['reduced or']\\n pid = PID_IG(d, [[0], [1]], [2])\\n assert pid[((0,), (1,))] == pytest.approx(-0.03122, abs=1e-4)\\n assert pid[((0,),)] == pytest.approx(0.34250, abs=1e-4)\\n assert pid[((1,),)] == pytest.approx(0.34250, abs=1e-4)\\n assert pid[((0, 1),)] == pytest.approx(0.34622, abs=1e-4)\",\n \"def _derX(self, x, y, z):\\n if _isscalar(x):\\n x_pos = max(min(self.xSearchFunc(self.x_list, x), self.x_n - 1), 1)\\n y_pos = max(min(self.ySearchFunc(self.y_list, y), self.y_n - 1), 1)\\n z_pos = max(min(self.zSearchFunc(self.z_list, z), self.z_n - 1), 1)\\n else:\\n x_pos = self.xSearchFunc(self.x_list, x)\\n x_pos[x_pos < 1] = 1\\n x_pos[x_pos > self.x_n - 1] = self.x_n - 1\\n y_pos = self.ySearchFunc(self.y_list, y)\\n y_pos[y_pos < 1] = 1\\n y_pos[y_pos > self.y_n - 1] = self.y_n - 1\\n z_pos = self.zSearchFunc(self.z_list, z)\\n z_pos[z_pos < 1] = 1\\n z_pos[z_pos > self.z_n - 1] = self.z_n - 1\\n beta = (y - self.y_list[y_pos - 1]) / (\\n self.y_list[y_pos] - self.y_list[y_pos - 1]\\n )\\n gamma = (z - self.z_list[z_pos - 1]) / (\\n self.z_list[z_pos] - self.z_list[z_pos - 1]\\n )\\n dfdx = (\\n (\\n (1 - beta) * (1 - gamma) * self.f_values[x_pos, y_pos - 1, z_pos - 1]\\n + (1 - beta) * gamma * self.f_values[x_pos, y_pos - 1, z_pos]\\n + beta * (1 - gamma) * self.f_values[x_pos, y_pos, z_pos - 1]\\n + beta * gamma * self.f_values[x_pos, y_pos, z_pos]\\n )\\n - (\\n (1 - beta)\\n * (1 - gamma)\\n * self.f_values[x_pos - 1, y_pos - 1, z_pos - 1]\\n + (1 - beta) * gamma * self.f_values[x_pos - 1, y_pos - 1, z_pos]\\n + beta * (1 - gamma) * self.f_values[x_pos - 1, y_pos, z_pos - 1]\\n + beta * gamma * self.f_values[x_pos - 1, y_pos, z_pos]\\n )\\n ) / (self.x_list[x_pos] - self.x_list[x_pos - 1])\\n return dfdx\",\n \"def assignPositions(self):\\n n = int(math.ceil(self.numAtoms**(1.0/3.0))) # Number of atoms in a direction\\n particle = 0 # Particles placed so far\\n \\n for x in range(0, n):\\n for y in range(0, n):\\n for z in range(0, n):\\n if (particle < self.numAtoms):\\n self.atoms[particle].x = x * self.sigma\\n self.atoms[particle].y = y * self.sigma \\n self.atoms[particle].z = z * self.sigma\\n particle += 1\",\n \"def _get_pid(split_data, sensor):\\n prot, ip_dst, port_dst, timestamp = split_data\\n prot = prot.lower()\\n\\n if not sanitizer.check_get_pid_params(prot, ip_dst, port_dst, timestamp):\\n return '-1,error checking input'\\n\\n return sensor.search_process(prot, ip_dst, port_dst, timestamp)\",\n \"def _compute_ptdfs(self):\\n z = self._compute_z()\\n s = np.zeros([self.n_nodes, self.n_nodes, self.n_nodes])\\n for k in range(self.n_nodes):\\n for L in range(self.n_nodes):\\n for i in range(self.n_nodes):\\n if k == 0 and L != 0:\\n s[k, L, i] = -1 * z[L-1, i-1]\\n elif k != 0 and L == 0:\\n s[k, L, i] = z[k-1, i-1]\\n elif k != 0 and L != 0 and k != L:\\n s[k, L, i] = z[k-1, i-1] - z[L-1, i-1]\\n return s\",\n \"def FindPointsWithinRadius(self, p_float, , vtkIdList):\\n ...\",\n \"def pairCorrelationFunction_3D(x, y, z, S, rMax, dr):\\n from numpy import zeros, sqrt, where, pi, mean, arange, histogram\\n\\n # Find particles which are close enough to the cube center that a sphere of radius\\n # rMax will not cross any face of the cube\\n bools1 = x > rMax\\n bools2 = x < (S - rMax)\\n bools3 = y > rMax\\n bools4 = y < (S - rMax)\\n bools5 = z > rMax\\n bools6 = z < (S - rMax)\\n\\n interior_indices, = where(bools1 * bools2 * bools3 * bools4 * bools5 * bools6)\\n num_interior_particles = len(interior_indices)\\n\\n if num_interior_particles < 1:\\n raise RuntimeError (\\\"No particles found for which a sphere of radius rMax\\\\\\n will lie entirely within a cube of side length S. Decrease rMax\\\\\\n or increase the size of the cube.\\\")\\n\\n edges = arange(0., rMax + 1.1 * dr, dr)\\n num_increments = len(edges) - 1\\n g = zeros([num_interior_particles, num_increments])\\n radii = zeros(num_increments)\\n numberDensity = len(x) / S**3\\n\\n # Compute pairwise correlation for each interior particle\\n for p in range(num_interior_particles):\\n index = interior_indices[p]\\n d = sqrt((x[index] - x)**2 + (y[index] - y)**2 + (z[index] - z)**2)\\n d[index] = 2 * rMax\\n\\n (result, bins) = histogram(d, bins=edges, normed=False)\\n g[p,:] = result / numberDensity\\n\\n # Average g(r) for all interior particles and compute radii\\n g_average = zeros(num_increments)\\n for i in range(num_increments):\\n radii[i] = (edges[i] + edges[i+1]) / 2.\\n rOuter = edges[i + 1]\\n rInner = edges[i]\\n g_average[i] = mean(g[:, i]) / (4.0 / 3.0 * pi * (rOuter**3 - rInner**3))\\n\\n return (g_average, radii, interior_indices)\\n # Number of particles in shell/total number of particles/volume of shell/number density\\n # shell volume = 4/3*pi(r_outer**3-r_inner**3)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6086874","0.59364504","0.5866037","0.5758806","0.5704394","0.56775993","0.5539624","0.5480766","0.5472652","0.544325","0.544325","0.54417825","0.5440501","0.54281235","0.53789955","0.53669405","0.5355419","0.5350521","0.5342179","0.53407073","0.52950525","0.52776915","0.5263636","0.5255988","0.52503526","0.52063936","0.51988935","0.51964253","0.51946175","0.51946175","0.5186394","0.51510215","0.51210266","0.50987387","0.5064591","0.50623417","0.5034352","0.5028594","0.50186914","0.5013572","0.5011133","0.49968475","0.49944347","0.49739078","0.49737388","0.49730122","0.49592203","0.49553272","0.49551356","0.49531025","0.49481","0.49415424","0.4930211","0.4929949","0.49249202","0.49244195","0.49231434","0.49141628","0.49100825","0.48978412","0.48891985","0.48863447","0.48665273","0.48572943","0.48549238","0.48540342","0.48494563","0.48461005","0.48437378","0.48390448","0.48385444","0.48265097","0.48254162","0.48225778","0.48217973","0.48201203","0.480901","0.48030216","0.48025382","0.48015422","0.47950742","0.4793564","0.47796476","0.477587","0.477577","0.4775417","0.47705942","0.47679895","0.47676674","0.47672218","0.4765341","0.47629255","0.47627282","0.47561336","0.47552028","0.47434974","0.4733703","0.47333592","0.4729035","0.47095963"],"string":"[\n \"0.6086874\",\n \"0.59364504\",\n \"0.5866037\",\n \"0.5758806\",\n \"0.5704394\",\n \"0.56775993\",\n \"0.5539624\",\n \"0.5480766\",\n \"0.5472652\",\n \"0.544325\",\n \"0.544325\",\n \"0.54417825\",\n \"0.5440501\",\n \"0.54281235\",\n \"0.53789955\",\n \"0.53669405\",\n \"0.5355419\",\n \"0.5350521\",\n \"0.5342179\",\n \"0.53407073\",\n \"0.52950525\",\n \"0.52776915\",\n \"0.5263636\",\n \"0.5255988\",\n \"0.52503526\",\n \"0.52063936\",\n \"0.51988935\",\n \"0.51964253\",\n \"0.51946175\",\n \"0.51946175\",\n \"0.5186394\",\n \"0.51510215\",\n \"0.51210266\",\n \"0.50987387\",\n \"0.5064591\",\n \"0.50623417\",\n \"0.5034352\",\n \"0.5028594\",\n \"0.50186914\",\n \"0.5013572\",\n \"0.5011133\",\n \"0.49968475\",\n \"0.49944347\",\n \"0.49739078\",\n \"0.49737388\",\n \"0.49730122\",\n \"0.49592203\",\n \"0.49553272\",\n \"0.49551356\",\n \"0.49531025\",\n \"0.49481\",\n \"0.49415424\",\n \"0.4930211\",\n \"0.4929949\",\n \"0.49249202\",\n \"0.49244195\",\n \"0.49231434\",\n \"0.49141628\",\n \"0.49100825\",\n \"0.48978412\",\n \"0.48891985\",\n \"0.48863447\",\n \"0.48665273\",\n \"0.48572943\",\n \"0.48549238\",\n \"0.48540342\",\n \"0.48494563\",\n \"0.48461005\",\n \"0.48437378\",\n \"0.48390448\",\n \"0.48385444\",\n \"0.48265097\",\n \"0.48254162\",\n \"0.48225778\",\n \"0.48217973\",\n \"0.48201203\",\n \"0.480901\",\n \"0.48030216\",\n \"0.48025382\",\n \"0.48015422\",\n \"0.47950742\",\n \"0.4793564\",\n \"0.47796476\",\n \"0.477587\",\n \"0.477577\",\n \"0.4775417\",\n \"0.47705942\",\n \"0.47679895\",\n \"0.47676674\",\n \"0.47672218\",\n \"0.4765341\",\n \"0.47629255\",\n \"0.47627282\",\n \"0.47561336\",\n \"0.47552028\",\n \"0.47434974\",\n \"0.4733703\",\n \"0.47333592\",\n \"0.4729035\",\n \"0.47095963\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.6788774"},"document_rank":{"kind":"string","value":"0"}}}],"truncated":false,"partial":true},"paginationData":{"pageIndex":904,"numItemsPerPage":100,"numTotalItems":95772,"offset":90400,"length":100}},"jwt":"eyJhbGciOiJFZERTQSIsImtpZCI6IjVHZDBvd0g5MTM2eDZjc1FvbE1zcktNWUZoRVFoUm5PVVVybEpjOUhaUEEifQ.eyJyZWFkIjp0cnVlLCJwZXJtaXNzaW9ucyI6eyJyZXBvLmNvbnRlbnQucmVhZCI6dHJ1ZX0sImlhdCI6MTc4NTcyMzcxNSwianRpIjoiMGU1ZjNhNjgtOGU4YS00NDM1LTkxNDUtNzBlMzg4NWE4MWVmIiwic3ViIjoiL2RhdGFzZXRzL25vbWljLWFpL2Nvcm5zdGFjay1weXRob24tdjEiLCJleHAiOjE3ODU3MjczMTUsImlzcyI6Imh0dHBzOi8vaHVnZ2luZ2ZhY2UuY28ifQ.hshHo24YGlQNif--6Qd0TadrcdvMWJcUcF1kPh7OVB5gJX-tc6PA3FTf57m1Fs9QHSeGpSRNdbGmv0thO9lFAw","displayUrls":true,"splitSizeSummaries":[{"config":"default","split":"train","numRows":95772,"numBytesParquet":1928375891}]},"discussionsStats":{"closed":1,"open":1,"total":2},"fullWidth":true,"hasGatedAccess":true,"hasFullAccess":true,"isEmbedded":false,"savedQueries":{"community":[],"user":[]}}">
query stringlengths 9 3.4k | document stringlengths 9 87.4k | metadata dict | negatives listlengths 4 101 | negative_scores listlengths 4 101 | document_score stringlengths 3 10 | document_rank stringclasses 102
values |
|---|---|---|---|---|---|---|
Assert that two multiline strings are equal. If they aren't, show a nice diff. | def assertMultiLineEqual(self, first, second, msg=None):
self.assertTrue(isinstance(first, str),
'First argument is not a string')
self.assertTrue(isinstance(second, str),
'Second argument is not a string')
if first != second:
message = ''.join(diffli... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def assertMultiLineEqual(self, first, second, msg=None):\r\n self.assert_(isinstance(first, basestring), (\r\n 'First argument is not a string'))\r\n self.assert_(isinstance(second, basestring), (\r\n 'Second argument is not a string'))\r\n\r\n if first != second:... | [
"0.82592815",
"0.74987626",
"0.72812736",
"0.726718",
"0.7259299",
"0.72427946",
"0.718826",
"0.71434915",
"0.7009044",
"0.6992177",
"0.6975448",
"0.6975448",
"0.69021523",
"0.6861659",
"0.6852261",
"0.68281657",
"0.681266",
"0.67798996",
"0.67484903",
"0.6747903",
"0.6730730... | 0.8611194 | 0 |
test Biblio's eq method for duplicates | def isduplicate(a, b):
db = bibtexparser.loads(a+'\n'+b)
e1, e2 = db.entries
refs = Biblio()
return refs.eq(e1, e2) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def isduplicate(self, a, b):\n db = bibtexparser.loads(a+'\\n'+b)\n e1, e2 = db.entries\n refs = Biblio(similarity=self.similarity)\n return refs.eq(e1, e2)",
"def test_duplicate_entries(self):",
"def testEquality(self):\n pass",
"def isduplicate(self, a, b):\n open(... | [
"0.7259203",
"0.65145224",
"0.6298735",
"0.62130135",
"0.6186938",
"0.61241937",
"0.6092625",
"0.6092625",
"0.6092625",
"0.6092625",
"0.6092625",
"0.6092625",
"0.6092625",
"0.6092625",
"0.6092625",
"0.6092625",
"0.6092625",
"0.6092625",
"0.6092625",
"0.6092625",
"0.6092625",
... | 0.7169162 | 1 |
test Biblio's eq method for duplicates | def isduplicate(self, a, b):
db = bibtexparser.loads(a+'\n'+b)
e1, e2 = db.entries
refs = Biblio(similarity=self.similarity)
return refs.eq(e1, e2) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def isduplicate(a, b):\n db = bibtexparser.loads(a+'\\n'+b)\n e1, e2 = db.entries\n refs = Biblio()\n return refs.eq(e1, e2)",
"def test_duplicate_entries(self):",
"def testEquality(self):\n pass",
"def isduplicate(self, a, b):\n open(self.mybib, 'w').write(a)\n ... | [
"0.71667874",
"0.65124714",
"0.62988126",
"0.62106305",
"0.61856186",
"0.6122873",
"0.60917985",
"0.60917985",
"0.60917985",
"0.60917985",
"0.60917985",
"0.60917985",
"0.60917985",
"0.60917985",
"0.60917985",
"0.60917985",
"0.60917985",
"0.60917985",
"0.60917985",
"0.60917985",... | 0.72566575 | 0 |
test Biblio's eq method in 'add' mode | def isduplicate(self, a, b):
open(self.mybib, 'w').write(a)
open(self.otherbib, 'w').write(b)
res = sp.call('papers add {} --bibtex {} --update-key --mode r --debug'.format(self.otherbib, self.mybib), shell=True)
return res != 0 | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_add(self):\n self.assertEqual(3, foo.add(1, 2))\n self.assertNotEqual(3, foo.add(2, 2))",
"def test_add():\n\n assert add(1, 1) == 2\n assert add(1, 2) == add(2, 1) == 3",
"def test_add(self):\n self.assertEqual(3, add(1, 2))\n self.assertNotEqual(3, add(2, 2))",
"... | [
"0.6051355",
"0.60280013",
"0.5969772",
"0.579601",
"0.5704755",
"0.5684875",
"0.56681126",
"0.5622322",
"0.5596762",
"0.5589284",
"0.55776083",
"0.55707574",
"0.55216604",
"0.55134535",
"0.5512043",
"0.5476853",
"0.54704183",
"0.54682106",
"0.54536456",
"0.54457116",
"0.5427... | 0.5490873 | 15 |
Gives a list of bounding boxes containg faces in the given image | def get_faceboxes(self,img,threshold):
faces = self.mark_detector.extract_cnn_facebox(img,threshold)
faceboxes = []
for face in faces:
start = (face[0],face[1])
end = (face[2],face[3])
box = Box.setStartEnd(start,end)
faceboxes.append(... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _box_faces(image):\n for face in image.faces:\n _box_face(image, face)\n return image",
"def get_faceboxes(self, image, threshold):\n rows, cols, _ = image.shape\n\n confidences = []\n faceboxes = []\n\n self.face_net.setInput(cv2.dnn.blobFromImage(image, 1.0, (300, 3... | [
"0.8085123",
"0.7980415",
"0.79564846",
"0.7850688",
"0.7760176",
"0.77158284",
"0.76029724",
"0.760038",
"0.75674653",
"0.7496214",
"0.74177533",
"0.74149823",
"0.7411155",
"0.727319",
"0.72631246",
"0.7260427",
"0.7202723",
"0.7196494",
"0.7174461",
"0.7151705",
"0.71304613... | 0.7947982 | 3 |
Returns marks, (x1,x2) x1 and x2 are points identifying a line ortogonal to the face plane | def getGazeDirection(self,img, facebox):
facebox_list = facebox.getList()
#extrat face box and downsampling
face_img = img[facebox_list[1]: facebox_list[3],facebox_list[0]: facebox_list[2]]
face_img = cv2.resize(face_img, (128, 128))
face_img = cv2.cvtColor(face_img, cv2... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_pose_marks(self, marks):\n pose_marks = []\n pose_marks.append(marks[30]) # Nose tip\n pose_marks.append(marks[8]) # Chin\n pose_marks.append(marks[36]) # Left eye left corner\n pose_marks.append(marks[45]) # Right eye right corner\n pose_marks.append(... | [
"0.6497237",
"0.61907125",
"0.59628296",
"0.57378024",
"0.5665428",
"0.55966413",
"0.5570014",
"0.55657524",
"0.55437905",
"0.5528099",
"0.552023",
"0.55149305",
"0.5482512",
"0.54736346",
"0.54707223",
"0.5448917",
"0.5430297",
"0.54257905",
"0.5408462",
"0.5394228",
"0.5390... | 0.5477771 | 13 |
Create the cached links. These are the links between locations caused by using direction keys for navigation as opposed to using dungeon features. | def cache_links(self):
for source_location in self.gen_locations():
for vi, delta in vi_delta_pairs:
drow, dcol = delta
for command, magnitude in ((vi, 1), (vi.upper(), 8)):
target_location = source_location
for i in range(magni... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def build_links(self):\n xygrid = self.xymap.xygrid\n\n # we must use the xygrid coordinates\n x, y = self.x, self.y\n\n # scan in all directions for links\n for direction, (dx, dy) in MAPSCAN.items():\n\n lx, ly = x + dx, y + dy\n\n if lx in xygrid and ly i... | [
"0.69821167",
"0.63550127",
"0.5738111",
"0.57277435",
"0.5647053",
"0.56404555",
"0.5520767",
"0.55009866",
"0.54728156",
"0.5469091",
"0.5463365",
"0.54544103",
"0.54356766",
"0.54338235",
"0.5429366",
"0.5406448",
"0.5374355",
"0.5365685",
"0.53489137",
"0.5334808",
"0.533... | 0.78895026 | 0 |
Build the transition and dynamic programming tables used to find the shortest path to a location. One object picker should be created per selection. | def __init__(self, location_to_ascii, row_min=1, col_min=0, row_max=21, col_max=78):
# Define the area of interest.
Rect.__init__(self, row_min, col_min, row_max, col_max)
# Define the transition table.
self.transition_table = AscDP.BackwardsForwardsTable()
# Add direction moves ... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def compute_lookuptable(self):\n\n if self.uselookuptable:\n # Evaluation lookup tables \n self.action_isok = np.zeros( ( self.nodes_n , self.actions_n ) , dtype = bool )\n self.x_next = np.zeros( ( self.nodes_n , self.actions_n , self.DS.n ) , dtype = float ) ... | [
"0.5611639",
"0.55651593",
"0.5509236",
"0.5498048",
"0.54785836",
"0.5462349",
"0.5421589",
"0.54057175",
"0.54055935",
"0.53959197",
"0.5389567",
"0.53534895",
"0.5275653",
"0.5274709",
"0.52581483",
"0.52575547",
"0.5246054",
"0.52256",
"0.5220583",
"0.5214623",
"0.5211673... | 0.0 | -1 |
This function simply calculates the epsilon effective if you don't give the value for epsiln one or two it will consider it to be 0.9 by default | def epsilonEffective(epsilon1=0.9, epsilon2=0.9):
result=1/(1/epsilon1+1/epsilon2-1)
return result | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def epsilon():\n return _EPSILON",
"def epsilon(current_episode, num_episodes):\n # return 1 - (current_episode/num_episodes)\n return .5 * .9**current_episode",
"def epsilon_delta(self):",
"def epsilon(self):\n return self.__epsilon",
"def update_epsilon(self):\n\t\tif self.epsilon > self.ep... | [
"0.7814464",
"0.77845764",
"0.74526864",
"0.73508424",
"0.7289584",
"0.7287363",
"0.7250014",
"0.7202939",
"0.6998537",
"0.6994459",
"0.6985205",
"0.69818515",
"0.6932892",
"0.6892059",
"0.688799",
"0.6879037",
"0.6791216",
"0.67908436",
"0.67772293",
"0.6705519",
"0.6654876"... | 0.77440226 | 2 |
This function simply calculates the epsilon effective for a list of emissivities while the other one is a normal wall it returns a list of effective epsilons | def epsilonEffectiveVectorialOtherOneNormalWall(ListOfEpsilons):
epsilon2= 0.9
ListOFEffectiveEpsilons= []
for anyEpsilon in ListOfEpsilons:
result=1/(1/anyEpsilon+1/epsilon2-1)
ListOFEffectiveEpsilons.append(result)
return ListOFEffectiveEpsilons | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def run_epsilon(env, num_of_bandits, iterations, episodes):\n\n # Initialize total mean rewards array per episode by zero\n epsilon_rewards = np.zeros(iterations)\n\n for i in range(episodes):\n print(f\"Running Epsilon episode:{i}\")\n\n n = 1\n action_count_per_bandit = np.ones(num_... | [
"0.63106453",
"0.60338986",
"0.5957807",
"0.59423536",
"0.59085244",
"0.5789438",
"0.5741385",
"0.5716987",
"0.5681946",
"0.5657834",
"0.5606077",
"0.55730236",
"0.5513506",
"0.5452497",
"0.5435057",
"0.54325557",
"0.54113334",
"0.54066813",
"0.5396189",
"0.5393934",
"0.53853... | 0.7452661 | 0 |
Define and evaluate the limit state functions that may be computationally expensive | def lsf_multimodal_function(theta):
y_out = -((theta[:, 0] ** 2 + 4) * (theta[:, 1] - 1) / 20 - np.sin(5 * theta[:, 0] / 2) - 2)
return y_out.reshape(y_out.shape[0], -1) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def getPolicy(self, state):\n \"\"\"Description:\n Find all of q-values of current state, and choose the action \n with the hight q-value as optimal policy\n \"\"\"\n \"\"\" YOUR CODE HERE \"\"\"\n legalActions = self.getLegalActions(state)\n action = None\n policy = util.Counter() # us... | [
"0.60537744",
"0.5802507",
"0.57057804",
"0.570512",
"0.5688094",
"0.5668728",
"0.56588054",
"0.5634615",
"0.5567792",
"0.55573106",
"0.5543706",
"0.5541091",
"0.5526567",
"0.55199945",
"0.5508761",
"0.55018425",
"0.5476276",
"0.5455228",
"0.5455228",
"0.5450378",
"0.5447722"... | 0.0 | -1 |
An STL Formula is initialized with a robustness function, which is commonly specified using a Predicate. More complex formulas are determined by logical operations like conjuction and disjunction (see other methods in this class). | def __init__(self, robustness):
self.robustness = robustness | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def negation(self):\n new_robustness = lambda s, t : - self.robustness(s,t)\n new_formula = STLFormula(new_robustness)\n\n return new_formula",
"def always(self, t1, t2):\n new_robustness = lambda s, t : min([ self.robustness(s,k) for k in range(t+t1, t+t2+1)])\n\n new_formula ... | [
"0.6757594",
"0.6180851",
"0.5799073",
"0.5723463",
"0.55895317",
"0.5459583",
"0.54238963",
"0.5402407",
"0.5294606",
"0.523891",
"0.5227728",
"0.51561034",
"0.5148659",
"0.50738364",
"0.5040158",
"0.50378716",
"0.5034396",
"0.5031577",
"0.50058746",
"0.5001457",
"0.4999761"... | 0.54243535 | 6 |
Return a new STL Formula object which represents the negation of this one. The robustness degree is given by rho(s,phi,t) = rho(s,phi,t) | def negation(self):
new_robustness = lambda s, t : - self.robustness(s,t)
new_formula = STLFormula(new_robustness)
return new_formula | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def negated(self):\n ops = {Eq: Ne, Ge: Lt, Gt: Le, Le: Gt, Lt: Ge, Ne: Eq}\n # If there ever will be new Relational subclasses, the following line\n # will work until it is properly sorted out\n # return ops.get(self.func, lambda a, b, evaluate=False: ~(self.func(a,\n # b, ... | [
"0.63784575",
"0.60499424",
"0.6047615",
"0.6025719",
"0.5980413",
"0.59710944",
"0.5950272",
"0.5905911",
"0.5871128",
"0.5808477",
"0.57869494",
"0.57742417",
"0.57666385",
"0.5696955",
"0.56903917",
"0.5639218",
"0.5592459",
"0.55629545",
"0.55408806",
"0.552846",
"0.55211... | 0.85079247 | 0 |
Return a new STL Formula object which represents the conjuction of | def conjunction(self, second_formula):
new_robustness = lambda s, t : min( self.robustness(s,t),
second_formula.robustness(s,t) )
new_formula = STLFormula(new_robustness)
return new_formula | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def formula(self):\n terms = []\n for ff in self.formulae:\n terms += list(ff.terms)\n return Formula(terms)",
"def test4():\r\n xmlstr = u\"\"\"\r\n<math xmlns=\"http://www.w3.org/1998/Math/MathML\">\r\n <mstyle displaystyle=\"true\">\r\n <mn>1</mn>\r\n <mo>+</mo>\r\n ... | [
"0.6481127",
"0.6069892",
"0.6016193",
"0.60097945",
"0.59924656",
"0.59799284",
"0.5961672",
"0.59534395",
"0.59182185",
"0.5858698",
"0.58271897",
"0.58195424",
"0.5794693",
"0.57394606",
"0.5685279",
"0.5664971",
"0.56265134",
"0.5540472",
"0.5539249",
"0.5527984",
"0.5519... | 0.557829 | 17 |
Return a new STL Formula object which represents the disjunction of | def disjunction(self, second_formula):
new_robustness = lambda s, t : max( self.robustness(s,t),
second_formula.robustness(s,t) )
new_formula = STLFormula(new_robustness)
return new_formula | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def to_not_and_or(formula: Formula) -> Formula:\r\n # Task 3.5\r\n\r\n map_operators = {'->': Formula.parse('(~p|q)'),\r\n '+': Formula.parse('((p&~q)|(~p&q))'),\r\n '<->': Formula.parse('~((p&~q)|(~p&q))'),\r\n '-&': Formula.parse('~(p&q)'),\r\n ... | [
"0.6928513",
"0.64927626",
"0.64809364",
"0.63076943",
"0.6272961",
"0.62019426",
"0.6155834",
"0.61348367",
"0.6078864",
"0.6068255",
"0.60622615",
"0.6024921",
"0.6003905",
"0.59905654",
"0.59699976",
"0.59579724",
"0.59041035",
"0.5857507",
"0.5839025",
"0.5812397",
"0.580... | 0.6939579 | 0 |
Return a new STL Formula object which represents this formula holding at some point in [t+t1, t+t2]. rho(s, F_[t1,t2](phi), t) = max_{k in [t+t1,t+t2]}( rho(s,phi,k) ) | def eventually(self, t1, t2):
new_robustness = lambda s, t : max([ self.robustness(s,k) for k in range(t+t1, t+t2+1)])
new_formula = STLFormula(new_robustness)
return new_formula | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def always(self, t1, t2):\n new_robustness = lambda s, t : min([ self.robustness(s,k) for k in range(t+t1, t+t2+1)])\n\n new_formula = STLFormula(new_robustness)\n\n return new_formula",
"def disjunction(self, second_formula):\n new_robustness = lambda s, t : max( self.robustness(s,t)... | [
"0.60814774",
"0.5594397",
"0.5511437",
"0.5436593",
"0.54058003",
"0.53587633",
"0.53587633",
"0.5265794",
"0.5249713",
"0.52059805",
"0.52044696",
"0.5127763",
"0.5115574",
"0.5098548",
"0.5070726",
"0.50691354",
"0.5043683",
"0.49980867",
"0.49883643",
"0.49751607",
"0.497... | 0.65423965 | 0 |
Return a new STL Formula object which represents this formula holding at all times in [t+t1, t+t2]. rho(s, F_[t1,t2](phi), t) = min_{k in [t+t1,t+t2]}( rho(s,phi,k) ) | def always(self, t1, t2):
new_robustness = lambda s, t : min([ self.robustness(s,k) for k in range(t+t1, t+t2+1)])
new_formula = STLFormula(new_robustness)
return new_formula | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def eventually(self, t1, t2):\n new_robustness = lambda s, t : max([ self.robustness(s,k) for k in range(t+t1, t+t2+1)])\n\n new_formula = STLFormula(new_robustness)\n\n return new_formula",
"def conjunction(self, second_formula):\n new_robustness = lambda s, t : min( self.robustness(... | [
"0.6225095",
"0.5380109",
"0.52846324",
"0.5268822",
"0.5250239",
"0.507966",
"0.5078371",
"0.5048716",
"0.5048716",
"0.5045929",
"0.50276214",
"0.501732",
"0.49967548",
"0.4975366",
"0.49715793",
"0.49676615",
"0.4959879",
"0.49277917",
"0.49169645",
"0.49146962",
"0.4910409... | 0.6450866 | 0 |
data_id The data_id that will be attached to the records produced. course_fields speed_fields heading_fields wind_dir_fields wind_speed_fields Commaseparated lists of field names from which we should take values for course, speed over ground, heading, relative wind speed and relative wind direction. update_on_fields If... | def __init__(self, data_id, course_fields, speed_fields, heading_fields,
wind_dir_fields, wind_speed_fields,
update_on_fields=None,
zero_line_reference=0,
convert_wind_factor=1,
convert_speed_factor=1,
output_nmea=False):
supe... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def processData(self,data):\n #print 'I GOT DATA',data,[0],data[1]\n # Check for valid data (not null or empty string)\n #print '**************NOTIFICATION***************',type(_RobotCommunicator.WALL_HEADER),type(data[0])\n if data:\n #print '**************NOTIFICATION******... | [
"0.53975344",
"0.52873915",
"0.50456554",
"0.50301075",
"0.49908647",
"0.49831617",
"0.48950723",
"0.47512385",
"0.47308448",
"0.4730168",
"0.47279853",
"0.47256327",
"0.47077668",
"0.46848103",
"0.46756554",
"0.46603763",
"0.46585894",
"0.46537262",
"0.46511868",
"0.46418202",... | 0.69498223 | 0 |
Incorporate any useable fields in this record, and if it gives us a new true wind value, return it. | def transform(self, record):
if not record:
return None
if not type(record) is DASRecord:
logging.warning('Improper format record: %s',record)
return None
update = False
for field_name in record.fields:
if field_name in self.course_fields:
self.course_val = record.field... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def wind_meta(self):\n return self.data.wind_meta",
"def wind(self):\n return self._wind",
"def _get_wred(self):\n return self.__wred",
"def _get_wred(self):\n return self.__wred",
"def _get_wred(self):\n return self.__wred",
"def calc_generation_wind_proposed (self):\n if s... | [
"0.5335317",
"0.52828914",
"0.52291673",
"0.52291673",
"0.52291673",
"0.51694596",
"0.49782172",
"0.49209738",
"0.49078652",
"0.48731014",
"0.48608252",
"0.48421362",
"0.48118705",
"0.4774674",
"0.47562644",
"0.47545525",
"0.4751787",
"0.4737342",
"0.47335005",
"0.472048",
"0... | 0.6221449 | 0 |
retrieves a dictionary representation of a Student instance | def to_json(self, attrs=None):
if type(attrs) is list:
my_dict = {}
for i in attrs:
if i in self.__dict__:
my_dict[i] = self.__dict__[i]
return(my_dict)
return(self.__dict__) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_to_dict_creates_dict(self):\n user = User()\n user_details = {\"student_id\": user.id, \"first_name\": \"Joe\"}\n u = Student(**user_details)\n new_d = u.to_dict()\n self.assertEqual(type(new_d), dict)\n self.assertFalse(\"_sa_instance_state\" in new_d)\n f... | [
"0.6967492",
"0.6854172",
"0.68230337",
"0.68190545",
"0.6693714",
"0.65850425",
"0.64653426",
"0.6447594",
"0.63673645",
"0.6365533",
"0.6316791",
"0.6198606",
"0.6174732",
"0.6135114",
"0.6131578",
"0.61182433",
"0.61072487",
"0.6086442",
"0.608156",
"0.60479915",
"0.601603... | 0.0 | -1 |
Initialise empty list to store movie objects. | def __init__(self):
self.movies = [] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __init__(self):\n self.movie_reviews = []",
"def __init__(self, movie_list, handler):\n self = self\n self.movie_list = movie_list\n self.handler = handler",
"def movies(self) -> List[Movie]:\n return super(MoviesManager, self).items",
"def __init__(self):\n self... | [
"0.65290993",
"0.64381063",
"0.6387146",
"0.6362394",
"0.6308672",
"0.62854606",
"0.6260135",
"0.61852294",
"0.6150018",
"0.60788643",
"0.60733324",
"0.60368407",
"0.60368407",
"0.603464",
"0.6025904",
"0.60086554",
"0.5979831",
"0.59669375",
"0.5956342",
"0.5935932",
"0.5929... | 0.7599408 | 0 |
Return a string representation of movie_collection. | def __str__(self):
return str([str(movie) for movie in self.movies]) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __str__(self):\n if len(self.movies) == 1:\n return \"[ %s\" % ( self.movies.head )\n else:\n i, l, s = 0, len(self.movies), \"\"\n ch = chr(201)\n for movie in self.movies:\n s += \"%s %s\" % ( ch, movie )\n i += 1\n ... | [
"0.6659319",
"0.6628551",
"0.62493557",
"0.60645914",
"0.58099663",
"0.57829535",
"0.5771873",
"0.5735844",
"0.5735844",
"0.5711104",
"0.5698495",
"0.56329626",
"0.5529546",
"0.5506747",
"0.5498773",
"0.54663736",
"0.54648674",
"0.5462892",
"0.5462892",
"0.5462892",
"0.546289... | 0.7336832 | 0 |
Add a movie to the list of movies. | def add_movie(self, movie):
self.movies.append(movie) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def add(self, movie):\n self.movies.append(movie)",
"def insert(self, movie):\n self._currentMovie = self.movies.add(movie)\n self._updateMovieList = True",
"def add_movie(self, movie_id, title, syn, actorsList):\n if movie_id in self.movies:\n \t\treturn False\n \tfor actor_i... | [
"0.8900799",
"0.8045397",
"0.7768572",
"0.76284903",
"0.7500664",
"0.7352316",
"0.7212312",
"0.7136348",
"0.7030553",
"0.6866704",
"0.6758157",
"0.66564816",
"0.65935546",
"0.6266042",
"0.6245702",
"0.6196159",
"0.6195921",
"0.6169882",
"0.6088118",
"0.6033789",
"0.60107416",... | 0.8978601 | 0 |
Returns number of movies unwatched. | def get_number_un_watched(self):
movies_un_watched = 0
for movie in self.movies:
if not movie.is_watched:
movies_un_watched += 1
return movies_un_watched | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_number_watched(self):\n movies_watched = 0\n for movie in self.movies:\n if movie.is_watched:\n movies_watched += 1\n return movies_watched",
"def get_number_of_movies(self):\n raise NotImplementedError",
"def unseen_count_for(self, user):\r\n ... | [
"0.7755944",
"0.6540844",
"0.61782014",
"0.6130556",
"0.6059607",
"0.57578415",
"0.57013404",
"0.569084",
"0.567021",
"0.56334585",
"0.55824435",
"0.5575674",
"0.55153644",
"0.5513155",
"0.5429644",
"0.5418207",
"0.5391372",
"0.5387409",
"0.5384734",
"0.5315951",
"0.5298279",... | 0.90050864 | 0 |
Returns number of movies watched. | def get_number_watched(self):
movies_watched = 0
for movie in self.movies:
if movie.is_watched:
movies_watched += 1
return movies_watched | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_number_of_movies(self):\n raise NotImplementedError",
"def get_number_un_watched(self):\n movies_un_watched = 0\n for movie in self.movies:\n if not movie.is_watched:\n movies_un_watched += 1\n return movies_un_watched",
"def tot_movies():\n ... | [
"0.79504406",
"0.78356934",
"0.684265",
"0.6501998",
"0.6493687",
"0.64376444",
"0.64284354",
"0.6427606",
"0.63701856",
"0.63086224",
"0.6142869",
"0.61026233",
"0.6084461",
"0.60532176",
"0.6037645",
"0.58779836",
"0.5861516",
"0.5820638",
"0.5809127",
"0.5804819",
"0.58046... | 0.88137585 | 0 |
Read the file containing movies saving as a list. | def load_movies(self, file_name):
in_file = open('{}'.format(file_name), 'r')
for line in in_file:
line_str = line.strip().split(',')
# Create movie instance and convert year to an integer
movie = Movie(line_str[INDEX_OF_TITLE], int(line_str[INDEX_OF_YEAR]), line_str... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def read_movies(filename):\n movies = []\n # TODO: Read the file correctly and instantiate movie objects to store them\n # inside the movies list.\n return movies",
"def loadMovieList():\n # Read the fixed movieulary list\n fid = open('movie.txt', 'r', encoding='UTF-8')\n ls = fid.readlines(... | [
"0.8445153",
"0.7818126",
"0.7173876",
"0.71036965",
"0.69080424",
"0.68292606",
"0.6827025",
"0.67422503",
"0.66594076",
"0.66577935",
"0.6559717",
"0.6392808",
"0.6307358",
"0.6306428",
"0.62772185",
"0.6257083",
"0.62313277",
"0.6198048",
"0.61694336",
"0.6110801",
"0.6096... | 0.7236775 | 2 |
Save movies to file. | def save_movies(self, filename):
out_file = open('{}'.format(filename), 'w')
for movie in self.movies:
out_file.write("{}\n".format(movie))
out_file.close() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def save_csv(outfile, movies):\n fieldnames = ['title', 'rating', 'year', 'actors', 'runtime']\n with open('movies.csv', 'w') as outfile:\n writer = csv.DictWriter(outfile, fieldnames=fieldnames)\n writer.writeheader()\n for line in movies:\n writer.writerow(line)\n\n\n # A... | [
"0.72095114",
"0.71403253",
"0.68307644",
"0.6719887",
"0.67072356",
"0.6481229",
"0.64616996",
"0.6323915",
"0.6316662",
"0.6286281",
"0.6236424",
"0.62208205",
"0.61929744",
"0.6184691",
"0.61743426",
"0.60964686",
"0.6085657",
"0.60776585",
"0.6068898",
"0.6067825",
"0.606... | 0.8231782 | 0 |
Sort objects by keyword attribute. | def sort_movies(self, keyword):
self.movies.sort(key=attrgetter(keyword, "title")) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def sortby(self):\n ...",
"def keysort(*args, **kwargs): # real signature unknown\n pass",
"def sort(self, field='word', order=None):\n self.data = list(self.sorted(field, order))",
"def sort_key(self):\n ...",
"def sort_books(self):\n self.foods = sorted(self.foods, key=attr... | [
"0.6517557",
"0.62519825",
"0.621693",
"0.618207",
"0.61291474",
"0.60603756",
"0.5968144",
"0.591704",
"0.58679897",
"0.58125305",
"0.57413775",
"0.5737953",
"0.5718942",
"0.5710644",
"0.5701423",
"0.5689594",
"0.5621519",
"0.5617988",
"0.5601959",
"0.5600666",
"0.5600666",
... | 0.7797052 | 0 |
Return longest movie title length. | def calculate_longest_title(self):
longest_title_length = 0
for movie in self.movies:
title_length = len(movie.title)
if title_length > longest_title_length:
longest_title_length = title_length
return longest_title_length | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def longest_word_length(words):",
"def display_count_longest_title():\n longest_title = reports.count_longest_title(filename)\n print(\n \"The longest title in {} has a {} characters\\n\".format(\n filename,\n longest_title))",
"def get_movie_longest_runtime(movies: list) -> ... | [
"0.77722895",
"0.7590663",
"0.7366647",
"0.7108653",
"0.7067252",
"0.6978308",
"0.69709504",
"0.68817616",
"0.683693",
"0.6814063",
"0.66816366",
"0.66371953",
"0.6625562",
"0.66211367",
"0.66208327",
"0.6615058",
"0.6594465",
"0.6562419",
"0.6558994",
"0.6544149",
"0.6536397... | 0.8994632 | 0 |
Sort movies by year and prints formatted table labeling unwatched with . | def list_movies(self, longest_title_length):
for i, movie in enumerate(self.movies):
unwatched_string = ' '
if not movie.is_watched:
unwatched_string = '*'
print("{:2}. {} {:{}} - {:5} ({})".format(i, unwatched_string, movie.title, longest_title_length,
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def yr_fewest_movies():\n copy = movies.copy()\n year = copy.sort_values(['Number of Movies', 'Year']).reset_index(drop = True).Year.loc[0]\n return ('yr_fewest_movies', year)",
"def main():\n movies = read_movies('bond.csv')\n\n print('Original list (first 10):')\n print_movies(mov... | [
"0.6516226",
"0.6265513",
"0.6254855",
"0.6015417",
"0.59726846",
"0.59625655",
"0.57363737",
"0.5729767",
"0.5654759",
"0.56210405",
"0.5605649",
"0.5573096",
"0.5542348",
"0.55401593",
"0.54924494",
"0.5470789",
"0.5466671",
"0.54481035",
"0.54068506",
"0.54062355",
"0.5404... | 0.623919 | 3 |
Set movie at specified index watched if not already. | def set_movie_watched(self, movie_index):
if self.movies[movie_index].is_watched:
print("You have already watched {}".format(self.movies[movie_index].title))
else:
self.movies[movie_index].watch_movie()
print("{} from {} watched".format(self.movies[movie_index].title,... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def set_target_movie(self, movie_title):\n self.target_movie = self.db.query(Movie).filter_by(\n title=movie_title).first()",
"def setMovie(self, movie):\n if movie != None:\n self.titleText.set(movie.title)\n if isinstance(movie.director, types.StringTypes):\n ... | [
"0.5464972",
"0.53104514",
"0.5152905",
"0.5102784",
"0.50916296",
"0.5083048",
"0.50648904",
"0.50172126",
"0.49893054",
"0.4985861",
"0.49777514",
"0.49769378",
"0.4974608",
"0.49403375",
"0.49258924",
"0.49239987",
"0.4907317",
"0.4899596",
"0.489666",
"0.48950246",
"0.489... | 0.7617139 | 0 |
Set is_watched to 'w' or 'u' ready for saving so that it matched sample output. | def bool_to_status(self):
for movie in self.movies:
if movie.is_watched:
movie.is_watched = WATCHED
else:
movie.is_watched = UNWATCHED | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def set_movie_watched(self, movie_index):\n if self.movies[movie_index].is_watched:\n print(\"You have already watched {}\".format(self.movies[movie_index].title))\n else:\n self.movies[movie_index].watch_movie()\n print(\"{} from {} watched\".format(self.movies[movie... | [
"0.5912901",
"0.555388",
"0.51608515",
"0.506256",
"0.50503856",
"0.5013928",
"0.5003339",
"0.4994564",
"0.49897543",
"0.49845046",
"0.49726027",
"0.49247593",
"0.48908532",
"0.48908532",
"0.4881085",
"0.4878073",
"0.48633444",
"0.48521966",
"0.48514238",
"0.48476604",
"0.482... | 0.5689392 | 1 |
Browse for .sm files | def BuildStack(self):
try:
dialog = wx.DirDialog(None, "Choose a directory",
style=wx.DD_DIR_MUST_EXIST|wx.DD_CHANGE_DIR)
#dialog.SetWildcard(wildcard)
if dialog.ShowModal() == wx.ID_OK:
directory = dialog.GetPath()
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def OpenSoundFiles():\n\n wildcard = create_wildcard(\"Sound files\", sppas.src.audiodata.aio.extensionsul)\n wildcard += '|' + create_wildcard(\"All files\", ['*', '*.*'])\n\n files = list()\n dlg = wx.FileDialog(None, \n \"Select sound file(s)\", \n paths... | [
"0.5978283",
"0.58677226",
"0.58519614",
"0.5773267",
"0.57463515",
"0.5632323",
"0.5517103",
"0.5515584",
"0.55132335",
"0.5501415",
"0.54622257",
"0.5433972",
"0.5403349",
"0.53323007",
"0.5332251",
"0.5292054",
"0.5290622",
"0.5265916",
"0.5265916",
"0.5256516",
"0.5248227... | 0.0 | -1 |
Browse for .hdf5 file | def SaveStackH5(self):
try:
wildcard = "HDF5 files (*.hdf5)|*.hdf5"
dialog = wx.FileDialog(None, "Save as .hdf5", wildcard=wildcard,
style=wx.SAVE|wx.OVERWRITE_PROMPT)
if dialog.ShowModal() == wx.ID_OK:
filepath = dialog.... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def onBrowse_imp1(self, event):\n data_folder = \"\"\n self.m_textCtrl_input_model_path1.Clear()\n\n dlg = wx.FileDialog(self, \"Open a file:\", wildcard=\"hdf5 files (*.h5)|*.h5\",\n style=wx.FD_OPEN | wx.FD_FILE_MUST_EXIST)\n default_path = self.m_textCtrl_i... | [
"0.6836094",
"0.6743301",
"0.6585112",
"0.6546339",
"0.6539629",
"0.6506283",
"0.6453404",
"0.6368453",
"0.6287706",
"0.61447805",
"0.6013481",
"0.5968393",
"0.59644145",
"0.5950732",
"0.5905181",
"0.5824385",
"0.58210135",
"0.58210135",
"0.5788737",
"0.5786438",
"0.577736",
... | 0.60527533 | 10 |
Browse for .hdf5 file | def SaveResultsToH5(self):
try:
wildcard = "HDF5 files (*.hdf5)|*.hdf5"
dialog = wx.FileDialog(None, "Save as .hdf5", wildcard=wildcard,
style=wx.SAVE|wx.OVERWRITE_PROMPT)
if dialog.ShowModal() == wx.ID_OK:
filepath = dia... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def onBrowse_imp1(self, event):\n data_folder = \"\"\n self.m_textCtrl_input_model_path1.Clear()\n\n dlg = wx.FileDialog(self, \"Open a file:\", wildcard=\"hdf5 files (*.h5)|*.h5\",\n style=wx.FD_OPEN | wx.FD_FILE_MUST_EXIST)\n default_path = self.m_textCtrl_i... | [
"0.6836139",
"0.6741686",
"0.65854824",
"0.65471804",
"0.6537863",
"0.6507506",
"0.6452145",
"0.6367841",
"0.6143151",
"0.6052056",
"0.60112906",
"0.59678173",
"0.5963143",
"0.5948905",
"0.5905889",
"0.5825003",
"0.58213663",
"0.58213663",
"0.5788032",
"0.5785552",
"0.5780011... | 0.6287379 | 8 |
Generate the dataset's data if it does not exist. | def generate_data(self):
self.remove_hdf5_file()
hdf5_handler = self.create_hdf5_file()
self.populate_hdf5_file(hdf5_handler, self.dataset) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def build_data_set(self):\n if not self.assert_data_correct():\n self.download_all_data()\n self.unpack_rename_data()\n self.split_data_characters()\n self.clean_data_fragments()\n self.create_font_data()\n if not self.assert_train_augmented():\n... | [
"0.69200563",
"0.67951465",
"0.6723771",
"0.6610489",
"0.6583298",
"0.65758735",
"0.65656567",
"0.6530771",
"0.64458627",
"0.64342827",
"0.6404715",
"0.6372979",
"0.63223845",
"0.62426066",
"0.62412035",
"0.6232917",
"0.6224932",
"0.6188829",
"0.6183252",
"0.6165206",
"0.6160... | 0.7456934 | 0 |
Generate the test dataset and store it to disk. | def generate_dataset(self):
sets = {
"train": 10,
"test": 5,
}
fields = {
"strings_list": lambda x: str_to_ascii(self.generate_string_list(x)),
"data": lambda x: np.random.randint(0, 10, (x, 10)),
"number": lambda x: np.array(range(x))... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def generateDataset(self):\n if self.outdir[-1] != \"/\": \n self.outdir += \"/\"\n self.outdir += \"dataset_trackml\"\n i = 1\n while os.path.exists(self.outdir):\n self.outdir.replace(\"_\"+str(i-1), \"\")\n self.outdir += (\"_\"+str(i))\n i... | [
"0.7327681",
"0.7252",
"0.72127897",
"0.71530336",
"0.70798606",
"0.6980536",
"0.697719",
"0.6964925",
"0.6962602",
"0.6940431",
"0.6919756",
"0.6919424",
"0.68703735",
"0.6856671",
"0.684216",
"0.68320286",
"0.6830385",
"0.6785239",
"0.67756003",
"0.669554",
"0.6651334",
"... | 0.66815734 | 20 |
Generate a list of strings. | def generate_string_list(self, n):
template_str = 'string_'
string_list = [template_str + str(i) for i in range(n)]
return string_list | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def generate_string_list(char_list, length):\n return [e for e in generate_strings(char_list, length)]",
"def generate_str(self, num):\n str_list = []\n for _ in range(num):\n str_list.append(self.fake.pystr())\n return str_list",
"def generate_strings(char_list, length):\n ... | [
"0.78389084",
"0.7442578",
"0.72651327",
"0.7240272",
"0.7009902",
"0.6672038",
"0.6522357",
"0.65052104",
"0.64621574",
"0.6427473",
"0.64225364",
"0.6373771",
"0.6346114",
"0.6333544",
"0.6331938",
"0.63198966",
"0.6306335",
"0.62754685",
"0.6215374",
"0.6160407",
"0.615534... | 0.777014 | 1 |
Load data for testing the FieldLoader class. | def get_test_data_FieldLoader(self, set_name='train', field='data'):
path = "/{set_name}/{field}".format(set_name=set_name, field=field)
field_loader = self.load_hdf5_file_FieldLoader(path)
set_data = self.dataset[set_name]
return field_loader, set_data | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def load_data(self) -> None:",
"def load_data(self):",
"def test_dataloader(self) -> DataLoader:\n return self._custom_data_loader()",
"def load_data(self):\n raise NotImplementedError()",
"def load_data(self, data):\n self.data = data\n self.validate()",
"def setUp(self):\n ... | [
"0.7236644",
"0.7104567",
"0.7077611",
"0.67128515",
"0.6609189",
"0.6563617",
"0.6536698",
"0.6475042",
"0.6435233",
"0.6316149",
"0.6312232",
"0.6294654",
"0.6196114",
"0.61840767",
"0.61840767",
"0.6171941",
"0.61452377",
"0.6128587",
"0.6126146",
"0.6096968",
"0.6084923",... | 0.7161606 | 1 |
Return a dataset for testing the FieldLoader class. | def get_test_dataset_SetLoader(self, set_name='train'):
set_loader = self.load_hdf5_file_SetLoader(set_name)
set_data = self.dataset[set_name]
set_fields = self.data_fields[set_name]
return set_loader, set_data, set_fields | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_test_dataset_DataLoader(self):\n test_info = self.get_test_DataLoader_info()\n name = test_info[\"name\"]\n task = test_info[\"task\"]\n data_dir = test_info[\"data_dir\"]\n hdf5_file = test_info[\"hdf5_file\"]\n\n data_loader = DataLoader(name, task, data_dir, hdf... | [
"0.78888327",
"0.7603223",
"0.73044086",
"0.72188866",
"0.7082152",
"0.7069775",
"0.69244474",
"0.6873793",
"0.6871499",
"0.68013656",
"0.6789716",
"0.6701403",
"0.67012626",
"0.66969347",
"0.65904266",
"0.6579232",
"0.6568345",
"0.65629375",
"0.6548726",
"0.65372163",
"0.652... | 0.6751672 | 11 |
Return a dataset for testing the FieldLoader class. | def get_test_dataset_DataLoader(self):
test_info = self.get_test_DataLoader_info()
name = test_info["name"]
task = test_info["task"]
data_dir = test_info["data_dir"]
hdf5_file = test_info["hdf5_file"]
data_loader = DataLoader(name, task, data_dir, hdf5_file)
ret... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_test_data_FieldLoader(self, set_name='train', field='data'):\n path = \"/{set_name}/{field}\".format(set_name=set_name, field=field)\n field_loader = self.load_hdf5_file_FieldLoader(path)\n set_data = self.dataset[set_name]\n return field_loader, set_data",
"def test_dataloade... | [
"0.76030594",
"0.73050845",
"0.7218909",
"0.70823777",
"0.707011",
"0.6923885",
"0.6874425",
"0.68715763",
"0.680077",
"0.67888016",
"0.6751399",
"0.670098",
"0.67003936",
"0.66979426",
"0.6590271",
"0.6578667",
"0.65673375",
"0.6562923",
"0.6548202",
"0.65370923",
"0.6524199... | 0.7889583 | 0 |
Get the expected values of an object index from the test dataset. | def get_expected_object_values(set_data, fields, idx):
assert set_data
assert fields
assert idx is not None
if isinstance(idx, int):
expected = get_single_object_values(set_data, fields, idx)
else:
expected = []
for i in idx:
expected.append(get_single_object_val... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_get_dimensions_by_index(self):\n\n dimensions, dim_names = pyjstat.get_dimensions(\n self.oecd_datasets['oecd'], 'index')\n self.assertTrue(dim_names[2] == 'year')\n self.assertTrue(dimensions[0].iloc[0]['index'] == 0)",
"def get_test_index(self):\n return self.tes... | [
"0.6085354",
"0.59751713",
"0.58467215",
"0.5743093",
"0.56780034",
"0.5677077",
"0.5662826",
"0.5632936",
"0.5603338",
"0.5561478",
"0.55502975",
"0.55169076",
"0.55166215",
"0.54973763",
"0.549305",
"0.5478096",
"0.5470087",
"0.54686487",
"0.54338706",
"0.5414726",
"0.53993... | 0.71672696 | 0 |
Sending request to server to go north. | def north(self):
self.send("north")
msg = self.recv()
return [msg.get(0), msg.get(1), msg.get(2)] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _send_request(self):\n route_chosen = self.comboBox_route_list.currentText()\n route_id = route_chosen.split(',')[0] #to get the id of the route\n trip_headsign_chosen = self.comboBox_trip_headsign_list.currentText()\n stop_chosen = self.comboBox_stop_list.currentText()\n sel... | [
"0.68568325",
"0.60774213",
"0.5888379",
"0.5861923",
"0.58271545",
"0.58136475",
"0.5812446",
"0.5806612",
"0.57657135",
"0.5717081",
"0.5715121",
"0.57071674",
"0.5697722",
"0.5621315",
"0.5606508",
"0.5528312",
"0.55264795",
"0.54878163",
"0.54593533",
"0.5439747",
"0.5436... | 0.5340307 | 28 |
Sending request to server to go south. | def south(self):
self.send("south")
msg = self.recv()
return [msg.get(0), msg.get(1), msg.get(2)] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _send_request(self):\n route_chosen = self.comboBox_route_list.currentText()\n route_id = route_chosen.split(',')[0] #to get the id of the route\n trip_headsign_chosen = self.comboBox_trip_headsign_list.currentText()\n stop_chosen = self.comboBox_stop_list.currentText()\n sel... | [
"0.600601",
"0.5746862",
"0.5328608",
"0.5302231",
"0.5262662",
"0.523163",
"0.5223088",
"0.52230334",
"0.5204523",
"0.51989526",
"0.51729643",
"0.5167329",
"0.51483107",
"0.5123291",
"0.50991184",
"0.50874394",
"0.5070086",
"0.5035433",
"0.50285786",
"0.50116074",
"0.4985136... | 0.52593195 | 5 |
Sending request to server to go east. | def east(self):
self.send("east")
msg = self.recv()
return [msg.get(0), msg.get(1), msg.get(2)] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _send_request(self):\n route_chosen = self.comboBox_route_list.currentText()\n route_id = route_chosen.split(',')[0] #to get the id of the route\n trip_headsign_chosen = self.comboBox_trip_headsign_list.currentText()\n stop_chosen = self.comboBox_stop_list.currentText()\n sel... | [
"0.6274922",
"0.5875293",
"0.5605408",
"0.5532936",
"0.54392785",
"0.535141",
"0.5335515",
"0.53249854",
"0.53071964",
"0.52963245",
"0.52826065",
"0.52774185",
"0.5245262",
"0.5241447",
"0.52274114",
"0.5207281",
"0.5201629",
"0.5138268",
"0.5125515",
"0.510253",
"0.5096249"... | 0.55065286 | 4 |
Sending request to server to go west. | def west(self):
self.send("west")
msg = self.recv()
return [msg.get(0), msg.get(1), msg.get(2)] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _send_request(self):\n route_chosen = self.comboBox_route_list.currentText()\n route_id = route_chosen.split(',')[0] #to get the id of the route\n trip_headsign_chosen = self.comboBox_trip_headsign_list.currentText()\n stop_chosen = self.comboBox_stop_list.currentText()\n sel... | [
"0.6707941",
"0.62575036",
"0.60849",
"0.5973586",
"0.5947263",
"0.59331524",
"0.5829443",
"0.57833195",
"0.57456744",
"0.571326",
"0.570843",
"0.56466776",
"0.5621991",
"0.562119",
"0.5541215",
"0.5491085",
"0.5484851",
"0.5437864",
"0.5435183",
"0.5387633",
"0.5369891",
"... | 0.5426729 | 19 |
Sending request to server to look around. Recieves status of adjacent tiles from server. | def look(self):
self.send("look")
msg = self.recv()
msg_tokens = []
tiles = []
for i in range(msg.size()):
msg_tokens.append(msg.get(i))
for tok in msg_tokens:
tiles.append(tok.split("|"))
return tiles | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def update_status(request):\n raw_data = request.raw_post_data\n logging.info(\"isrproxy update_status: %s\" % raw_data)\n\n update_status_data = simplejson.loads(raw_data)\n\n # redirect update to dev server in production environment\n if update_status_data.get('Operator_ID') == WB_DEV_OPERATOR_ID ... | [
"0.5576414",
"0.5564557",
"0.55327535",
"0.54753107",
"0.5401497",
"0.5369825",
"0.52473956",
"0.5235013",
"0.52159554",
"0.5207385",
"0.5200553",
"0.5155084",
"0.5091361",
"0.507583",
"0.50586957",
"0.505842",
"0.5037245",
"0.5036804",
"0.50064236",
"0.49962437",
"0.49942917... | 0.0 | -1 |
Sending request to disarm an adjacent trap. | def disarm(self, direction):
self.send("disarm " + direction)
msg = self.recv()
return msg.get(0) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def disassociation_from_ap(self):\n # send disassociation\n self.ap1.tx_msdu(da=self.host.macaddr, body=wifi.disassociation(), \n fctl=wifi.fctl_disassociation)\n \n # expect a deauth frame\n mpdu = self.ap1.rx_mpdu(wifi.AIR_MGMT)\n \n # sanity ch... | [
"0.5579351",
"0.55666995",
"0.53452766",
"0.531071",
"0.5253965",
"0.52062815",
"0.5178076",
"0.51533264",
"0.5106116",
"0.50844777",
"0.5076529",
"0.5076529",
"0.5076118",
"0.5061429",
"0.5057326",
"0.5043118",
"0.5009013",
"0.4985737",
"0.49818358",
"0.49659583",
"0.4953678... | 0.6480957 | 0 |
Sends the given operation to the server. | def send(self, op):
tokens = op.split()
msg = message()
for token in tokens:
msg.add(token)
self.pb.send(msg) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def do_operation(self):\n operation = self.inputs['operation']\n res = self.entity.do_operation(self.context, **self.inputs)\n if res:\n return self.RES_OK, \"Node operation '%s' succeeded.\" % operation\n else:\n return self.RES_ERROR, \"Node operation '%s' failed... | [
"0.65273005",
"0.65004045",
"0.6436639",
"0.6344679",
"0.62421525",
"0.61538506",
"0.6068884",
"0.6068392",
"0.6000146",
"0.5946958",
"0.5913439",
"0.5902766",
"0.58820164",
"0.58820164",
"0.5862677",
"0.5844414",
"0.5798752",
"0.5796108",
"0.5752205",
"0.5738845",
"0.5728808... | 0.6920459 | 0 |
Recieves a response from the server. | def recv(self):
msg = self.pb.recv()
if msg.get(0) == "timeout":
print "You failed to find Toby before the time ran out!"
self.cleanup()
elif msg.get(0) == "toby":
print "You found Toby. Good job!"
self.cleanup()
elif msg.get(0) == "dead":
print "You died!"
self.cleanup()
return msg | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def receive_response(self):\n return self.socket.receive()",
"def get_response(command):\n connection = get_client()\n\n connection.send(command)\n\n data = connection.recv()\n connection.close()\n\n return data",
"async def recv(self):\n return await self.receptor.response_queue.g... | [
"0.7011037",
"0.6589897",
"0.6541744",
"0.65120596",
"0.6485724",
"0.64145404",
"0.636809",
"0.6295736",
"0.6292598",
"0.62294203",
"0.6223843",
"0.62168163",
"0.6214169",
"0.6213474",
"0.61884505",
"0.616017",
"0.609996",
"0.6066863",
"0.6066863",
"0.6059501",
"0.6054074",
... | 0.0 | -1 |
Close connections and notify server that session is over. | def cleanup(self):
self.pb.cleanup()
sys.exit() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def server_close(self):\n\t\tpass",
"def handle_close(self):\n LOGGER.debug(\"server closed\")\n self.clear()\n data = {}\n self.update_notify_state(data, STAGE_SERVER_UNCONNECTED)\n self.close()\n\n # close all and restart\n asyncore.close_all()",
"def close_co... | [
"0.7452282",
"0.73618275",
"0.72769415",
"0.7209967",
"0.717841",
"0.71199244",
"0.71067214",
"0.7071134",
"0.7059105",
"0.70334625",
"0.7006491",
"0.7002468",
"0.6992781",
"0.6979551",
"0.6966999",
"0.6948275",
"0.6938148",
"0.69095916",
"0.690229",
"0.69008005",
"0.68724394... | 0.0 | -1 |
Scheduler a model defined in OpenAPI | def __init__(self, type=None, metadata=None): # noqa: E501
self.openapi_types = {"type": str, "metadata": Metadata}
self.attribute_map = {"type": "type", "metadata": "metadata"}
self._type = type
self._metadata = metadata | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def from_dict(cls, dikt) -> \"Scheduler\":\n return util.deserialize_model(dikt, cls)",
"def dynamic_import_scheduler(module):\n model_class = dynamic_import(module, SCHEDULER_DICT)\n assert issubclass(\n model_class, SchedulerInterface\n ), f\"{module} does not implement SchedulerInterfac... | [
"0.56897783",
"0.5681567",
"0.5592761",
"0.54756105",
"0.54454046",
"0.54212445",
"0.5406241",
"0.53492516",
"0.5316051",
"0.5295895",
"0.5273675",
"0.5245985",
"0.52314985",
"0.5217647",
"0.5206941",
"0.52057344",
"0.51626253",
"0.5124587",
"0.512223",
"0.51163745",
"0.51105... | 0.0 | -1 |
Returns the dict as a model | def from_dict(cls, dikt) -> "Scheduler":
return util.deserialize_model(dikt, cls) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def from_dict(cls, dikt) -> 'ModelClass':\n return util.deserialize_model(dikt, cls)",
"def to_dict_model(self) -> dict:\n return dict((key, getattr(self, key)) for key in self.__mapper__.c.keys())",
"def from_dict(cls, dikt):\n return util.deserialize_model(dikt, cls)",
"def from_dict(cls, ... | [
"0.6939894",
"0.68444926",
"0.67725724",
"0.67725724",
"0.67725724",
"0.67725724",
"0.67725724",
"0.67725724",
"0.6739522",
"0.6698291",
"0.6698291",
"0.66464084",
"0.66383654",
"0.66022646",
"0.660082",
"0.65999925",
"0.6593835",
"0.6580194",
"0.65621036",
"0.64150435",
"0.6... | 0.0 | -1 |
Gets the type of this Scheduler. | def type(self):
return self._type | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def schedule_type(self):\n return self._schedule_type",
"def get_type(self):\n return self._TYPE",
"def get_type (self):\n return self._stype",
"def get_type(self):\n return self._type",
"def get_type(self):\n return self._type",
"def get_type(self):\n return sel... | [
"0.8195117",
"0.71118546",
"0.71044254",
"0.70377827",
"0.70377827",
"0.7005059",
"0.698471",
"0.6981658",
"0.6981658",
"0.6939486",
"0.69035137",
"0.6889826",
"0.68877524",
"0.68441236",
"0.6835996",
"0.6827982",
"0.6810675",
"0.68067247",
"0.6794449",
"0.67832",
"0.6767924"... | 0.69478595 | 27 |
Sets the type of this Scheduler. | def type(self, type):
if type is None:
raise ValueError("Invalid value for `type`, must not be `None`") # noqa: E501
self._type = type | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def schedule_type(self, schedule_type):\n\n self._schedule_type = schedule_type",
"def schedule_type(self, schedule_type):\n\n self._schedule_type = schedule_type",
"def set_type(self, type):\n self.type = type",
"def set_type(self, type):\n self.type = type",
"def set_type(self... | [
"0.80057335",
"0.80057335",
"0.75507337",
"0.75507337",
"0.7483278",
"0.7115609",
"0.7019111",
"0.70181847",
"0.69953287",
"0.6979536",
"0.6979536",
"0.695165",
"0.695165",
"0.69398105",
"0.69398105",
"0.69398105",
"0.69398105",
"0.69398105",
"0.69398105",
"0.69398105",
"0.69... | 0.6880235 | 43 |
Gets the metadata of this Scheduler. | def metadata(self):
return self._metadata | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_metadata(self):\n return self.manager.get_metadata(self)",
"def get_metadata(self):\n return self._metadata",
"def metadata(self):\n return self.meta.metadata",
"def metadata(self):\r\n return self._metadata",
"def get(self):\n return self._metadata",
"def get_s... | [
"0.71406114",
"0.70414925",
"0.6984677",
"0.6975013",
"0.69092923",
"0.6902686",
"0.6902265",
"0.6890652",
"0.68209904",
"0.6809682",
"0.6779367",
"0.6746391",
"0.6677705",
"0.6677705",
"0.6659976",
"0.664664",
"0.664664",
"0.66246855",
"0.6524459",
"0.6507235",
"0.6486973",
... | 0.7021962 | 6 |
Sets the metadata of this Scheduler. | def metadata(self, metadata):
self._metadata = metadata | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def set_metadata(self, metadata):\n return self.manager.set_metadata(self, metadata)",
"def set_metadata(self, metadata):\n return self.manager.set_metadata(self, metadata)",
"def set_metadata(self, metadata):\n self.metadata = metadata\n return self",
"def metadata(self, metadata... | [
"0.7284354",
"0.7284354",
"0.72251797",
"0.6924326",
"0.6924326",
"0.6912875",
"0.65728146",
"0.65576124",
"0.6509923",
"0.64945316",
"0.63769543",
"0.63764304",
"0.6335112",
"0.6334947",
"0.63345087",
"0.63050437",
"0.6295306",
"0.6257091",
"0.6245504",
"0.6149908",
"0.61499... | 0.7268934 | 8 |
Simple animation of the wave advecting ... | def animate(x,y,title=None,step=None,pause=0.001):
plt.clf()
if step is not None and title is not None:
plt.title("%s (Step %d)" %(title,step))
plt.plot(x,y)
plt.draw()
plt.pause(pause)
plt.show(block=False) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def animatevelocity(j):\n i = j/v_intervals\n uanim.set_data(x, u[j])\n massanim.set_data(t[:j], mass[:j])\n vanim.set_data(v_times[:i], velocity[:i])\n ampanim.set_data(t[:j], amplitudes[:j])\n #txt1.set_text(\"j = %s\" %j)\n if j > stop1:\n wave1.set_data(x, u[stop1])\n if j > stop... | [
"0.63495135",
"0.6196701",
"0.61764556",
"0.6165962",
"0.6140859",
"0.604862",
"0.588793",
"0.5788353",
"0.5768238",
"0.57620364",
"0.57617486",
"0.5733577",
"0.5728057",
"0.5728057",
"0.57244307",
"0.5708346",
"0.57071495",
"0.5693935",
"0.5686925",
"0.56790626",
"0.565908",... | 0.5371441 | 50 |
Shift perfectly, no calculations of y; just y(n) > y((n+1)%L) (basically a rotateright) ... just for reference | def perfect_shift(y):
return np.append([y[-1]],y[0:-1]) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def shift(image,shift_x,shift_y):\n return np.roll(np.roll(image,shift_y,axis=0),shift_x,axis=1)",
"def lrshift(val, n) -> np.int64:\n return (val % (1 << 64)) >> n",
"def _shift(self, s):\n start_pos = self._relative_head_pos()\n l = 1 + 2 * self.shift_length\n shift = int(s * l - 0... | [
"0.67403364",
"0.6632031",
"0.6628545",
"0.6394657",
"0.61860895",
"0.61860895",
"0.61860895",
"0.61860895",
"0.6110119",
"0.606753",
"0.59852594",
"0.59837425",
"0.5971836",
"0.5950179",
"0.5943645",
"0.5943645",
"0.58661544",
"0.5860182",
"0.5842202",
"0.58294725",
"0.58097... | 0.6870793 | 0 |
Advance 1 step using Forwardtime, Centeredspace | def ftcs(_x,_y,_cs,_dx,_dt):
#todo: in a loop ... think about a more pythonic way to do this
# s = _cs * _dt / (2. * _dx)
# next_y = np.zeros(np.shape(_y)) #next time step
# nLen = len(_y)
# for n in range(nLen):
# n_next = (n + 1) if n < (nLen-1) else 0
# n_prev = (n - 1) if n > 0 ... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def advance(self): \n self.center.x = self.center.x + self.velocity.dx\n self.center.y = self.center.y + self.velocity.dy",
"def Advance():\n warp.step()",
"def step_forward(self):",
"def _forward_kinematics_step(self, t_step):\n (s_1, s_12, s_123) = self._sines\n (c_1, c_12... | [
"0.6634304",
"0.6587821",
"0.6553405",
"0.625148",
"0.62141305",
"0.6194353",
"0.6151987",
"0.61328804",
"0.6068492",
"0.60640913",
"0.60591906",
"0.6024224",
"0.60145533",
"0.598659",
"0.59727436",
"0.59276134",
"0.59168255",
"0.59158915",
"0.5887274",
"0.5885864",
"0.584553... | 0.0 | -1 |
Advance 1 step using Lax | def lax(_x,_y,_cs,_dx,_dt):
s = _cs * _dt / (2. * _dx)
next_y = 0.5 *(np.append(_y[1:], _y[0]) + np.append(_y[-1], _y[:-1])) \
- s * (np.append(_y[1:], _y[0]) - np.append(_y[-1], _y[:-1]))
return next_y | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _advance(self):\t\t# override inherited version\n self._current *= self._base",
"def _advance(self):\n self._current += 1",
"def step_forward(self):",
"def forward(self, x):\n return self.l1(x)",
"def _advance(self):\n self._prev, self._current = self._current, self._prev + ... | [
"0.65308684",
"0.64072937",
"0.6387594",
"0.6321694",
"0.631977",
"0.6288484",
"0.61668223",
"0.6070409",
"0.6040912",
"0.6014779",
"0.59810954",
"0.5952722",
"0.59403884",
"0.58998656",
"0.58883333",
"0.58578897",
"0.58270264",
"0.5812622",
"0.58045393",
"0.5791352",
"0.5787... | 0.0 | -1 |
Advance 1 step using LaxWendroff | def lax_wen(_x,_y,_cs,_dx,_dt):
s = _cs * _dt / (2. * _dx)
s2 = (_cs**2.) * (_dt**2.) / (2. * (_dx**2.))
next_y = _y[:] - s*(np.append(_y[1:], _y[0]) - np.append(_y[-1], _y[:-1])) \
+ s2*(np.append(_y[1:], _y[0]) + np.append(_y[-1], _y[:-1]) - 2*_y[:])
return next_y | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _advance(self):\n self._current += 1",
"def _advance(self):\t\t# override inherited version\n self._current *= self._base",
"def _advance(self):\n self._prev, self._current = self._current, self._prev + self._current",
"def step_forward(self):",
"def step1ab(self):\n\t\tif self.b[s... | [
"0.6488334",
"0.6316092",
"0.6051661",
"0.6036867",
"0.6003655",
"0.5999034",
"0.59847456",
"0.59441745",
"0.5922006",
"0.58752036",
"0.5836568",
"0.58160806",
"0.5786469",
"0.5781549",
"0.5757453",
"0.57362497",
"0.5721856",
"0.5717035",
"0.5706227",
"0.5685344",
"0.56851834... | 0.0 | -1 |
Fills the template of python configuration file for datacard preparation | def createCfg_prep_dcard(self, jobOptions):
category_output = self.channel
if jobOptions['label']:
category_output += "_%s" % jobOptions['label']
lines = []
lines.append("process.fwliteInput.fileNames = cms.vstring('%s')" % jobOptions['inputFile'])
lines.append("process.fwliteOutput.fileName... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def generate_config(container_data, file_path):\n pass",
"def _init_config(self):\n self.config = self.config_template.specialize()\n print('MMH CONFIG:\\n' + str(self.config))",
"def config():\n file_path = None # path to the input file\n db_path = None # path to the output db\n ... | [
"0.67815447",
"0.66767985",
"0.65957564",
"0.6537106",
"0.6500459",
"0.6379473",
"0.6368642",
"0.6317948",
"0.6295786",
"0.6284518",
"0.62698406",
"0.6262515",
"0.6262515",
"0.6257156",
"0.62318164",
"0.62216794",
"0.62152416",
"0.62152135",
"0.6213334",
"0.6205779",
"0.62026... | 0.6349458 | 7 |
I'm the a property. | def a(self):
return self._a | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def property( self, prop ):\n raise NotImplementedError(\"property\")",
"def property(self, p_int): # real signature unknown; restored from __doc__\n pass",
"def _property(attr):\n name = '_' + attr\n @property\n def prop(self):\n \"\"\"Get the specific attribute.\"\"\"\n r... | [
"0.7833885",
"0.7020226",
"0.6798755",
"0.6784938",
"0.67531514",
"0.6735335",
"0.672958",
"0.672958",
"0.672958",
"0.6631659",
"0.66263175",
"0.658225",
"0.64780694",
"0.6433763",
"0.6425462",
"0.6395595",
"0.6384428",
"0.6369832",
"0.63278943",
"0.6311077",
"0.62527674",
... | 0.0 | -1 |
I'm the e property. | def e(self):
return self._e | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_E(self):\r\n return self.E",
"def e(self, e):\n\n self._e = e",
"def get_E(self):\n return self.E",
"def E(self):\n return self._properties['E']",
"def E(self):\n return self._E",
"def E(self):\n return self._E",
"def ehandle(self):\n return self._eh... | [
"0.74820995",
"0.7460332",
"0.73928255",
"0.72371143",
"0.71522623",
"0.71522623",
"0.6508572",
"0.6490028",
"0.6425671",
"0.6375467",
"0.6284834",
"0.6227812",
"0.6227812",
"0.62267196",
"0.6221513",
"0.6193148",
"0.60434306",
"0.5989004",
"0.5946854",
"0.5887836",
"0.584394... | 0.8164787 | 0 |
I'm the inc property. | def inc(self):
return self._inc | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def inc(self):\n self._value += 1",
"def increment(self):\r\n return self.add(1)",
"def increment(self) -> global___Expression:",
"def increment_counter(self) -> None:",
"def _modifyProperty(self,dec):\n pass",
"def incr_operand(self):\n pass",
"def get_inc(self):\n retur... | [
"0.69979954",
"0.6902046",
"0.6662313",
"0.66253597",
"0.6607319",
"0.6580319",
"0.65539956",
"0.65401846",
"0.65195906",
"0.6515084",
"0.6501719",
"0.63391596",
"0.63147354",
"0.6312719",
"0.6285045",
"0.6224541",
"0.6216525",
"0.6214255",
"0.62074393",
"0.6182061",
"0.61629... | 0.77464503 | 0 |
I'm the Om property. | def Om(self):
return self._Om | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def om(self):\n return self._om",
"def moi(self):\n\n pass",
"def get_o(self):\n return self.o",
"def property(self, p_int): # real signature unknown; restored from __doc__\n pass",
"def _showProperty(self):\n pass",
"def property( self, prop ):\n raise NotImplem... | [
"0.7130849",
"0.60610646",
"0.59436876",
"0.59310603",
"0.5916612",
"0.58097064",
"0.5673482",
"0.5673482",
"0.5673482",
"0.54857105",
"0.54576874",
"0.5444633",
"0.54392326",
"0.5419425",
"0.53296006",
"0.5305579",
"0.5263575",
"0.52366114",
"0.52342314",
"0.5233221",
"0.520... | 0.7669906 | 0 |
I'm the om property. | def om(self):
return self._om | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def Om(self):\n return self._Om",
"def moi(self):\n\n pass",
"def property( self, prop ):\n raise NotImplementedError(\"property\")",
"def get_o(self):\n return self.o",
"def property(self, p_int): # real signature unknown; restored from __doc__\n pass",
"def properties... | [
"0.7034278",
"0.63692933",
"0.6175412",
"0.61665934",
"0.61052203",
"0.591592",
"0.591592",
"0.591592",
"0.59120154",
"0.58743906",
"0.58643997",
"0.5859979",
"0.5732439",
"0.56568724",
"0.559987",
"0.5554393",
"0.5553714",
"0.55381227",
"0.54483944",
"0.5425846",
"0.54186624... | 0.7430322 | 0 |
I'm the H property. | def H(self):
return self._H | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def h(self) -> float:\n return self._h",
"def h(self): # pylint: disable=invalid-name\n return self._h",
"def is_H(self):\n return True",
"def is_H(self):\n return True",
"def h(self):\n return self._h",
"def update_H(self):",
"def get_h0(self, t):\n return se... | [
"0.73934793",
"0.71388894",
"0.710541",
"0.710541",
"0.6980057",
"0.6904231",
"0.6783644",
"0.6776315",
"0.674058",
"0.6728726",
"0.6598538",
"0.6571018",
"0.65669626",
"0.6494272",
"0.6486298",
"0.6455249",
"0.642911",
"0.6422516",
"0.6390683",
"0.63494384",
"0.6303365",
"... | 0.78022635 | 0 |
I'm the epoch property. | def epoch(self):
return self._epoch | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def epoch(self):\n return _coordsys.coordsys_epoch(self)",
"def set_epoch(self, epoch):\r\n pass",
"def epoch():\n\treturn time.time()",
"def epoch():\n return datetime2epoch(datetime.now())",
"def GetEpoch(self):\n return _gmat_py.Attitude_GetEpoch(self)",
"def cur_epoch(self):\n... | [
"0.7948318",
"0.7636237",
"0.7558367",
"0.75083977",
"0.7421768",
"0.7372495",
"0.7297328",
"0.7210528",
"0.70881516",
"0.6936589",
"0.6905358",
"0.68977195",
"0.6741958",
"0.66929716",
"0.66661257",
"0.666138",
"0.66086245",
"0.6600611",
"0.6585031",
"0.65276086",
"0.6485145... | 0.83609456 | 0 |
I'm the epoch_M property. | def epoch_M(self):
return self._epoch_M | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def epoch(self):\n return self._epoch",
"def set_epoch(self, epoch):\r\n pass",
"def epoch(self):\n return _coordsys.coordsys_epoch(self)",
"def GetEpoch(self):\n return _gmat_py.Attitude_GetEpoch(self)",
"def epoch():\n\treturn time.time()",
"def epoch_detail(self):\n ... | [
"0.74173445",
"0.6983966",
"0.69142866",
"0.6853805",
"0.659223",
"0.6501514",
"0.6478274",
"0.62859935",
"0.62701535",
"0.62441427",
"0.62349266",
"0.6152219",
"0.60909456",
"0.5969186",
"0.5957573",
"0.5929347",
"0.5902148",
"0.58972347",
"0.586194",
"0.58306897",
"0.581658... | 0.8976243 | 0 |
I'm the M property. | def M(self):
return self._M | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def M(self):\n return self._properties['M']",
"def getM(self):\r\n return self.M",
"def moi(self):\n\n pass",
"def get_m1(self):\n\n pass",
"def M(self) -> int:\n return self.params.M",
"def Mxy(self):\n return self.Mx.My",
"def get_M(self):\n return 1.0... | [
"0.79089844",
"0.74489814",
"0.6702801",
"0.6698779",
"0.65353805",
"0.63709855",
"0.63307273",
"0.62976044",
"0.62114793",
"0.6201829",
"0.6127184",
"0.61061794",
"0.60908824",
"0.60109353",
"0.5946789",
"0.5889533",
"0.5845052",
"0.5767508",
"0.5726675",
"0.5717197",
"0.570... | 0.706804 | 2 |
Print the current orbital parameters a, e, inc, argperi, capom, H | def __str__(self):
status = ("\na: %.2f \n" % self.a +
"e: %.2f \n" % self.e +
"inc: %.2f deg \n" % (self.inc * 180/math.pi) +
"om: %.2f deg \n" % (self.om * 180/math.pi) +
"Om: %.2f deg \n" % (self.Om * 180/math.pi) +
"H:... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def show_parameters(self):\n with np.printoptions(precision=3, suppress=True):\n print('number of wind phase = {}'.format(self.ncomp))\n print('galactic parameter = {}'.format(self.scaling_field))\n print('reference height = {}'.format(self.z0))\n for p in ['cool_... | [
"0.701719",
"0.69558907",
"0.6840527",
"0.62526584",
"0.6218964",
"0.6205169",
"0.6191117",
"0.61182123",
"0.6115266",
"0.6083515",
"0.6077989",
"0.60738575",
"0.6051088",
"0.60151744",
"0.600268",
"0.5972984",
"0.59588736",
"0.59405583",
"0.5915042",
"0.5900441",
"0.58979195... | 0.0 | -1 |
Compute and assign and Hmagnitude from a socalled singlE powerlaw, knee, or divot Hmagnitude distribution. When provided a slope alpha and a faintside maximum Hmagnitude (hmax), a Hmagnitude is drawn randomly from the distribution dN/dH propto 10(alpha H) in the range hmin = 1 to hmax. Specify hmin to change the bright... | def drawH(self, alpha, hmax, alpha_faint=None, contrast=1, hbreak=None,
hmin=1):
# Avoid singularity for alpha = 0
alpha = 0.0000000001 if alpha == 0 else alpha
# Set alpha_faint to alpha for the case of a single power-law
alpha_faint = alpha if alpha_faint is None else al... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_height_fwhm_calculation(peakdata):\n # mu = 0\n # variance = 1.0\n # sigma = np.sqrt(variance)\n # x = np.linspace(mu - 20*sigma, mu + 20*sigma, 100.0)\n # y = norm.pdf(x, mu, 1)\n x = peakdata[0]\n y = peakdata[1]\n check_height_fwhm(x, y, lineshapes.voigt, models.VoigtModel())\n ... | [
"0.57013035",
"0.561052",
"0.5579129",
"0.55207247",
"0.548725",
"0.54475385",
"0.537149",
"0.5325857",
"0.5278528",
"0.5268215",
"0.52665937",
"0.52601075",
"0.5251945",
"0.52324474",
"0.5193713",
"0.5178757",
"0.5177294",
"0.51746935",
"0.5156782",
"0.51521426",
"0.51354307... | 0.761445 | 0 |
Perturb (fuzz) semimajor axis randomly by up to + percent specified Input is treated as percentage if type is not specified as 'abs'. If type = 'abs', a will be changed randomly by + amount specified. The first argument is a string containing the variable to be fuzzed. The appropriate options are 'a', 'e', 'inc', 'Om',... | def fuzz(self, variable, fz, type=None):
# Check to see if the attribute exists, if so get the value
if not hasattr(self, variable):
raise ValueError("You tried to fuzz a parameter that does not exit")
var = getattr(self, variable)
# if variable is an angle, treat it properly... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def defuzzification(self):\n self.price = fuzz.defuzz(self.psf,self.fuzzy_output, 'som')",
"def main():\r\n _evaluative_test(5)\r\n _fuzz_test(1)\r\n _fuzz_test(1, 512)\r\n _fuzz_test(1, 1512)\r\n _fuzz_test(1000)\r\n _fuzz_test(1000, 512)\r\n _fuzz_test(1000, 4077)",
"def fuzz():\n... | [
"0.5732995",
"0.55186677",
"0.5119221",
"0.50102854",
"0.49203992",
"0.48581415",
"0.4821607",
"0.48188433",
"0.47911242",
"0.4722664",
"0.4682123",
"0.4677746",
"0.4645468",
"0.46381727",
"0.4637192",
"0.46334326",
"0.45095548",
"0.450736",
"0.44810542",
"0.44614375",
"0.442... | 0.73384976 | 0 |
Determines smallest number divisible by all numbers 1 to x. | def smallestMultiple(x):
ans = 1
for prime in xprime(x):
ans *= prime**int(log(x, prime))
return ans | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def smallest_number_divisible(n):\n\tprime_numbers = generate_prime_less_than_n(n)\n\tlog_n = math.log(n)\n\tres = 1\n\tfor pi in prime_numbers:\n\t\tres *= math.pow(pi, math.floor(log_n/math.log(pi)))\n\treturn res",
"def finddiv(x):\r\n \r\n div = (1, x)\r\n for i in range(2, x//2+1):\r\n if x%... | [
"0.76617324",
"0.74890375",
"0.708696",
"0.70112544",
"0.6964907",
"0.69107777",
"0.6902035",
"0.68590194",
"0.68404037",
"0.683988",
"0.67654645",
"0.6758752",
"0.6721042",
"0.67108655",
"0.66632086",
"0.65752566",
"0.65006626",
"0.64714175",
"0.64620346",
"0.64505184",
"0.6... | 0.7994635 | 0 |
Modify a python object that supports the buffer interface internally. This is useful for testing things like socket.recv_into() dest_buffer must be smaller than source_buffer, or the code will assert. | def modify_buffer_object(source_buffer, dest_buffer, nbytes=None):
assert len(source_buffer) <= len(dest_buffer)
copy_len = len(source_buffer) if nbytes is None else min(nbytes, source_buffer)
buffer_ptr = (ctypes.c_byte * len(dest_buffer)).from_buffer(dest_buffer)
new_value_ptr = (ctypes.c_byte * len(s... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _tobuffer(self, object_):\n\n raise NotImplementedError",
"def use_buffer(self, buffer_size):\n self.__buffer_size = buffer_size\n if self.__buffer is None:\n self.__buffer = []",
"def swap_buffers(self):\n raise NotImplementedError()",
"def _read_into_buffer(self):... | [
"0.71334606",
"0.632377",
"0.62844825",
"0.6151401",
"0.61270875",
"0.61198306",
"0.61197627",
"0.602732",
"0.594199",
"0.5892748",
"0.5892748",
"0.5892748",
"0.5828508",
"0.5773723",
"0.5754132",
"0.5739361",
"0.5726852",
"0.5726852",
"0.5720015",
"0.571318",
"0.568297",
"... | 0.78256 | 0 |
Await a condition function to return True, otherwise raise an AssertionError if the condition did not return True within the alloted time. | def await_condition(description, condition_eval_callable, on_failure=lambda: True, timeout=10, poll_s=0.1):
start_time = time.time()
def should_continue():
return time.time() - start_time < timeout
while not condition_eval_callable():
if not should_continue():
on_failure()
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def await_condition(condition, timeout=2000):\n\n for _ in range(timeout):\n if condition():\n return True\n time.sleep(0.001)\n return False",
"def until_true(condition, timeout, error_msg):\n timeout = timestr_to_secs(timeout)\n max_wait = time.time() + timeout\n ... | [
"0.7560678",
"0.72292703",
"0.7114256",
"0.7015878",
"0.69801235",
"0.69610274",
"0.6899991",
"0.6843958",
"0.6793191",
"0.6574894",
"0.6491553",
"0.64850456",
"0.6315587",
"0.6235223",
"0.61285186",
"0.6070208",
"0.6060411",
"0.60604",
"0.6031214",
"0.6023985",
"0.6023985",
... | 0.7275414 | 1 |
Return the density of states in a 1D array (according to get_frequencies()) | def get_dos(self):
return self.get_array('dos') | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def density(self):\r\n return self.count_ones() / float(self.xspan * self.yspan)",
"def density(self):\n return self.nnz/self.dim",
"def counts_to_density(\n x: Union[_cpp.DataArray, _cpp.Dataset], dim: str\n) -> Union[_cpp.DataArray, _cpp.Dataset]:\n return _call_cpp_func(_cpp.counts_to_densit... | [
"0.67306876",
"0.6545734",
"0.652916",
"0.6466963",
"0.64478296",
"0.63397855",
"0.63013804",
"0.6270028",
"0.614507",
"0.60950315",
"0.60252184",
"0.5969756",
"0.59521574",
"0.592468",
"0.59091216",
"0.58831763",
"0.5864672",
"0.58550507",
"0.58550507",
"0.58550507",
"0.5813... | 0.0 | -1 |
Return the number of atoms (equivalent to the dimension of partial density of states) | def get_number_of_partial_dos(self, full=False):
partial_dos = self.get_array('partial_dos')
if full:
return len(partial_dos)
return len(partial_dos[self._get_equivalent_atom_list()]) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def numAtoms(self):\n return self.nAtoms",
"def size(self):\r\n return len(atoms)",
"def get_number_of_atoms_to_optimize(self):\n v = self.c.get(simulation_cell=True)\n return len(v.data.stoichiometry)",
"def natoms(self):\n return len(self.atoms)",
"def num_atoms(self):\... | [
"0.7615236",
"0.7479874",
"0.7446102",
"0.7385822",
"0.73555297",
"0.7247755",
"0.7196846",
"0.71780443",
"0.7173893",
"0.7165874",
"0.7159424",
"0.71553284",
"0.7118576",
"0.7118576",
"0.70925087",
"0.7039619",
"0.70308644",
"0.70176536",
"0.6989161",
"0.6988811",
"0.6936567... | 0.0 | -1 |
Return the partial density of states | def get_partial_dos(self, full=False):
partial_dos = self.get_array('partial_dos')
if full:
return partial_dos
indices, weights = self._get_equivalent_atom_list(with_weights=True)
partial_dos = [partial * weight for weight, partial in zip(weights, partial_dos[indices])]
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def density(self):\r\n return self.count_ones() / float(self.xspan * self.yspan)",
"def getDensityOfStates(self, Elist):\n\t\treturn _modes.freerotor_densityofstates(Elist, self.frequencies, 1 if self.linear else 0)",
"def getDensityOfStates(self, Elist):\n\t\tpass",
"def getDensityOfStates(self, Elist):\... | [
"0.6990002",
"0.68468076",
"0.6540495",
"0.64641935",
"0.64567894",
"0.6429281",
"0.6427787",
"0.6427787",
"0.6427787",
"0.6426647",
"0.6402431",
"0.6341133",
"0.633433",
"0.6293956",
"0.62743706",
"0.62305063",
"0.61604667",
"0.6110642",
"0.6062941",
"0.6012021",
"0.5964267"... | 0.0 | -1 |
Return the corresponding frequencies to get_dos() and get_partial_dos() | def get_frequencies(self):
return self.get_array('frequencies') | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_frequency(self):\r\n # print '*********in get freq'\r\n self.cntr.run('FREQ 1')\r\n f_0_ = self.cntr.get_measurements(1)\r\n self.f_0 = f_0_[0]\r\n self.cntr.run('FREQ 2')\r\n f_rep_ = self.cntr.get_measurements(1)\r\n self.f_rep = f_rep_[0]",
"def get_cw_... | [
"0.6753553",
"0.6381248",
"0.63641745",
"0.6289217",
"0.6214848",
"0.61800855",
"0.616702",
"0.6142434",
"0.60968804",
"0.6092314",
"0.6045899",
"0.6002879",
"0.59977996",
"0.5992096",
"0.5984933",
"0.59689164",
"0.596595",
"0.5947886",
"0.59470624",
"0.59387994",
"0.59163076... | 0.59397584 | 19 |
Store the atomic symbols as a numpy array. | def get_atom_labels(self, full=False):
import numpy
labels = self.get_attr("atom_labels")
if full:
return labels
return numpy.array(labels)[self._get_equivalent_atom_list()].tolist() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _raw_to_arrays(self):\n self.update_geometry()\n if isinstance(self, Molecule):\n # normal qcdb.Molecule\n geom = self.geometry(np_out=True)\n else:\n # psi4.core.Molecule\n geom = np.array(self.geometry())\n mass = np.asarray([self.mass(a... | [
"0.64369416",
"0.6005739",
"0.5834887",
"0.56393343",
"0.5608841",
"0.5587981",
"0.5584245",
"0.5577252",
"0.55483854",
"0.5543307",
"0.55303025",
"0.54635966",
"0.5408",
"0.5402539",
"0.5385811",
"0.53760046",
"0.53566366",
"0.53395516",
"0.53386134",
"0.53217524",
"0.532157... | 0.0 | -1 |
Store the phonon dos as a numpy array | def set_atom_labels(self, labels):
self.set_attribute("atom_labels", labels) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def save_numpy_array(self):\n np.save(\"smallest_particles.npy\", self.smallest_particles)\n np.save(\"number_counts.npy\", self.number_counts)\n np.save(\"number_counts_2.npy\", self.number_counts_2)",
"def to_array(self, normalize: bool = True) -> jnp.ndarray:\n return NotImplemente... | [
"0.57991946",
"0.5630915",
"0.56130564",
"0.5575848",
"0.5575372",
"0.5550803",
"0.5545238",
"0.5543249",
"0.5534787",
"0.5514769",
"0.54567087",
"0.5446889",
"0.5446504",
"0.5414669",
"0.5401872",
"0.53778",
"0.537432",
"0.53715014",
"0.53292847",
"0.53037775",
"0.5284815",
... | 0.0 | -1 |
Store the phonon dos as a numpy array | def set_dos(self, array):
self.set_array('dos', array) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def save_numpy_array(self):\n np.save(\"smallest_particles.npy\", self.smallest_particles)\n np.save(\"number_counts.npy\", self.number_counts)\n np.save(\"number_counts_2.npy\", self.number_counts_2)",
"def to_array(self, normalize: bool = True) -> jnp.ndarray:\n return NotImplemente... | [
"0.5800146",
"0.5632037",
"0.5612084",
"0.55791765",
"0.5577007",
"0.5552041",
"0.55471516",
"0.5545793",
"0.5535587",
"0.5516911",
"0.5459809",
"0.54493976",
"0.5447765",
"0.5417437",
"0.54042953",
"0.5378878",
"0.5376346",
"0.53732157",
"0.53298765",
"0.5306282",
"0.5282699... | 0.5284786 | 20 |
Store the frequencies as a numpy array | def set_frequencies(self, array):
self.set_array('frequencies', array) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_frequencies(self):\n\n return self.get_array('frequencies')",
"def get_frequency_array(self):\n\t\treturn np.logspace(np.log10(self.converted_range[0]), np.log10(\n\t\t\tself.converted_range[1]), num=129)[:self.maximum_frequency]",
"def as_counts_array(counts):\n if isinstance(counts, (Mappin... | [
"0.74099725",
"0.7206024",
"0.70724887",
"0.70608664",
"0.67623717",
"0.67613375",
"0.6740164",
"0.673538",
"0.673538",
"0.6565815",
"0.65468955",
"0.64563775",
"0.6386303",
"0.63798875",
"0.63664573",
"0.63525856",
"0.63240004",
"0.6315427",
"0.6312897",
"0.62865484",
"0.622... | 0.6563629 | 10 |
Store the partial dos as a numpy array | def set_partial_dos(self, array):
self.set_array('partial_dos', array)
self.set_attribute("n_partial_dos", len(array)) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def to_fits_array(self):\n return self.data",
"def array(self):",
"def make_data(self): \n s = numpy.arange(0.0, 10.0, 0.01)\n s = numpy.reshape(s, (10,10,10))\n s = numpy.transpose(s)\n\n v = numpy.zeros(3000, 'd')\n v[1::3] = 1.0\n v = numpy.reshape(v, ... | [
"0.58784777",
"0.58602244",
"0.56124526",
"0.56086195",
"0.55979156",
"0.55947816",
"0.55429274",
"0.5539849",
"0.55386084",
"0.5537771",
"0.5529546",
"0.5492652",
"0.5482164",
"0.54607034",
"0.541553",
"0.5411863",
"0.541172",
"0.54034406",
"0.54002327",
"0.54000807",
"0.539... | 0.6228336 | 0 |
Returns true if no imaginary modes (shown as negative frequency DOS) | def is_stable(self, tol=1e-6):
import numpy as np
dos = self.get_dos()
freq = self.get_frequencies()
mask_neg = np.ma.masked_less(freq, 0.0).mask
mask_pos = np.ma.masked_greater(freq, 0.0).mask
if mask_neg.any() == False:
return True
if mask_pos.an... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def is_imaginary(self):\r\n return self._real.is_zero()",
"def is_imaginary(self) -> bool:\n return self < 0",
"def is_real(self):\r\n return self._imag.is_zero()",
"def is_isotropic(self):\n return self.fibres is None",
"def is_zero(self):\r\n return self._real.is_zero()... | [
"0.7435767",
"0.7236454",
"0.70290595",
"0.677156",
"0.6736559",
"0.64063257",
"0.64053893",
"0.6321965",
"0.6316691",
"0.6256833",
"0.620375",
"0.615895",
"0.61450577",
"0.6060106",
"0.6021838",
"0.60216886",
"0.59767884",
"0.59512895",
"0.5950726",
"0.594923",
"0.5943724",
... | 0.0 | -1 |
_test_mtr_regression This demo demonstrates how to evaluate a MultiTarget Regressor. The employed dataset is 'scm1d', which is contained in the data folder. | def demo(output_file=None):
stream = RegressionGenerator(n_samples=5000, n_features=20,
n_informative=15, random_state=1,
n_targets=7)
stream.prepare_for_use()
classifier = MultiTargetRegressionHoeffdingTree(leaf_prediction='adaptive')
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def testRegression(self):\n cont_features = [\n tf.contrib.layers.real_valued_column('feature', dimension=4)]\n\n regressor = tf.contrib.learn.DNNRegressor(feature_columns=cont_features,\n hidden_units=[3, 3])\n\n regressor.fit(input_fn=_iris_input_multi... | [
"0.64248",
"0.6264158",
"0.6189551",
"0.61789185",
"0.6148435",
"0.60771984",
"0.60628456",
"0.5992778",
"0.59514636",
"0.59385335",
"0.5908251",
"0.5893649",
"0.5882528",
"0.58807784",
"0.5873406",
"0.5850031",
"0.57582396",
"0.5741631",
"0.5733211",
"0.57257617",
"0.5722824... | 0.5806374 | 16 |
Launch python.exe subprocess which will in turn launch the user's program. | def open(self, cmd, lines, columns, python_exe='python.exe', communicator_py='conque_sole_communicator.py', options={}):
self.lines = lines
self.columns = columns
self.bucket = u('')
# create a shm key
self.shm_key = 'mk' + str(time.time())
# python command
cmd_... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def Run_command_window(argument):\n if os.name == 'posix':\n argument = argument.replace(\".exe\",\"\")\n os.system(argument)\n\n else:\n startupinfo = subprocess.STARTUPINFO()\n startupinfo.dwFlags |= subprocess.STARTF_USESHOWWINDOW\n\n process = subprocess.Popen(argument,... | [
"0.6752562",
"0.6670607",
"0.6139621",
"0.61282873",
"0.6070133",
"0.60197455",
"0.60073906",
"0.60036474",
"0.5989704",
"0.5966463",
"0.58947265",
"0.58886284",
"0.5873769",
"0.58675075",
"0.5839422",
"0.58391964",
"0.5838483",
"0.58278173",
"0.5817032",
"0.58005387",
"0.573... | 0.0 | -1 |
Read a range of console lines from shared memory. Returns a pair of lists containing the console text and console text attributes. | def read(self, start_line, num_lines, timeout=0):
# emulate timeout by sleeping timeout time
if timeout > 0:
read_timeout = float(timeout) / 1000
#logging.debug("sleep " + str(read_timeout) + " seconds")
time.sleep(read_timeout)
output = []
attributes... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"async def read_console(self):\n while self.proc is not None and self.proc.poll() is None:\n line = await self.loop.run_in_executor(None, self.proc.stdout.readline) # Async readline\n # Parse the command output and get the time in epoch format\n match = re.match(r'\\[([0-9]{... | [
"0.60659015",
"0.5939009",
"0.58916974",
"0.57521653",
"0.56490976",
"0.5647062",
"0.564037",
"0.56112045",
"0.5468083",
"0.5451037",
"0.53977436",
"0.5367511",
"0.53567046",
"0.531081",
"0.5267202",
"0.5250136",
"0.52072364",
"0.51704943",
"0.51641566",
"0.51494616",
"0.5137... | 0.60982656 | 0 |
Return a dictionary with current console cursor and scrolling information. | def get_stats(self):
try:
rescroll = self.shm_rescroll.read()
if rescroll != '' and rescroll != None:
logging.debug('cmd found')
logging.debug(str(rescroll))
self.shm_rescroll.clear()
# close down old memory
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def screen_status(self):\n height, width = self.stdscr.getmaxyx()\n i_start = self.y_start * width + self.x_start\n\n return i_start, height, width",
"def get_position():\n return win32api.GetCursorPos()",
"def get_cursor(self):\n k, font, txt = self._cursor, self.font, self.txt\... | [
"0.6328449",
"0.61619335",
"0.6097711",
"0.5976729",
"0.59197915",
"0.5848462",
"0.5822547",
"0.5798608",
"0.5695266",
"0.5680687",
"0.5673493",
"0.5661445",
"0.56608653",
"0.56183183",
"0.55158216",
"0.54739004",
"0.54739004",
"0.54709613",
"0.54708505",
"0.54678154",
"0.546... | 0.0 | -1 |
Write input to shared memory. | def write(self, text):
self.bucket += text
istr = self.shm_input.read()
if istr == '':
logging.debug('input shm is empty, writing')
self.shm_input.write(self.bucket[:500])
self.bucket = self.bucket[500:] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def write_mem(self):\n request = 'commands/writemem'\n return self._post(request)",
"def init_shared_memory(self, mem_key):\n\n self.shm_input = ConqueSoleSharedMemory(CONQUE_SOLE_INPUT_SIZE, 'input', mem_key)\n self.shm_input.create('write')\n self.shm_input.clear()\n\n ... | [
"0.60039324",
"0.5930608",
"0.59300476",
"0.59215933",
"0.5888126",
"0.5880619",
"0.5785169",
"0.57275254",
"0.5707015",
"0.56850415",
"0.56826055",
"0.5598872",
"0.5578339",
"0.5567999",
"0.5565713",
"0.5556433",
"0.5556433",
"0.5539855",
"0.5533115",
"0.5515601",
"0.5509092... | 0.6564761 | 0 |
Write virtual key code to shared memory using proprietary escape sequences. | def write_vk(self, vk_code):
seq = u("\x1b[") + u(str(vk_code)) + u("VK")
self.write(seq) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def sendKeyEventVirtualMachine(self,node,vmid, key):\n post_data = {'key': str(key)}\n data = self.connect('put',\"nodes/%s/qemu/%s/sendkey\" % (node,vmid), post_data)\n return data",
"def write_key():\n key = fernet.Fernet.generate_key()\n keyfile = open(KEY_PATH,'wb')\n keyfile.wr... | [
"0.5687842",
"0.5372233",
"0.53592056",
"0.53062105",
"0.51792115",
"0.5168341",
"0.51523745",
"0.51337457",
"0.51326776",
"0.5097107",
"0.5078062",
"0.5057081",
"0.50533074",
"0.50469446",
"0.50351524",
"0.5021595",
"0.49984193",
"0.49932158",
"0.49932158",
"0.4989421",
"0.4... | 0.70451427 | 0 |
Write idle command to shared memory block, so subprocess controller can hibernate. | def idle(self):
logging.info('writing idle shm')
self.shm_command.write({'cmd': 'idle', 'data': {}}) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def idle():",
"def standby() -> None:",
"def idle(self):\n return",
"def send_cmd(self, cmd):\n logger.info(\"sending cmd %s to fuse\", cmd)\n with open(self.ipc + \".\" + str(threading.current_thread().ident), 'w', 0) as f:\n #with open(self.ipc, 'a+') as f:\n f.write(... | [
"0.644398",
"0.5689538",
"0.55050457",
"0.5367759",
"0.5346736",
"0.532258",
"0.52653563",
"0.52629304",
"0.5259209",
"0.5252185",
"0.52438426",
"0.52135015",
"0.52101225",
"0.51984185",
"0.51957124",
"0.5160946",
"0.51504266",
"0.51238734",
"0.51017064",
"0.509163",
"0.50765... | 0.8227453 | 0 |
Write resume command to shared memory block, so subprocess controller can wake up. | def resume(self):
self.shm_command.write({'cmd': 'resume', 'data': {}}) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def resume(self):\n self.stdin_queue.put(\"resume\")",
"def resume(self):\n\t\treturn Job(SDK.PrlVm_Resume(self.handle)[0])",
"def resume(self):\n\t\tpass",
"def resume(vm='', env=''):\n local( main_dir + '/vagrant/bin/vm.sh resume ' + str(vm) + ' ' + str(env) )",
"def resume(self):\n pass",... | [
"0.62004507",
"0.6185218",
"0.6178511",
"0.61511475",
"0.6130952",
"0.6130952",
"0.6130952",
"0.6088023",
"0.593814",
"0.5913175",
"0.5753355",
"0.57384956",
"0.57384956",
"0.56370336",
"0.561635",
"0.561405",
"0.5585171",
"0.5578812",
"0.55781746",
"0.55668956",
"0.5525529",... | 0.7903206 | 0 |
Shut it all down. | def close(self):
self.shm_command.write({'cmd': 'close', 'data': {}})
time.sleep(0.2) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def shutdown(self):\n\n pass",
"def shutdown(self) -> None:",
"def shutdown(self) -> None:",
"def shutdown(self):\n pass",
"def shutdown(self):\n pass",
"def shutdown(self):\n pass",
"def shutdown(self):",
"def shutdown(self) -> None:\n pass",
"def shutdown(self):... | [
"0.817547",
"0.8154512",
"0.8154512",
"0.81257796",
"0.81257796",
"0.81257796",
"0.8089488",
"0.79877144",
"0.797899",
"0.7859694",
"0.77252233",
"0.77156514",
"0.7689519",
"0.76439804",
"0.7624332",
"0.7596953",
"0.75795174",
"0.7547538",
"0.75161654",
"0.7500131",
"0.747837... | 0.0 | -1 |
Create shared memory objects. | def init_shared_memory(self, mem_key):
self.shm_input = ConqueSoleSharedMemory(CONQUE_SOLE_INPUT_SIZE, 'input', mem_key)
self.shm_input.create('write')
self.shm_input.clear()
self.shm_output = ConqueSoleSharedMemory(CONQUE_SOLE_BUFFER_LENGTH * self.columns, 'output', mem_key, True)
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def create_shared_memory_manager(\n address: typing.Tuple[str, int], authkey: typing.Optional[bytes]\n) -> SharedMemoryManager:\n smm = SharedMemoryManager(address=address, authkey=authkey)\n return smm",
"def __init__(self):\n\t\tself.dataMemory = sysv_ipc.SharedMemory(65)\n\t\tself.statusMemory = sysv... | [
"0.6806886",
"0.6637284",
"0.6420833",
"0.5987398",
"0.5987398",
"0.5987398",
"0.59054685",
"0.5809415",
"0.5729596",
"0.5698809",
"0.5693551",
"0.5631676",
"0.561561",
"0.561286",
"0.56091833",
"0.5602408",
"0.56005305",
"0.5592581",
"0.55451244",
"0.5470646",
"0.5406517",
... | 0.58049566 | 8 |
PID algorithm for anything | def computePID(setpoint,
_input, last_error, prev_time):
kp = 0.5
kd = 5
ki = 0.02
current_time = time.time()
d_time = current_time - prev_time
error = setpoint - _input
#print("error", error)
#error_sum += (error * d_time)
d_error = (error - last_error) / d_... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def ppid(self):",
"def pid(self):",
"def pidGet(self) -> float:\n ...",
"def pidGet(self) -> float:\n ...",
"def inspire_pidstore():",
"def dynamic_pid(self):\n pass",
"def _update_PID(self):\n self.pid = PID(p=self.paramP, i=self.paramI, d=self.paramD, setpoint=self.voltage... | [
"0.71910334",
"0.6614745",
"0.6562891",
"0.6562891",
"0.6499642",
"0.63020134",
"0.616472",
"0.5998051",
"0.59355164",
"0.5924834",
"0.5907015",
"0.5819289",
"0.5810391",
"0.5769309",
"0.5708543",
"0.56778383",
"0.56778383",
"0.5675718",
"0.5638636",
"0.5638505",
"0.55943847"... | 0.5710995 | 14 |
calculates PID for x, y and z | def xyzPID(home_lon, home_lat, home_alt,
lon, lat, alt,
error_sum, last_error_lon, last_error_lat, prev_time):
#x PID
output_lon, last_error_lon, prev_time = calculatePID(home_lon,lon,error_sum, last_error_lon, prev_time)
#y PID
output_lat, last_error_lat, prev_time = calculatePID(... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def elec_p_xyz_loop(x, y, z):\n U = 0.\n\n r = np.sqrt(x**2 + y**2 + z**2)\n x = x/r\n y = y/r\n z = z/r\n\n npts = x.size\n for i in range(npts-1):\n for j in range(i+1, npts):\n dsq = (x[i]-x[j])**2 + (y[i]-y[j])**2 + (z[i]-z[j])**2\n U += 1./np.sqrt(dsq)\n re... | [
"0.6086874",
"0.59364504",
"0.5866037",
"0.5758806",
"0.5704394",
"0.56775993",
"0.5539624",
"0.5480766",
"0.5472652",
"0.544325",
"0.544325",
"0.54417825",
"0.5440501",
"0.54281235",
"0.53789955",
"0.53669405",
"0.5355419",
"0.5350521",
"0.5342179",
"0.53407073",
"0.52950525... | 0.6788774 | 0 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.