0] = ax0[ax0 > 0] * 2\\n if cube.shape[0] > 1:\\n # Scale other axes to be in a useful range for floor divide\\n cube[1:] = cube[1:] * 4\\n # Define the shifts\\n displace = cube[1:].floor() % 2\\n shift = displace[0]\\n # We need an algebra that satisies: 1 * 0 = 0, 1 * 1 = 1, 0 * 1 = 0, 0 * 0 = 1\\n # This is achieved with * = (==)\\n for ax in displace[1:]:\\n shift = shift == ax\\n ax0 += shift\\n cube[1:] -= 2\\n cube *= 2\\n return cube.t()\",\n \"def numpy_to_cube(np_array, similar_cube, dimensions):\\n\\n new_cube = iris.cube.Cube.copy(similar_cube) # copy similar cube\\n\\n # time, lat, lon\\n if dimensions == 3:\\n new_cube.data[:,:,:] = np.nan # convert new cube entries to nan\\n new_cube.data[:,:,:] = np_array # fill with numpy array data\\n\\n # lat, lon\\n elif dimensions == 2:\\n new_cube.data[:,:] = np.nan # convert new cube entries to nan\\n new_cube.data[:,:] = np_array # fill with numpy array data\\n\\n # either time, lat or lon only\\n elif dimensions == 1:\\n new_cube.data[:] = np.nan # convert new cube entries to nan\\n new_cube.data[:] = np_array # fill with numpy array data\\n\\n # return the numpy array, failed to convert to a cube\\n else:\\n print('failed to convert')\\n new_cube = np_array\\n\\n return new_cube\",\n \"def to_pycuber(self) -> pycuber.Cube:\\n self.soft_align_faces()\\n qpos_copy = self.sim.data.qpos.copy()\\n\\n cubies = []\\n\\n for i in range(27):\\n cubelet_meta = self.cubelet_meta_info[i]\\n\\n if cubelet_meta[\\\"type\\\"] == \\\"cubelet\\\":\\n mtx = self._cubelet_rotation_matrix(cubelet_meta, qpos_copy)\\n\\n original_coords = cubelet_meta[\\\"coords\\\"]\\n # current_coords = (mtx @ cubelet_meta['coords'].astype(float)).round().astype(int)\\n\\n cubie_desc = {}\\n\\n for prev_axis, sign in enumerate(original_coords):\\n if sign != 0:\\n vec = mtx[:, prev_axis] * sign\\n new_axis = np.abs(vec).argmax()\\n new_sign = vec[new_axis]\\n\\n color = PYCUBER_REVERSE_COLORS[prev_axis, sign]\\n loc = PYCUBER_REVERSE_LOCATIONS[new_axis, new_sign]\\n\\n cubie_desc[loc] = pycuber.Square(color)\\n\\n if len(cubie_desc) == 3:\\n cubies.append(pycuber.Corner(**cubie_desc))\\n elif len(cubie_desc) == 2:\\n cubies.append(pycuber.Edge(**cubie_desc))\\n if cubelet_meta[\\\"type\\\"] == \\\"driver\\\":\\n original_coords = cubelet_meta[\\\"coords\\\"]\\n axis = np.abs(original_coords).argmax()\\n sign = original_coords[axis]\\n\\n color = PYCUBER_REVERSE_COLORS[axis, sign]\\n loc = PYCUBER_REVERSE_LOCATIONS[axis, sign]\\n\\n cubie_desc = {loc: pycuber.Square(color)}\\n cubies.append(pycuber.Centre(**cubie_desc))\\n\\n return pycuber.Cube(cubies=cubies)\",\n \"def add_cube(self, cube, name, size=None, lbda=None, add_white=False,\\n unit_size=u.arcsec, unit_wave=u.angstrom):\\n if size is None:\\n size = self.default_size\\n unit_size = u.arcsec\\n\\n subcub = cube.subcube(center=(self.dec, self.ra), size=size,\\n unit_center=u.deg, unit_size=unit_size)\\n\\n if add_white:\\n self.images['MUSE_WHITE'] = subcub.mean(axis=0)\\n\\n if lbda is not None:\\n subcub = subcub.select_lambda(lbda[0], lbda_max=lbda[1],\\n unit_wave=unit_wave)\\n\\n self.cubes[name] = subcub\",\n \"def setspectral(self, *args, **kwargs):\\n return _coordsys.coordsys_setspectral(self, *args, **kwargs)\",\n \"def smooth_cube(self, width=3, **kwargs):\\n # Validate input width\\n num_dims = len(self.dimensions)\\n wid_list = [1]*num_dims # NB: a width of 1 results in no smoothing\\n if isinstance(width, (list, tuple)):\\n # Note: we assume the last dim is always wavelength\\n wid_list[0] = width[0]\\n if num_dims > 2:\\n wid_list[1] = width[1]\\n print('Warning: smoothing over the x-axis can yield unexpected'\\n +' results due to the time interval between observations.'\\n +' Use with care.')\\n\\n if len(width) >= num_dims:\\n print('Warning: smoothing over the wavelength axis is not'\\n +' supported. Only widths for the Y & X axes will be used')\\n elif isinstance(width, (int, float, u.Quantity)):\\n wid_list[0] = width # Only smooth along y-axis\\n else:\\n print('Error: invalid width data type. Please input an int, float,'\\n +' or astropy.units.Quantity instance', file=sys.stderr)\\n return None\\n\\n coord_ax = ['y', 'x', 'w']\\n for w in range(len(wid_list)-1):\\n # Parse a astropy.units.Quantity and convert to units of pixels\\n if isinstance(wid_list[w], u.Quantity):\\n if wid_list[w].unit == u.pix:\\n wid_list[w] = wid_list[w].value\\n elif not wid_list[w].unit.physical_type == 'angle':\\n print('Error: invalid width unit. Please input a pixel or'\\n +' angular unit.', file=sys.stderr)\\n return None\\n else:\\n try:\\n # Note: y & x scales are in units of [arcsec]/[pixel]\\n ax_scale = self.meta['pointing'][coord_ax[w]+'_scale']\\n except KeyError:\\n print('Error: missing '+coord_ax[w]+'-axis scale.')\\n return None\\n angular_wid_str = str(wid_list[w])\\n wid_list[w] = wid_list[w].to('arcsec').value / ax_scale\\n print('Note: on the '+coord_ax[w]+'-axis, '+angular_wid_str\\n +' is equivalent to '+str(wid_list[w])+' pixels.')\\n\\n # Round to nearest pixel and add 1 to even values\\n wid_list[w] = int(round(wid_list[w]))\\n if wid_list[w] % 2 == 0:\\n wid_list[w] = wid_list[w] + 1\\n\\n # Create smoothing kernel with normalized weights (i.e. sum to 1)\\n # Note: Using a 2D or 3D kernel allows us to smooth everything at once\\n sm_weights = np.ones(wid_list) / (wid_list[0]*wid_list[1])\\n sm_kernel = CustomKernel(sm_weights)\\n\\n # Calculate smoothed data and uncertainty values\\n sm_data = convolve(self.data, sm_kernel, **kwargs)\\n if self.uncertainty is not None:\\n sm_errs = np.sqrt(convolve(self.uncertainty.array**2,\\n sm_kernel, **kwargs))\\n else:\\n sm_errs = none\\n sm_data_mask = np.logical_or(np.isnan(sm_data), sm_data < 0)\\n\\n # Pack everything up in a new EISCube\\n old_radcal = self.radcal\\n new_meta = copy.deepcopy(self.meta)\\n new_meta['notes'].append('Smoothed using pixel widths of '+str(wid_list))\\n wcs_mask = (np.array(tuple(reversed(self.wcs.array_shape))) <= 1).tolist()\\n\\n output_cube = EISCube(sm_data, wcs=self.wcs, uncertainty=sm_errs,\\n wavelength=self.wavelength, radcal=old_radcal,\\n meta=new_meta, unit=self.unit,\\n mask=sm_data_mask, missing_axes=wcs_mask)\\n\\n return output_cube\",\n \"def normalise(self, spectrum):\\n\\n return spectrum\",\n \"def normalise(self, spectrum):\\n\\n return spectrum\",\n \"def index_as_cube(self):\\n return _IndexAsCubeSlicer(self)\",\n \"def to_spherical(self):\\n return cartesian_to_spherical(self.x, self.y, self.z)\",\n \"def spectral():\\n c = _si.c.value\\n h = _si.h.value\\n hc = h * c\\n two_pi = 2.0 * np.pi\\n inv_m_spec = si.m**-1\\n inv_m_ang = si.radian / si.m\\n\\n return Equivalency(\\n [\\n (si.m, si.Hz, lambda x: c / x),\\n (si.m, si.J, lambda x: hc / x),\\n (si.Hz, si.J, lambda x: h * x, lambda x: x / h),\\n (si.m, inv_m_spec, lambda x: 1.0 / x),\\n (si.Hz, inv_m_spec, lambda x: x / c, lambda x: c * x),\\n (si.J, inv_m_spec, lambda x: x / hc, lambda x: hc * x),\\n (inv_m_spec, inv_m_ang, lambda x: x * two_pi, lambda x: x / two_pi),\\n (si.m, inv_m_ang, lambda x: two_pi / x),\\n (si.Hz, inv_m_ang, lambda x: two_pi * x / c, lambda x: c * x / two_pi),\\n (si.J, inv_m_ang, lambda x: x * two_pi / hc, lambda x: hc * x / two_pi),\\n ],\\n \\\"spectral\\\",\\n )\",\n \"def spectral_model(self, which=\\\"point\\\"):\\n idx = self._get_idx(which)\\n\\n pars = {\\n \\\"reference\\\": \\\"7 TeV\\\",\\n \\\"amplitude\\\": self.data[f\\\"spec{idx}_dnde\\\"],\\n \\\"index\\\": -self.data[f\\\"spec{idx}_index\\\"],\\n }\\n\\n errs = {\\n \\\"amplitude\\\": self.data[f\\\"spec{idx}_dnde_err\\\"],\\n \\\"index\\\": self.data[f\\\"spec{idx}_index_err\\\"],\\n }\\n\\n model = Model.create(\\\"PowerLawSpectralModel\\\", \\\"spectral\\\", **pars)\\n\\n for name, value in errs.items():\\n model.parameters[name].error = value\\n\\n return model\",\n \"def get_wave(self, _spectrogram, _is_full_spectrogram=False):\\n # in half spectrogram, 1st row is not in mirror image\\n # last line row is same, so, we flip 2nd to last but one rows\\n\\n fft_coeffs = self.F\\n if not _is_full_spectrogram:\\n # generating full spectrogram from the upper half if 'is_full_spectrogram' is False\\n full_spectrogram = np.vstack((_spectrogram[0],\\n _spectrogram[1:-1],\\n _spectrogram[-1],\\n np.flipud(_spectrogram[1:-1]).conjugate()))\\n else:\\n full_spectrogram = _spectrogram\\n\\n # Doing Fourier inverse to get segmented matrix\\n signal_segment_matrix = np.dot(fft_coeffs.conjugate().T, full_spectrogram).real\\n # Recovering timeseries signal\\n signal = self.reconstruct_signal(signal_segment_matrix)\\n # Rescaling the signal\\n # signal = (signal - signal.min()) / (signal.max() - signal.min())\\n # signal = signal / signal.var()\\n\\n # returning signal\\n return signal\",\n \"def convert_spectrogram_to_audio(self, spec: 'torch.tensor', **kwargs) -> 'torch.tensor':\",\n \"def mel_spectrogram(self, y):\\n # assert(torch.min(y.data) >= -1)\\n # assert(torch.max(y.data) <= 1)\\n\\n magnitudes, phases = self.stft_fn.transform(y)\\n # magnitudes = magnitudes.data\\n mel_output = torch.matmul(self.mel_basis, magnitudes)\\n mel_output = self.spectral_normalize(mel_output)\\n return mel_output\",\n \"def convert_linear_spectrogram_to_audio(self, spec: 'torch.tensor', **kwargs) -> 'torch.tensor':\",\n \"def extract_spectra(self, cube, obj_mask='MASK_UNION', sky_mask='MASK_SKY',\\n tags_to_try=('MUSE_WHITE', 'NB_LYALPHA',\\n 'NB_HALPHA', 'NB_SUMOII3726'),\\n skysub=True, psf=None, beta=None, lbda=None,\\n apertures=None, unit_wave=u.angstrom):\\n if obj_mask not in self.images:\\n raise ValueError('key %s not present in the images dictionary'\\n % obj_mask)\\n\\n if skysub and sky_mask not in self.images:\\n raise ValueError('key %s not present in the images dictionary'\\n % sky_mask)\\n\\n ima = self.images[obj_mask]\\n\\n if ima.wcs.sameStep(cube.wcs):\\n size = ima.shape[0]\\n unit_size = None\\n else:\\n size = ima.wcs.get_step(unit=u.arcsec)[0] * ima.shape[0]\\n unit_size = u.arcsec\\n\\n center = (self.dec, self.ra)\\n subcub = cube.subcube(center=center, size=size,\\n unit_center=u.deg, unit_size=unit_size,\\n lbda=lbda, unit_wave=unit_wave)\\n wcsref = subcub.wcs\\n\\n if not ima.wcs.isEqual(wcsref):\\n ima = ima.resample(\\n newdim=subcub.shape[1:],\\n newstart=wcsref.get_start(unit=u.deg),\\n newstep=wcsref.get_step(unit=u.arcsec),\\n order=0, unit_start=u.deg, unit_step=u.arcsec)\\n\\n object_mask = ima.data.data\\n\\n if skysub:\\n skymask = self.images[sky_mask]\\n if not skymask.wcs.isEqual(wcsref):\\n skymask = skymask.resample(\\n newdim=subcub.shape[1:],\\n newstart=wcsref.get_start(unit=u.deg),\\n newstep=wcsref.get_step(unit=u.arcsec),\\n order=0, unit_start=u.deg, unit_step=u.arcsec)\\n\\n # Get the sky spectrum and subtract it\\n self.spectra['MUSE_SKY'] = subcub.mean(weights=skymask.data.data,\\n axis=(1, 2))\\n subcub = subcub - self.spectra['MUSE_SKY']\\n suffix = '_SKYSUB'\\n else:\\n suffix = ''\\n\\n # No weighting\\n spec = (subcub * object_mask).sum(axis=(1, 2))\\n self.spectra['MUSE_TOT' + suffix] = spec\\n\\n if apertures:\\n tmpim = Image(data=np.zeros_like(object_mask, dtype=bool),\\n copy=False, wcs=ima.wcs)\\n for radius in apertures:\\n tmpim.mask_ellipse(center, radius, 0)\\n mask = object_mask.astype(bool) & tmpim.mask\\n # spec = compute_spectrum(subcub, weights=mask)\\n spec = (subcub * mask).sum(axis=(1, 2))\\n self.spectra['MUSE_APER_%.1f%s' % (radius, suffix)] = spec\\n tmpim.unmask()\\n\\n # Loop over the narrow-band images we want to use. Apply the object\\n # mask and ensure that the weight map within the object mask is >=0.\\n if tags_to_try is not None:\\n nb_tags = list(set(tags_to_try) & set(self.images))\\n ksel = (object_mask != 0)\\n for tag in nb_tags:\\n if self.images[tag].wcs.isEqual(wcsref):\\n weight = self.images[tag].data.copy()\\n weight[ksel] -= np.min(weight[ksel])\\n weight = weight.filled(0)\\n self.spectra[tag + suffix] = compute_optimal_spectrum(\\n subcub, object_mask, weight)\\n\\n # PSF\\n if psf is not None:\\n if len(psf.shape) == 3:\\n # PSF cube. The user is responsible for getting the\\n # dimensions right\\n if not np.array_equal(psf.shape, subcub.shape):\\n raise ValueError('Incorrect dimensions for the PSF cube '\\n '({}) (it must be ({})) '\\n .format(psf.shape, subcub.shape))\\n elif len(psf.shape) == 1:\\n psf = create_psf_cube(subcub.shape, psf, beta=beta, wcs=wcsref)\\n\\n spec = compute_optimal_spectrum(subcub, object_mask, psf)\\n self.spectra['MUSE_PSF' + suffix] = spec\\n # Insert the PSF weighted flux - here re-normalised?\",\n \"def transform_cube(self,\\n cube: xr.Dataset,\\n gm: GridMapping,\\n cube_config: CubeConfig) -> TransformedCube:\\n return cube, gm, cube_config\",\n \"def make_spectrogram(self, wav):\\n y, sr = wav\\n shape = self.spectrogram_shape\\n if shape < 100:\\n n_mels = 128\\n n_fft = 512\\n hop_length = 512\\n elif shape < 200:\\n n_mels = 256\\n n_fft = 1024\\n hop_length = 256\\n else:\\n n_mels = 512\\n n_fft = 1408\\n hop_length = 256\\n if self.spectrogram_type == 'melspec':\\n spec = librosa.feature.melspectrogram(y=y, sr=sr,\\n hop_length=hop_length,\\n n_fft=n_fft, n_mels=n_mels)\\n spec = librosa.power_to_db(spec)\\n elif self.spectrogram_type == 'spec':\\n spec = np.abs(librosa.core.stft(y=y, n_fft=shape * 4, hop_length=hop_length))\\n spec = librosa.amplitude_to_db(spec, ref=np.max)\\n else:\\n raise ValueError('Unknown value for spectrogram_type: should be either melspec or spec!')\\n return spec\",\n \"def copy(self):\\n new_cubies = [cubie.copy() for cubie in self.cubies]\\n new_cube = Cube(new_cubies)\\n return new_cube\",\n \"def generated_cube(self) -> Optional[xr.Dataset]:\\n return self._generated_cube\",\n \"def normalised(self):\\n q = Quaternion(self)\\n q._normalise()\\n return q\",\n \"def sum_spectra(self, wave_range=None, units=u.Angstrom):\\n if wave_range is None:\\n # Sum over entire wavelength axis and return an NDCube\\n sum_data = np.sum(self.data, axis=2)\\n new_wcs = self.wcs.dropaxis(0)\\n new_meta = copy.deepcopy(self.meta)\\n new_meta['notes'].append('Summed over entire wavelength axis.')\\n return NDCube(sum_data, new_wcs, meta=new_meta)\\n\\n # Validate input wavelength range\\n if isinstance(wave_range, (list, tuple)):\\n use_range = [0, 0]\\n range_units = ['unknown', 'unknown']\\n print('Summing EISCube spectra over a select wavelength range.')\\n if len(wave_range) != 2:\\n print('Error: invalid number of wave_range values. Please input'\\n +' a list or tuple with exactly two elements.',\\n file=sys.stderr)\\n return None\\n else:\\n print('Error: invalid wave_range type. Please input either None or'\\n +' a list (or tuple) with two elements.', file=sys.stderr)\\n return None\\n\\n for w in range(2):\\n if isinstance(wave_range[w], u.Quantity):\\n # Parse an astropy.units.Quantity and convert as needed\\n # Note: this will overwrite any inputs to the \\\"units\\\" kwarg\\n if wave_range[w].unit == u.pix:\\n use_range[w] = wave_range[w].value\\n range_units[w] = u.pix\\n elif wave_range[w].unit.physical_type == 'length':\\n use_range[w] = wave_range[w].to('Angstrom').value\\n range_units[w] = u.Angstrom\\n else:\\n print('Error: invalid wavelength unit. Please input a pixel'\\n +' or length unit.', file=sys.stderr)\\n return None\\n else:\\n # Assume default or user inputted units (still convert if needed)\\n input_units = u.Unit(units)\\n if input_units == u.pix:\\n use_range[w] = float(wave_range[w])\\n range_units[w] = u.pix\\n elif input_units.physical_type == 'length':\\n u_scale = input_units.to('Angstrom')\\n use_range[w] = float(wave_range[w])*u_scale\\n range_units[w] = u.Angstrom\\n else:\\n print('Error: invalid wavelength unit. Please input a pixel'\\n +' or length unit.', file=sys.stderr)\\n return None\\n\\n # Check for consistent units\\n if range_units[0] != range_units[1]:\\n print('Error: mismatched units. Please input the same units for'\\n +' both wave_range elements or use the \\\"units\\\" keyword',\\n file=sys.stderr)\\n return None\\n\\n # If given values of [center, half width], compute the actual range\\n if use_range[1] < use_range[0]:\\n temp_center = use_range[0]\\n temp_half_wid = use_range[1]\\n use_range[0] = temp_center - temp_half_wid\\n use_range[1] = temp_center + temp_half_wid\\n\\n # Get indices to be summed over\\n w_indices = [0, -1]\\n if range_units[0] == u.pix:\\n # Round pixels values to nearest whole indice\\n w_indices[w] = int(round(use_range[w]))\\n elif range_units[0] == u.Angstrom:\\n # Find the closest pixel location on the average wavelength axis\\n try:\\n # Note: the corrected wavelength has units of [Angstrom]\\n w_coords = np.mean(self.wavelength, axis=(0,1))\\n except KeyError:\\n print('Error: missing or invalid corrected wavelength array.')\\n return None\\n for w in range(2):\\n abs_w_diff = np.abs(w_coords - use_range[w])\\n w_indices[w] = np.argmin(abs_w_diff)\\n\\n sum_data = np.sum(self.data[:,:,w_indices[0]:w_indices[1]+1], axis=2)\\n new_wcs = self.wcs.dropaxis(0)\\n new_meta = copy.deepcopy(self.meta)\\n new_meta['notes'].append('Summed wavelength axis over the range of '\\n +str(use_range)+' '+str(range_units[0]))\\n return NDCube(sum_data, new_wcs, meta=new_meta)\",\n \"def mel_spectrogram(self, y):\\n if isinstance(y, np.ndarray):\\n y = torch.from_numpy(y).float()\\n y = y.unsqueeze(0)\\n y = torch.autograd.Variable(y, requires_grad=False)\\n\\n assert (torch.min(y.data) >= -1)\\n assert (torch.max(y.data) <= 1)\\n\\n magnitudes, phases = self.stft_fn.transform(y)\\n magnitudes = magnitudes.data\\n mel_output = torch.matmul(self.mel_basis, magnitudes)\\n mel_output = self.spectral_normalize(mel_output)\\n return torch.squeeze(mel_output, 0).detach().cpu().numpy().T\",\n \"def shape(self):\\n return self._spectral_shape\",\n \"def __init__(self, cube_file):\\n\\t\\timport pyfits, pywcs\\n\\t\\t# Put the cube in RA - DEC - RM order and save it\\n\\t\\tCube.__init__(self, np.transpose(pyfits.getdata(cube_file), (2, 1, 0)))\\n\\t\\tself.wcs = pywcs.WCS(pyfits.getheader(cube_file))\\n\\n\\t\\tsky0 = self.pix2sky([0,0,0])\\n\\t \\tskyN = self.pix2sky([self.x_max,self.y_max,self.z_max])\\n\\t \\tself.ra_min = min(sky0[0],skyN[0])\\n\\t\\tself.ra_max = max(sky0[0],skyN[0])\\n\\t\\tself.ra_step = (self.ra_max-self.ra_min)/self.x_max\\n\\t \\tself.dec_min = min(sky0[1],skyN[1])\\n\\t self.dec_max = max(sky0[1],skyN[1])\\n\\t\\tself.dec_step = (self.dec_max-self.dec_min)/self.y_max\\n\\t\\tself.fd_min = min(sky0[2],skyN[2])\\n\\t\\tself.fd_max = max(sky0[2],skyN[2])\\n\\t\\tself.fd_step = (self.fd_max-self.fd_min)/self.z_max\",\n \"def transform_cube(self,\\n cube: xr.Dataset,\\n gm: GridMapping,\\n cube_config: CubeConfig) -> TransformedCube:\",\n \"def flatten_cube(cube):\\n nb=cube.shape[0]\\n cube_flattened = np.zeros_like(cube)\\n for i in range(nb):\\n cube_flattened[i,:,:] = flatten_image(cube[i,:,:])\\n return cube_flattened\",\n \"def _spin_spherical_convolution_from_spectral(\\n transformer, coefficients_in, filter_coefficients, spins_out,\\n spectral_pooling, spectral_upsampling,\\n output_representation):\\n if spectral_pooling:\\n ell_max = coefficients_in.shape[0] - 1\\n new_ell_max = (ell_max+1) // 2 - 1\\n coefficients_in = coefficients_in[\\n :new_ell_max + 1, (ell_max-new_ell_max):(ell_max+new_ell_max+1)]\\n\\n # Compute the convolution in the spectral domain.\\n coefficients_out = jnp.einsum(\\\"lmic,liocd->lmod\\\",\\n coefficients_in,\\n filter_coefficients)\\n\\n if spectral_upsampling:\\n num_ell = coefficients_out.shape[0]\\n coefficients_out = jnp.pad(coefficients_out,\\n [(0, num_ell), (num_ell, num_ell),\\n (0, 0), (0, 0)])\\n\\n if output_representation == \\\"spectral\\\":\\n return coefficients_out\\n elif output_representation == \\\"spatial\\\":\\n # Convert back to the spatial domain.\\n return transformer.swsft_backward_spins_channels(coefficients_out,\\n spins_out)\\n else:\\n raise ValueError(\\\"`output_representation` must be either \\\"\\n \\\"'spectral' or 'spatial'.\\\")\",\n \"def slice_to_spectrogram(self, y_coord, x_coord=None, **kwargs):\\n if self.axes_wcs.wcs.ctype[0] not in ['TIME', 'UTC']:\\n raise cu.CubeError(1,\\n 'Cannot create a spectrogram with no time axis')\\n if self.axes_wcs.wcs.ctype[1] != 'WAVE':\\n raise cu.CubeError(2, 'A spectral axis is needed in a spectrogram')\\n if self.data.ndim == 3:\\n data = self.data[:, :, cu.pixelize(y_coord, self.axes_wcs, 2)]\\n else:\\n if x_coord is None:\\n raise cu.CubeError(4, 'An x-coordinate is needed for 4D cubes')\\n data = self.data[:, :, cu.pixelize(y_coord, self.axes_wcs, 2),\\n cu.pixelize(x_coord, self.axes_wcs, 3)]\\n time_axis = self.time_axis().value\\n freq_axis = self.wavelength_axis().value\\n\\n if 'DATE_OBS'in self.meta:\\n tformat = '%Y-%m-%dT%H:%M:%S.%f'\\n start = datetime.datetime.strptime(self.meta['DATE_OBS'], tformat)\\n else:\\n start = datetime.datetime(1, 1, 1)\\n\\n if 'DATE_END' in self.meta:\\n tformat = '%Y-%m-%dT%H:%M:%S.%f'\\n end = datetime.datetime.strptime(self.meta['DATE_END'], tformat)\\n else:\\n dif = time_axis[-1] - time_axis[0]\\n unit = self.axes_wcs.wcs.cunit[0]\\n dif = dif * u.Unit(unit)\\n days = dif.to(sday)\\n lapse = datetime.timedelta(days.value)\\n end = start + lapse\\n return Spectrogram(data=data, time_axis=time_axis, freq_axis=freq_axis,\\n start=start, end=end, **kwargs)\",\n \"def create_spectrogram(audio_file, sampling_rate = 44100):\\n\\n #print(audio_file)\\n S, freqs, times = mlab.specgram(audio_file, NFFT=4096, Fs=sampling_rate,window=mlab.window_hanning,noverlap=2048)\\n \\n #print(S.shape)\\n return S\",\n \"def spectral_decomposition(self):\\n w = SpectralChoiceDialog(self)\\n if w.value == 1: # If new data was created\\n self.model.refresh_file()\",\n \"def _setup_sensor ( self ):\\n self.spectral = Spectral ( np.array([450, 520, 630, 770., 1550, 2090.] ),\\n np.array([ 520, 600, 690, 900., 1750., 2350.] ) )\",\n \"def to_wavelength(self):\\n\\n if self.unit == 'f_lam':\\n raise ValueError('Dispersion is arealdy in wavelength')\\n elif self.unit == 'f_nu':\\n self.flux = self.flux * self.dispersion**2 / (c.value * 1e+10)\\n self.dispersion = (c.value * 1e+10) / self.dispersion\\n\\n self.flux = np.flip(self.flux, axis=0)\\n self.dispersion = np.flip(self.dispersion, axis=0)\\n\\n elif self.unit == 'f_loglam':\\n self.dispersion = np.exp(self.dispersion)\\n self.flux = self.flux / self.dispersion\\n else:\\n raise ValueError('Spectrum unit not recognized: ', self.unit)\\n\\n self.unit = 'f_lam'\",\n \"def read(cls, filename, **kwargs):\\n hdulist = fits.open(name=filename, **kwargs)\\n header = _clean(hdulist[0].header)\\n # TODO: Make sure each cube has a correct wcs.\\n w = WCS(header=header, naxis=3)\\n wavelengths = [c.name for c in hdulist[1].columns if c.dim is not None]\\n data = [hdulist[1].data[wav] for wav in wavelengths]\\n cubes = [EISSpectralCube(data[i], w, i+1, dataHeader=hdulist[1].header,\\n primaryHeader=hdulist[0].header)\\n for i in range(len(data))]\\n return dict(zip(wavelengths, cubes))\",\n \"def sensitivity_cube(datadir):\\n filename = datadir.join(\\\"test_sensitivity_cube.fits\\\").strpath\\n wavelengths = [3500.0, 5500.0]\\n alphas = [-3.5, -3.5]\\n\\n return SensitivityCube.from_file(filename, wavelengths, alphas)\",\n \"def unoriented_cube():\\n faces = get_oriented_cube_faces()\\n for face in faces:\\n np.random.shuffle(face)\\n poly = Polyhedron(get_cube_points(), faces, faces_are_convex=True)\\n poly.sort_faces()\\n return poly\",\n \"def _move_spectral_axis(wcs, flux, mask=None, uncertainty=None):\\n naxis = getattr(wcs, 'naxis', len(wcs.world_axis_physical_types))\\n if naxis > 1:\\n temp_axes = []\\n phys_axes = wcs.world_axis_physical_types\\n for i in range(len(phys_axes)):\\n if phys_axes[i] is None:\\n continue\\n if phys_axes[i][0:2] == \\\"em\\\" or phys_axes[i][0:5] == \\\"spect\\\":\\n temp_axes.append(i)\\n if len(temp_axes) != 1:\\n raise ValueError(\\\"Input WCS must have exactly one axis with \\\"\\n \\\"spectral units, found {}\\\".format(len(temp_axes)))\\n\\n # Due to FITS conventions, a WCS with spectral axis first corresponds\\n # to a flux array with spectral axis last.\\n if temp_axes[0] != 0:\\n wcs = wcs.swapaxes(0, temp_axes[0])\\n if flux is not None:\\n flux = np.swapaxes(flux, len(flux.shape) - temp_axes[0] - 1, -1)\\n if mask is not None:\\n mask = np.swapaxes(mask, len(mask.shape) - temp_axes[0] - 1, -1)\\n if uncertainty is not None:\\n if isinstance(uncertainty, NDUncertainty):\\n # Account for Astropy uncertainty types\\n unc_len = len(uncertainty.array.shape)\\n temp_unc = np.swapaxes(uncertainty.array,\\n unc_len - temp_axes[0] - 1, -1)\\n if uncertainty.unit is not None:\\n temp_unc = temp_unc * u.Unit(uncertainty.unit)\\n uncertainty = type(uncertainty)(temp_unc)\\n else:\\n uncertainty = np.swapaxes(uncertainty,\\n len(uncertainty.shape) -\\n temp_axes[0] - 1, -1)\\n return wcs, flux, mask, uncertainty\",\n \"def transform(self, data):\\n self.cube = self.trf.transform(data)\",\n \"def plasm_cube(self, size=0.1, color=WHITE):\\n return COLOR(color)(T([1,2,3])(self.coords)(CUBOID([size, size, size])))\",\n \"def _setup_sensor ( self ):\\n self.spectral = Spectral ( np.array([500, 610, 780, 1580.] ),\\n np.array([590, 680, 890, 1750.] ) )\",\n \"def __mul__(self, scalar):\\n out = SpectrumTemplate(wave=self.wave, flux=self.flux*scalar)\\n out.fwhm = self.fwhm\\n return out\",\n \"def get_mel_spectro_transform(conf):\\n\\n mel_spectro_transform = torchaudio.transforms.MelSpectrogram(sample_rate=conf['data']['transform']['sample_rate'],\\n win_length=conf['data']['transform']['win_length'],\\n hop_length=conf['data']['transform']['hop_length'],\\n n_fft=conf['data']['transform']['n_fft'],\\n f_min=conf['data']['transform']['f_min'],\\n f_max=conf['data']['transform']['f_max'],\\n n_mels=conf['data']['transform']['n_mels'],\\n )\\n return mel_spectro_transform\",\n \"def spectrum(self):\\r\\n f, spectrum = tsa.get_spectra(self.input.data, method=self.method)\\r\\n return spectrum\",\n \"def mel_spectrogram(self, wav):\\n D = self._stft(wav)\\n S = self._linear_to_mel(np.abs(D))\\n return self._normalize(S).T\",\n \"def apply_spectral_radius(w,spectral_radius):\\n assert len(w.shape)==2 and w.shape[0]==w.shape[1],\\\\\\n \\\"Error: apply_spectral_radius must receive 'w' as a square matrix.\\\"\\n\\n new_w = np.array(w)\\n spectral_radius_w = calc_spectral_radius(w)\\n if spectral_radius_w > 0.0:\\n new_w = (w / spectral_radius_w) * spectral_radius\\n else:\\n print(\\\"Warning: Spectral radius of 'w' is zero (because of small size). Therefore, spectral radius does not changed.\\\")\\n\\n return new_w\",\n \"def fix_data(self, cube: Cube) -> Cube:\\n return cube\",\n \"def generate_spectrum(self):\\n matlab_method = self.matlab_mapper[self.matlab_script]\\n n, dm, peak_locations, omega_res, n_shell, gamma_amp = matlab_method(float(self.n_max), float(self.n_max_s),\\n float(self.num_channels), float(self.scale),\\n float(self.omega_shift), float(self.dg),\\n float(self.dgs), float(self.gamma_amp_factor),\\n float(self.amp_factor), float(self.epsilon2),\\n nargout=6)\\n dm = [list(d) for d in dm]\\n self.num_timesteps = len(dm[0])\\n if type(peak_locations) == float:\\n peak_locations = list([peak_locations])\\n else:\\n peak_locations = [list(p) for p in peak_locations]\\n spectrum = Spectrum(n=n, dm=dm, peak_locations=peak_locations, n_shell=n_shell, gamma_amp=gamma_amp, **self.__dict__)\\n return spectrum\",\n \"def _collapse_scalar_dimensions(cube: Cube) -> Cube:\\n coords_to_collapse = []\\n for coord in cube.coords(dim_coords=True):\\n if len(coord.points) == 1 and \\\"realization\\\" not in coord.name():\\n coords_to_collapse.append(coord)\\n for coord in coords_to_collapse:\\n cube = next(cube.slices_over(coord))\\n return cube\",\n \"def slice_to_cube(self, axis, chunk, **kwargs):\\n if self.data.ndim == 3:\\n raise cu.CubeError(4, 'Can only slice a hypercube into a cube')\\n\\n item = [slice(None, None, None) for _ in range(4)]\\n if isinstance(chunk, tuple):\\n if cu.iter_isinstance(chunk, (u.Quantity, u.Quantity)):\\n pixel0 = cu.convert_point(chunk[0].value, chunk[0].unit,\\n self.axes_wcs, axis)\\n pixel1 = cu.convert_point(chunk[1].value, chunk[1].unit,\\n self.axes_wcs, axis)\\n item[axis] = slice(pixel0, pixel1, None)\\n elif cu.iter_isinstance((chunk, int, int)):\\n item[axis] = slice(chunk[0], chunk[1], None)\\n else:\\n raise cu.CubeError(5, \\\"Parameters must be of the same type\\\")\\n newdata = self.data[item].sum(axis)\\n else:\\n unit = chunk.unit if isinstance(chunk, u.Quantity) else None\\n pixel = cu.convert_point(chunk, unit, self.axes_wcs, axis)\\n item[axis] = pixel\\n newdata = self.data[item]\\n wcs_indices = [0, 1, 2, 3]\\n wcs_indices.remove(3 - axis)\\n newwcs = wu.reindex_wcs(self.axes_wcs, np.array(wcs_indices))\\n if axis == 2 or axis == 3:\\n newwcs = wu.add_celestial_axis(newwcs)\\n newwcs.was_augmented = True\\n cube = Cube(newdata, newwcs, meta=self.meta, **kwargs)\\n return cube\",\n \"def get_spectrum(self):\\n return self.spectrum.copy()\",\n \"def to_grid(self, field_spectral):\\n return self._spharm.spectogrd(field_spectral)\",\n \"def reconstruct_waveform(self, mel, n_iter=32):\\n amp_mel = self._denormalize(mel)\\n S = librosa.feature.inverse.mel_to_stft(\\n amp_mel,\\n power=1,\\n sr=self.config['sampling_rate'],\\n n_fft=self.config['n_fft'],\\n fmin=self.config['f_min'],\\n fmax=self.config['f_max'])\\n wav = librosa.core.griffinlim(\\n S,\\n n_iter=n_iter,\\n hop_length=self.config['hop_length'],\\n win_length=self.config['win_length'])\\n return wav\",\n \"def get_spectral(period, stream, damping, rotation=None):\\n T = period\\n freq = 1.0 / T\\n omega = (2 * 3.14159 * freq) ** 2\\n paz_sa = corn_freq_2_paz(freq, damp=damping)\\n paz_sa['sensitivity'] = omega\\n paz_sa['zeros'] = []\\n spect_stream = Stream()\\n\\n horizontals = []\\n for idx, trace in enumerate(stream):\\n # Group all of the max values from traces without\\n # Z in the channel name\\n if 'Z' not in trace.stats['channel'].upper():\\n horizontals += [trace.copy()]\\n h1_stats = horizontals[0].stats\\n\\n if rotation is None:\\n for trace in stream:\\n samp_rate = trace.stats['sampling_rate']\\n with warnings.catch_warnings():\\n warnings.simplefilter(\\\"ignore\\\")\\n dd = simulate_seismometer(trace.data, samp_rate,\\n paz_remove=None,\\n paz_simulate=paz_sa,\\n taper=True,\\n simulate_sensitivity=True,\\n taper_fraction=0.05)\\n period_str = 'T' + '{:04.2f}'.format(T)\\n stats_out = trace.stats.copy()\\n stats_out['period'] = period_str\\n spect_trace = Trace(dd, stats_out)\\n spect_trace.data = spect_trace.data * GAL_TO_PCTG\\n spect_trace.stats['units'] = '%%g'\\n spect_stream.append(spect_trace)\\n return spect_stream\\n elif rotation.lower() == 'nongm':\\n if len(horizontals) != 2:\\n warnings.warn('Spectral amplitude rotation could not be performed.')\\n return\\n rot = [rotate(horizontals[0], horizontals[1], combine=True)]\\n elif rotation.lower() == 'gm':\\n if len(horizontals) != 2:\\n warnings.warn('Spectral amplitude rotation could not be performed.')\\n return\\n rot1, rot2 = rotate(horizontals[0], horizontals[1], combine=False)\\n rot = [rot1, rot2]\\n rotated = []\\n for rot_matrix in rot:\\n rotated_spectrals = np.zeros(rot_matrix.shape)\\n for idx, row in enumerate(rot_matrix):\\n samp_rate = h1_stats['sampling_rate']\\n with warnings.catch_warnings():\\n warnings.simplefilter(\\\"ignore\\\")\\n dd = simulate_seismometer(row, samp_rate,\\n paz_remove=None,\\n paz_simulate=paz_sa,\\n taper=True,\\n simulate_sensitivity=True,\\n taper_fraction=0.05)\\n\\n period_str = 'T' + '{:04.2f}'.format(T)\\n stats_out = h1_stats.copy()\\n stats_out['period'] = period_str\\n spect_trace = Trace(dd, stats_out)\\n spect_trace.data = spect_trace.data * GAL_TO_PCTG\\n spect_trace.stats['units'] = '%%g'\\n rotated_spectrals[idx] = spect_trace\\n rotated += [rotated_spectrals]\\n return rotated\",\n \"def getCube(unique_name):\",\n \"def calculate(cubes):\\n rlut_cube = cubes.extract_cube(\\n Constraint(name='toa_outgoing_longwave_flux'))\\n rlutcs_cube = cubes.extract_cube(\\n Constraint(name='toa_outgoing_longwave_flux_assuming_clear_sky'))\\n\\n lwcre_cube = rlutcs_cube - rlut_cube\\n lwcre_cube.units = rlut_cube.units\\n\\n return lwcre_cube\",\n \"def toReal(self):\\n\\n\\t\\tif self.space==\\\"real\\\":\\n\\t\\t\\tpass \\n\\t\\telse:\\n\\t\\t\\tself.data = fftengine.irfft2(self.data)\\n\\t\\t\\tself.space = \\\"real\\\"\",\n \"def forward(self, cube: torch.Tensor) -> torch.Tensor:\\n\\n # make sure that the nchan assumptions for the ImageCube and the NuFFT\\n # setup are the same\\n if cube.size(0) != self.nchan:\\n raise DimensionMismatchError(\\n f\\\"nchan of ImageCube ({cube.size(0)}) is different than that used to initialize NuFFT layer ({self.nchan})\\\"\\n )\\n\\n # \\\"unpack\\\" the cube, but leave it flipped\\n # NuFFT routine expects a \\\"normal\\\" cube, not an fftshifted one\\n shifted = torch.fft.fftshift(cube, dim=(1, 2))\\n\\n # convert the cube to a complex type, since this is required by TorchKbNufft\\n complexed = shifted.type(torch.complex128)\\n\\n # Consider how the similarity of the spatial frequency samples should be\\n # treated. We already took care of this on the k_traj side, since we set\\n # the shapes. But this also needs to be taken care of on the image side.\\n # * If we plan to parallelize with the coil dimension, then we need an\\n # image with shape (1, nchan, npix, npix).\\n # * If we plan to parallelize using the batch dimension, then we need\\n # an image with shape (nchan, 1, npix, npix).\\n\\n if self.same_uv:\\n # we want to unsqueeze/squeeze at dim=0 to parallelize over the coil\\n # dimension\\n # unsquezee shape: [1, nchan, npix, npix]\\n altered_dimension = 0\\n else:\\n # we want to unsqueeze/squeeze at dim=1 to parallelize over the\\n # batch dimension\\n # unsquezee shape: [nchan, 1, npix, npix]\\n altered_dimension = 1\\n\\n expanded = complexed.unsqueeze(altered_dimension)\\n\\n # torchkbnufft uses a [nbatch, ncoil, npix, npix] scheme\\n output: torch.Tensor = self.coords.cell_size**2 * self.nufft_ob(\\n expanded,\\n self.k_traj,\\n interp_mats=(\\n (self.real_interp_mat, self.imag_interp_mat)\\n if self.sparse_matrices\\n else None\\n ),\\n )\\n\\n # squeezed shape: [nchan, npix, npix]\\n output = torch.squeeze(output, dim=altered_dimension)\\n\\n return output\",\n \"def cube(self):\\n\\n dims = self.voxels.shape\\n max_dim = max(dims)\\n \\n x_target = (max_dim - dims[0]) / 2\\n y_target = (max_dim - dims[1]) / 2\\n z_target = (max_dim - dims[2]) / 2\\n\\n self.voxels = np.pad(self.voxels,\\n ((int(np.ceil(x_target)), int(np.floor(x_target))),\\n (int(np.ceil(y_target)), int(np.floor(y_target))),\\n (int(np.ceil(z_target)), int(np.floor(z_target)))),\\n 'constant',\\n constant_values=(0))\\n\\n self.point_position = self.point_position + [np.ceil(z_target),\\n np.ceil(y_target),\\n np.ceil(x_target)]\\n\\n return(self)\",\n \"def get_spectrum(self) -> pd.Series:\\n short_time_spectrum = self.get_short_time_spectrum()\\n raw_spectrum = short_time_spectrum.sum(axis=1)\\n frequencies = librosa.fft_frequencies(\\n sr=self.sample_rate,\\n n_fft=self.n_fft\\n )\\n spectrum = pd.Series(raw_spectrum, frequencies)\\n return spectrum\",\n \"def get_spectral_norm(self, sess):\\n first_term = self.get_first_term(sess)[0]\\n second_term = self.get_second_term(sess)\\n return first_term * second_term\",\n \"def spectrum(self):\\r\\n spectrum = tsa.cache_to_psd(self.cache, self.ij)\\r\\n\\r\\n return spectrum\",\n \"def get_default_mix_matrix(\\n self, source_speaker_mode, target_speaker_mode, matrix_hop=0\\n ):\\n target_channels = self.get_speaker_mode_channels(target_speaker_mode)\\n if matrix_hop:\\n source_channels = matrix_hop\\n else:\\n source_channels = self.get_speaker_mode_channels(source_speaker_mode)\\n matrix = (c_float * (source_channels * target_channels))()\\n self._call_fmod(\\n \\\"FMOD_System_GetDefaultMixMatrix\\\",\\n source_speaker_mode.value,\\n target_speaker_mode.value,\\n matrix,\\n matrix_hop,\\n )\\n return matrix\",\n \"def example_spectral_to_xyz():\\r\\n\\r\\n print(\\\"=== Example: Spectral->XYZ ===\\\")\\r\\n spc = SpectralColor(\\r\\n observer='2', illuminant='d50',\\r\\n spec_380nm=0.0600, spec_390nm=0.0600, spec_400nm=0.0641,\\r\\n spec_410nm=0.0654, spec_420nm=0.0645, spec_430nm=0.0605,\\r\\n spec_440nm=0.0562, spec_450nm=0.0543, spec_460nm=0.0537,\\r\\n spec_470nm=0.0541, spec_480nm=0.0559, spec_490nm=0.0603,\\r\\n spec_500nm=0.0651, spec_510nm=0.0680, spec_520nm=0.0705,\\r\\n spec_530nm=0.0736, spec_540nm=0.0772, spec_550nm=0.0809,\\r\\n spec_560nm=0.0870, spec_570nm=0.0990, spec_580nm=0.1128,\\r\\n spec_590nm=0.1251, spec_600nm=0.1360, spec_610nm=0.1439,\\r\\n spec_620nm=0.1511, spec_630nm=0.1590, spec_640nm=0.1688,\\r\\n spec_650nm=0.1828, spec_660nm=0.1996, spec_670nm=0.2187,\\r\\n spec_680nm=0.2397, spec_690nm=0.2618, spec_700nm=0.2852,\\r\\n spec_710nm=0.2500, spec_720nm=0.2400, spec_730nm=0.2300)\\r\\n xyz = convert_color(spc, XYZColor)\\r\\n print(xyz)\\r\\n print(\\\"=== End Example ===\\\\n\\\")\",\n \"def from_array(self, data, sr=None):\\n if self.normalize: data = 0.95*(data / abs(data).max())\\n\\n if sr != self.stft.sampling_rate:\\n raise ValueError(\\\"{} SR doesn't match target {} SR\\\".format( \\\\\\n sr, self.stft.sampling_rate))\\n audio_norm = data.clamp(-1, 1)\\n audio_norm = torch.autograd.Variable(audio_norm, requires_grad=False)\\n melspec = self.stft.mel_spectrogram(audio_norm[None])\\n melspec = torch.squeeze(melspec, 0)\\n return melspec\",\n \"def spectral_window(self):\\n if self._spectral_window is None:\\n spec_lc = self.lc.copy()\\n spec_lc.flux = np.zeros(len(self.lc.flux)) + 1\\n self._spectral_window = Periodogram.from_lightcurve(spec_lc)\\n return self._spectral_window\",\n \"def convertToSpectroGram(self):\",\n \"def _get_spectrograms(self, index):\\n file = self._waves[index]\\n\\n # get hyper-parameters\\n hp = self.hparams\\n\\n w, _ = lr.load(file, sr=hp.sr)\\n w, _ = lr.effects.trim(w) # triming\\n\\n linear = audio.wave2spec(w, hp)\\n\\n return linear, w\",\n \"def makeSpectrogram(self, datalist):\\n data = SpectrogramData(datalist)\\n spectrogram = Qwt.QwtPlotSpectrogram()\\n spectrogram.setData(data)\\n spectrogram.attach(self)\\n self.clearZoomStack()\",\n \"def get_sample(self):\\n sample = Sample(self._substrate[0].composition)\\n\\n for layer in self._layers:\\n sample.add_layer(layer.composition, layer.thickness_m,\\n layer.mass_thickness_kg_m2, layer.density_kg_m3)\\n\\n return sample\",\n \"def spectral(w, s=1.0):\\n n_in, n_out = w.size()\\n n = max(n_out, n_in)\\n gain = s / math.sqrt(n)\\n return w.normal_(0, 1).mul_(gain)\",\n \"def calc_noise_in_cube(cube, masking_scheme='simple', mask=None,\\n spatial_average_npix=None,\\n spatial_average_nbeam=5.0,\\n spectral_average_nchan=5, verbose=False):\\n\\n from scipy.ndimage import generic_filter\\n from astropy.stats import mad_std\\n\\n if masking_scheme not in ['simple', 'user']:\\n raise ValueError(\\\"'masking_scheme' should be specified as\\\"\\n \\\"either 'simple' or 'user'\\\")\\n elif masking_scheme == 'user' and mask is None:\\n raise ValueError(\\\"'masking_scheme' set to 'user', yet \\\"\\n \\\"no user-specified mask found\\\")\\n\\n # extract negative values (only needed if masking_scheme='simple')\\n if masking_scheme == 'simple':\\n if verbose:\\n print(\\\"Extracting negative values...\\\")\\n negmask = cube < (0 * cube.unit)\\n negdata = cube.with_mask(negmask).filled_data[:].value\\n negdata = np.stack([negdata, -1 * negdata], axis=-1)\\n else:\\n negdata = None\\n\\n # find rms noise as a function of channel\\n if verbose:\\n print(\\\"Estimating rms noise as a function of channel...\\\")\\n if masking_scheme == 'user':\\n mask_v = mask\\n elif masking_scheme == 'simple':\\n rms_v = mad_std(negdata, axis=(1, 2, 3), ignore_nan=True)\\n uplim_v = (3 * rms_v * cube.unit).reshape(-1, 1, 1)\\n lolim_v = (-3 * rms_v * cube.unit).reshape(-1, 1, 1)\\n mask_v = (((cube - uplim_v) < (0 * cube.unit)) &\\n ((cube - lolim_v) > (0 * cube.unit)))\\n rms_v = cube.with_mask(mask_v).mad_std(axis=(1, 2)).quantity.value\\n rms_v = generic_filter(rms_v, np.nanmedian,\\n mode='constant', cval=np.nan,\\n size=spectral_average_nchan)\\n \\n # find rms noise as a function of sightline\\n if verbose:\\n print(\\\"Estimating rms noise as a function of sightline...\\\")\\n if masking_scheme == 'user':\\n mask_s = mask\\n elif masking_scheme == 'simple':\\n rms_s = mad_std(negdata, axis=(0, 3), ignore_nan=True)\\n uplim_s = 3 * rms_s * cube.unit\\n lolim_s = -3 * rms_s * cube.unit\\n mask_s = (((cube - uplim_s) < (0 * cube.unit)) &\\n ((cube - lolim_s) > (0 * cube.unit)))\\n rms_s = cube.with_mask(mask_s).mad_std(axis=0).quantity.value\\n if spatial_average_npix is None:\\n beamFWHM_pix = (cube.beam.major.to(u.deg).value /\\n np.abs(cube.wcs.celestial.wcs.cdelt.min()))\\n beamFWHM_pix = np.max([beamFWHM_pix, 3.])\\n spatial_average_npix = int(spatial_average_nbeam *\\n beamFWHM_pix)\\n rms_s = generic_filter(rms_s, np.nanmedian,\\n mode='constant', cval=np.nan,\\n size=spatial_average_npix)\\n\\n # create rms noise cube from the tensor product of rms_v and rms_s\\n if verbose:\\n print(\\\"Creating rms noise cube (direct tensor product)...\\\")\\n rmscube = SpectralCube(np.einsum('i,jk', rms_v, rms_s),\\n wcs=cube.wcs,\\n header=cube.header.copy(strip=True))\\n rmscube.allow_huge_operations = cube.allow_huge_operations\\n # correct the normalization of the rms cube\\n if masking_scheme == 'user':\\n mask_n = mask\\n elif masking_scheme == 'simple':\\n rms_n = mad_std(negdata, ignore_nan=True)\\n uplim_n = 3 * rms_n * cube.unit\\n lolim_n = -3 * rms_n * cube.unit\\n mask_n = (((cube - uplim_n) < (0 * cube.unit)) &\\n ((cube - lolim_n) > (0 * cube.unit)))\\n rms_n = cube.with_mask(mask_n).mad_std().value\\n rmscube /= rms_n\\n\\n # apply NaN mask\\n rmscube = rmscube.with_mask(cube.mask.include())\\n\\n # check unit\\n if rmscube.unit != cube.unit:\\n rmscube = rmscube * (cube.unit / rmscube.unit)\\n\\n return rmscube\",\n \"def normalize_spectra(self, spectra):\\n self._compute_hull(spectra)\\n normalized_spectra = Spectra()\\n for p in self._points:\\n normalized_spectra.add_point(self._normalize_point(p))\\n return normalized_spectra\",\n \"def move_spectator(self) -> None:\\n\\n spectator = self.carla_world.get_spectator()\\n if spectator is not None and self.scene_camera is not None:\\n spectator.set_transform(self.scene_camera.get_transform())\",\n \"def U(self, *args):\\n return _Bnd.Bnd_Sphere_U(self, *args)\",\n \"def convolve_cube(cube, newbeam, res_tol=0.0, min_coverage=0.8,\\n append_raw=False, verbose=False,\\n suppress_error=False):\\n\\n from functools import partial\\n from astropy.convolution import convolve_fft\\n\\n if min_coverage is None:\\n # Skip coverage check and preserve NaN values.\\n # This uses the default interpolation strategy\\n # implemented in 'astropy.convolution.convolve_fft'\\n convolve_func = partial(convolve_fft, preserve_nan=True,\\n allow_huge=True, quiet=~verbose)\\n else:\\n # Do coverage check to determine the mask on the output\\n convolve_func = partial(convolve_fft, nan_treatment='fill',\\n boundary='fill', fill_value=0.,\\n allow_huge=True, quiet=~verbose)\\n\\n if (res_tol > 0) and (newbeam.major != newbeam.minor):\\n raise ValueError(\\\"You cannot specify a non-zero resolution \\\"\\n \\\"torelance if the target beam is not round\\\")\\n\\n tol = newbeam.major * np.array([1-res_tol, 1+res_tol])\\n if ((tol[0] < cube.beam.major < tol[1]) and\\n (tol[0] < cube.beam.minor < tol[1])):\\n if verbose:\\n print(\\\"Native resolution within tolerance - \\\"\\n \\\"Copying original cube...\\\")\\n my_append_raw = False\\n newcube = cube.unmasked_copy().with_mask(cube.mask.include())\\n else:\\n if verbose:\\n print(\\\"Convolving cube...\\\")\\n try:\\n convcube = cube.convolve_to(newbeam,\\n convolve=convolve_func)\\n if min_coverage is not None:\\n # divide the raw convolved image by the weight image\\n my_append_raw = True\\n wtcube = SpectralCube(\\n cube.mask.include().astype('float'),\\n cube.wcs, beam=cube.beam)\\n wtcube = wtcube.convolve_to(newbeam,\\n convolve=convolve_func)\\n newcube = convcube / wtcube.unmasked_data[:]\\n # mask all pixels w/ weight smaller than min_coverage\\n threshold = min_coverage * u.dimensionless_unscaled\\n newcube = newcube.with_mask(wtcube >= threshold)\\n else:\\n my_append_raw = False\\n newcube = convcube\\n print(\\\"\\\") # force line break after the progress bar\\n except ValueError as err:\\n if suppress_error:\\n return\\n else:\\n raise ValueError(\\n \\\"Unsuccessful convolution: {}\\\\nOld: {}\\\\nNew: {}\\\"\\n \\\"\\\".format(err, cube.beam, newbeam))\\n\\n if append_raw and my_append_raw:\\n return newcube, convcube, wtcube\\n else:\\n return newcube\",\n \"def testRendersSimpleCube(self):\\n\\n model_transforms = camera_utils.euler_matrices(\\n [[-20.0, 0.0, 60.0], [45.0, 60.0, 0.0]])[:, :3, :3]\\n\\n vertices_world_space = torch.matmul(\\n torch.stack([self.cube_vertices, self.cube_vertices]),\\n model_transforms.transpose())\\n\\n normals_world_space = torch.matmul(\\n torch.stack([self.cube_normals, self.cube_normals]),\\n model_transforms.transpose())\\n\\n # camera position:\\n eye = torch.tensor([[0.0, 0.0, 6.0], [0.0, 0.0, 6.0]], dtype=torch.float32)\\n center = torch.tensor([[0.0, 0.0, 0.0], [0.0, 0.0, 0.0]], dtype=torch.float32)\\n world_up = torch.tensor([[0.0, 1.0, 0.0], [0.0, 1.0, 0.0]], dtype=torch.float32)\\n image_width = 640\\n image_height = 480\\n light_positions = torch.tensor([[[0.0, 0.0, 6.0]], [[0.0, 0.0, 6.0]]])\\n light_intensities = torch.ones([2, 1, 3], dtype=torch.float32)\\n vertex_diffuse_colors = torch.ones_like(vertices_world_space, dtype=torch.float32)\\n\\n renders = mesh_renderer.mesh_renderer(\\n vertices_world_space, self.cube_triangles, normals_world_space,\\n vertex_diffuse_colors, eye, center, world_up, light_positions,\\n light_intensities, image_width, image_height)\\n\\n for image_id in range(renders.shape[0]):\\n target_image_name = \\\"Gray_Cube_%i.png\\\" % image_id\\n baseline_image_path = os.path.join(self.test_data_directory,\\n target_image_name)\\n test_utils.expect_image_file_and_render_are_near(\\n self, baseline_image_path, renders[image_id, :, :, :])\",\n \"def readSpectrum(self,fileName,colWave=0,colFlux=1,skipRows=0):\\n if not \\\".fits\\\" in fileName:\\n self.spectrum = sp.readSpectrum(fileName,\\\\\\n colWave=colWave,\\\\\\n colFlux=colFlux,\\\\\\n skipRows=skipRows)\\n\\n else:\\n self.spectrum = sp.Spectrum()\\n \\\"\\\"\\\" Check more at\\n http://archive.eso.org/cms/eso-data/help/1dspectra.html\\n https://www.hs.uni-hamburg.de/DE/Ins/Per/Czesla/PyA/PyA/pyaslDoc/aslDoc/readFitsSpec.html\\n \\\"\\\"\\\"\\n self.spectrum.wave, self.spectrum.flux = pyasl.read1dFitsSpec(fileName)\\n # self.spectrum.wave = self.spectrum.wave.byteswap().newbyteorder()\\n self.spectrum.flux = self.spectrum.flux.byteswap().newbyteorder() #TODO PyAstronomy bug\\n self.spectrum.name = fileName\\n self.radialVelocity = 0.0\\n self.oryginalWavelength = copy.deepcopy(self.spectrum.wave)\\n\\n self.spectrumNote.set_spectrum(fileName)\",\n \"def to_matrix(self): \\n warnings.warn(f'{self} is being reconstructed into a matrix, consider operating on the decomposed form.')\\n\\n full = self.to_tensor()\\n if self.n_matrices == ():\\n return full.reshape(self.shape)\\n else:\\n return full.reshape(self.n_matrices + self.shape)\",\n \"def mel_spectrogram(self, y):\\n assert torch.min(y.data) >= -1\\n assert torch.max(y.data) <= 1\\n magnitudes, phases = self.stft_fn.transform(y)\\n magnitudes = magnitudes.data\\n mel_output = torch.matmul(self.mel_basis, magnitudes)\\n mel_output = self.spectral_normalize(mel_output)\\n energy = torch.norm(magnitudes, dim=1)\\n return mel_output, energy\",\n \"def writeCube(c) :\\n print(\\\"Edge Length =\\\",c.getLength())\\n print(\\\"Volume =\\\",c.volume())\\n print(\\\"Surface Area =\\\",c.surfaceArea())\\n print(\\\"Face Diagonal =\\\",c.faceDiagonal())\\n print(\\\"Space Diagonal =\\\",c.spaceDiagonal())\",\n \"def test_sphere(self, sample_rate, num_channels, bits_per_sample):\\n duration = 1\\n path = self.get_temp_path(\\\"data.sph\\\")\\n sox_utils.gen_audio_file(path, sample_rate, num_channels, duration=duration, bit_depth=bits_per_sample)\\n info = self._info(path)\\n assert info.sample_rate == sample_rate\\n assert info.num_frames == sample_rate * duration\\n assert info.num_channels == num_channels\\n assert info.bits_per_sample == bits_per_sample\\n assert info.encoding == \\\"PCM_S\\\"\",\n \"def forward(self, audio: Tensor) -> Tensor:\\r\\n\\r\\n nb_sources = self.nb_targets\\r\\n nb_samples = audio.shape[0]\\r\\n\\r\\n # getting the STFT of mix:\\r\\n # (nb_samples, nb_channels, nb_bins, nb_frames, 2)\\r\\n mix_stft = self.stft(audio)\\r\\n X = self.complexnorm(mix_stft)\\r\\n\\r\\n # initializing spectrograms variable\\r\\n spectrograms = torch.zeros(X.shape + (nb_sources,), dtype=audio.dtype, device=X.device)\\r\\n\\r\\n for j, (target_name, target_module) in enumerate(self.target_models.items()):\\r\\n # apply current model to get the source spectrogram\\r\\n target_spectrogram = target_module(X.detach().clone())\\r\\n spectrograms[..., j] = target_spectrogram\\r\\n\\r\\n # transposing it as\\r\\n # (nb_samples, nb_frames, nb_bins,{1,nb_channels}, nb_sources)\\r\\n spectrograms = spectrograms.permute(0, 3, 2, 1, 4)\\r\\n\\r\\n # rearranging it into:\\r\\n # (nb_samples, nb_frames, nb_bins, nb_channels, 2) to feed\\r\\n # into filtering methods\\r\\n mix_stft = mix_stft.permute(0, 3, 2, 1, 4)\\r\\n\\r\\n # create an additional target if we need to build a residual\\r\\n if self.residual:\\r\\n # we add an additional target\\r\\n nb_sources += 1\\r\\n\\r\\n if nb_sources == 1 and self.niter > 0:\\r\\n raise Exception(\\r\\n \\\"Cannot use EM if only one target is estimated.\\\"\\r\\n \\\"Provide two targets or create an additional \\\"\\r\\n \\\"one with `--residual`\\\"\\r\\n )\\r\\n\\r\\n nb_frames = spectrograms.shape[1]\\r\\n targets_stft = torch.zeros(\\r\\n mix_stft.shape + (nb_sources,), dtype=audio.dtype, device=mix_stft.device\\r\\n )\\r\\n for sample in range(nb_samples):\\r\\n pos = 0\\r\\n if self.wiener_win_len:\\r\\n wiener_win_len = self.wiener_win_len\\r\\n else:\\r\\n wiener_win_len = nb_frames\\r\\n while pos < nb_frames:\\r\\n cur_frame = torch.arange(pos, min(nb_frames, pos + wiener_win_len))\\r\\n pos = int(cur_frame[-1]) + 1\\r\\n\\r\\n targets_stft[sample, cur_frame] = wiener(\\r\\n spectrograms[sample, cur_frame],\\r\\n mix_stft[sample, cur_frame],\\r\\n self.niter,\\r\\n softmask=self.softmask,\\r\\n residual=self.residual,\\r\\n )\\r\\n\\r\\n # getting to (nb_samples, nb_targets, channel, fft_size, n_frames, 2)\\r\\n targets_stft = targets_stft.permute(0, 5, 3, 2, 1, 4).contiguous()\\r\\n\\r\\n # inverse STFT\\r\\n estimates = self.istft(targets_stft, length=audio.shape[2])\\r\\n\\r\\n return estimates\",\n \"def cube_data(self):\\n cube_data = copy.deepcopy(self.data)\\n cube_data.shape = [self.nints * self.ngroups, self.rows, self.columns]\\n return cube_data\",\n \"def SpectrumAdapter(value):\\n\\n from mitsuba.core.xml import load_string\\n from mitsuba.core import sample_shifted, Vector1f, Spectrum\\n from mitsuba.render import SurfaceInteraction3f\\n\\n def instantiate(args):\\n if hasattr(value, 'sample'):\\n return value\\n else:\\n obj = load_string(value % args)\\n expanded = obj.expand()\\n if len(expanded) == 1:\\n return expanded[0]\\n else:\\n return obj\\n\\n def sample_functor(sample, *args):\\n plugin = instantiate(args)\\n si = SurfaceInteraction3f.zero(ek.slices(sample))\\n wavelength, weight = plugin.sample(si, sample_shifted(sample[0]))\\n return Vector1f(wavelength[0])\\n\\n def pdf_functor(w, *args):\\n plugin = instantiate(args)\\n si = SurfaceInteraction3f.zero(ek.slices(w))\\n si.wavelengths = w\\n return plugin.pdf(si)[0]\\n\\n return sample_functor, pdf_functor\",\n \"def cube_from_bbox(bbox):\\n cube = pm.polyCube(\\n width=bbox.width(),\\n height=bbox.height(),\\n depth=bbox.depth(),\\n ch=False\\n )\\n cube[0].setAttr('t', bbox.center())\\n return cube[0]\",\n \"def test_cube(self):\\n\\n # No isosurface\\n cube_zero = numpy.zeros((2, 2, 2), dtype=numpy.float32)\\n\\n result = marchingcubes.MarchingCubes(cube_zero, 1.)\\n self.assertEqual(result.shape, cube_zero.shape)\\n self.assertEqual(result.isolevel, 1.)\\n self.assertEqual(result.invert_normals, True)\\n\\n vertices, normals, indices = result\\n self.assertEqual(len(vertices), 0)\\n self.assertEqual(len(normals), 0)\\n self.assertEqual(len(indices), 0)\\n\\n # Cube array dimensions: shape = (dim 0, dim 1, dim2)\\n #\\n # dim 0 (Z)\\n # ^\\n # |\\n # 4 +------+ 5\\n # /| /|\\n # / | / |\\n # 6 +------+ 7|\\n # | | | |\\n # |0 +---|--+ 1 -> dim 2 (X)\\n # | / | /\\n # |/ |/\\n # 2 +------+ 3\\n # /\\n # dim 1 (Y)\\n\\n # isosurface perpendicular to dim 0 (Z)\\n cube = numpy.array(\\n (((0., 0.), (0., 0.)),\\n ((1., 1.), (1., 1.))), dtype=numpy.float32)\\n level = 0.5\\n vertices, normals, indices = marchingcubes.MarchingCubes(\\n cube, level, invert_normals=False)\\n self.assertAllClose(vertices[:, 0], level)\\n self.assertAllClose(normals, (1., 0., 0.))\\n self.assertEqual(len(indices), 2)\\n\\n # isosurface perpendicular to dim 1 (Y)\\n cube = numpy.array(\\n (((0., 0.), (1., 1.)),\\n ((0., 0.), (1., 1.))), dtype=numpy.float32)\\n level = 0.2\\n vertices, normals, indices = marchingcubes.MarchingCubes(cube, level)\\n self.assertAllClose(vertices[:, 1], level)\\n self.assertAllClose(normals, (0., -1., 0.))\\n self.assertEqual(len(indices), 2)\\n\\n # isosurface perpendicular to dim 2 (X)\\n cube = numpy.array(\\n (((0., 1.), (0., 1.)),\\n ((0., 1.), (0., 1.))), dtype=numpy.float32)\\n level = 0.9\\n vertices, normals, indices = marchingcubes.MarchingCubes(\\n cube, level, invert_normals=False)\\n self.assertAllClose(vertices[:, 2], level)\\n self.assertAllClose(normals, (0., 0., 1.))\\n self.assertEqual(len(indices), 2)\\n\\n # isosurface normal in dim1, dim 0 (Y, Z) plane\\n cube = numpy.array(\\n (((0., 0.), (0., 0.)),\\n ((0., 0.), (1., 1.))), dtype=numpy.float32)\\n level = 0.5\\n vertices, normals, indices = marchingcubes.MarchingCubes(cube, level)\\n self.assertAllClose(normals[:, 2], 0.)\\n self.assertEqual(len(indices), 2)\",\n \"def renormalize_by_spectrum(self, spectrum, dispersion='match', trim_mode='wav', inplace=False):\\n\\n spec = self.copy()\\n spec2 = spectrum.copy()\\n\\n\\n\\n if dispersion == \\\"match\\\":\\n spec.match_dispersions(spec2, match_secondary=False,\\n force=True, interp_kind='linear')\\n elif isinstance(dispersion,(list,)):\\n spec.trim_dispersion(dispersion, mode=trim_mode,inplace=True)\\n spec2.trim_dispersion(dispersion, mode=trim_mode,inplace=True)\\n else:\\n print(\\\"Spectra will be normalized but dispersion ranges do not necessarily match!\\\")\\n\\n\\n\\n average_self_flux = np.trapz(spec.flux, spec.dispersion)\\n\\n average_spec_flux = np.trapz(spec2.flux, spec2.dispersion)\\n\\n self.scale = (average_spec_flux/average_self_flux)\\n\\n if inplace:\\n self.flux_scale_factor = average_spec_flux/average_self_flux\\n self.flux = self.flux * (average_spec_flux/average_self_flux)\\n else:\\n spec = self.copy()\\n spec.flux_scale_factor = average_spec_flux/average_self_flux\\n flux = self.flux * (average_spec_flux/average_self_flux)\\n spec.scale = self.scale\\n spec.flux = flux\\n\\n return spec\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6274869","0.6003347","0.5845092","0.5763128","0.56499904","0.55344087","0.55215806","0.5233117","0.5228521","0.5198386","0.5195983","0.51448613","0.51295257","0.5123832","0.5117463","0.51086575","0.50924385","0.50752395","0.50532764","0.50532764","0.5052271","0.50365114","0.5025228","0.50172853","0.5015062","0.5012336","0.4975221","0.49724463","0.49710262","0.49196136","0.49007583","0.4900698","0.4900346","0.4891247","0.4885221","0.4860859","0.48404178","0.48402235","0.4820574","0.48204738","0.480184","0.4785572","0.47796574","0.47740465","0.47661477","0.47643927","0.47620404","0.475683","0.47519076","0.47509867","0.4749234","0.47371456","0.47307917","0.47108462","0.47048205","0.4703442","0.46905604","0.4690285","0.4689738","0.468495","0.46820685","0.46804237","0.46726337","0.46576995","0.46557364","0.46481502","0.4635168","0.4621581","0.46198994","0.45973504","0.45792174","0.45642567","0.45621473","0.4559502","0.45522472","0.4530181","0.45266446","0.4519136","0.45016694","0.4492197","0.4490549","0.4490534","0.44805542","0.44715863","0.4471233","0.4459253","0.44430622","0.44387823","0.4434728","0.44304976","0.44263178","0.44087338","0.44047585","0.44024912","0.43990302","0.43935245","0.4386353","0.43849546","0.43734592","0.43701953"],"string":"[\n \"0.6274869\",\n \"0.6003347\",\n \"0.5845092\",\n \"0.5763128\",\n \"0.56499904\",\n \"0.55344087\",\n \"0.55215806\",\n \"0.5233117\",\n \"0.5228521\",\n \"0.5198386\",\n \"0.5195983\",\n \"0.51448613\",\n \"0.51295257\",\n \"0.5123832\",\n \"0.5117463\",\n \"0.51086575\",\n \"0.50924385\",\n \"0.50752395\",\n \"0.50532764\",\n \"0.50532764\",\n \"0.5052271\",\n \"0.50365114\",\n \"0.5025228\",\n \"0.50172853\",\n \"0.5015062\",\n \"0.5012336\",\n \"0.4975221\",\n \"0.49724463\",\n \"0.49710262\",\n \"0.49196136\",\n \"0.49007583\",\n \"0.4900698\",\n \"0.4900346\",\n \"0.4891247\",\n \"0.4885221\",\n \"0.4860859\",\n \"0.48404178\",\n \"0.48402235\",\n \"0.4820574\",\n \"0.48204738\",\n \"0.480184\",\n \"0.4785572\",\n \"0.47796574\",\n \"0.47740465\",\n \"0.47661477\",\n \"0.47643927\",\n \"0.47620404\",\n \"0.475683\",\n \"0.47519076\",\n \"0.47509867\",\n \"0.4749234\",\n \"0.47371456\",\n \"0.47307917\",\n \"0.47108462\",\n \"0.47048205\",\n \"0.4703442\",\n \"0.46905604\",\n \"0.4690285\",\n \"0.4689738\",\n \"0.468495\",\n \"0.46820685\",\n \"0.46804237\",\n \"0.46726337\",\n \"0.46576995\",\n \"0.46557364\",\n \"0.46481502\",\n \"0.4635168\",\n \"0.4621581\",\n \"0.46198994\",\n \"0.45973504\",\n \"0.45792174\",\n \"0.45642567\",\n \"0.45621473\",\n \"0.4559502\",\n \"0.45522472\",\n \"0.4530181\",\n \"0.45266446\",\n \"0.4519136\",\n \"0.45016694\",\n \"0.4492197\",\n \"0.4490549\",\n \"0.4490534\",\n \"0.44805542\",\n \"0.44715863\",\n \"0.4471233\",\n \"0.4459253\",\n \"0.44430622\",\n \"0.44387823\",\n \"0.4434728\",\n \"0.44304976\",\n \"0.44263178\",\n \"0.44087338\",\n \"0.44047585\",\n \"0.44024912\",\n \"0.43990302\",\n \"0.43935245\",\n \"0.4386353\",\n \"0.43849546\",\n \"0.43734592\",\n \"0.43701953\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.8686489"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":24984,"cells":{"query":{"kind":"string","value":"Returns a numpy array containing the time values for the cube's time dimension, as well as the unit used."},"document":{"kind":"string","value":"def time_axis(self):\n if self.axes_wcs.wcs.ctype[0] not in ['TIME', 'UTC']:\n raise cu.CubeError(1, 'No time axis present')\n delta = self.axes_wcs.wcs.cdelt[0]\n crpix = self.axes_wcs.wcs.crpix[0]\n crval = self.axes_wcs.wcs.crval[0]\n start = crval - crpix * delta\n stop = start + len(self.data) * delta\n cunit = u.Unit(self.axes_wcs.wcs.cunit[0])\n return np.linspace(start, stop, num=self.data.shape[-1]) * cunit"},"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 time(self):\n return self.time_array","def time_axis_array(self):\n return self._time_axis.get_array()","def arr_time(self):\n return self._arr_time","def times(self):\n if self._times is None:\n self._times = np.zeros((self.ntimestep), dtype=np.float64)\n for record in range(self.ntimestep):\n self._times[record] = self.get_data_time(record)\n\n return self._times","def _write_time_cube(self, cube, key_list):\n data = cube.data[:]\n coords = cube.coord('time')[:]\n for t in range(0, data.shape[0]):\n value = round_variable(self.input_data.get_value(\n InputType.VARIABLE)[0], data[t])\n with iris.FUTURE.context(cell_datetime_objects=True):\n time_str = coords[t].cell(\n 0).point.strftime('%Y-%m-%d')\n try:\n self.data_dict[time_str].append(value)\n except KeyError:\n key_list.append(time_str)\n self.data_dict[time_str] = [value]","def get_time(start, stop, step = 1):\n # reshape array into columns from row\n return numpy.reshape(numpy.array(range(start, stop, step)), (-1,1))","def time_list(self):\n return (self.N_T * (np.arange(self.N_itr) + 1) /\n self.N_itr * 1000 * self.DT)","def rt_arr_time(self):\n return self._rt_arr_time","def get_time(self):\n return numpy.linspace(self.header.time_gate_start, \\\n self.header.time_gate_stop, self.num_time_bins())","def time(self):\n return self[self.time_columns]","def time(self):\n return self[self.time_columns]","def unit_array(self):\n return self._data_array.values * units(self._units)","def get_tim(self):\n return self.sum(axis=0)","def conv_time_units(cube1,cube2):\n time_coord1=cube1.coord('time')\n time_units1=time_coord1.units\n #\n time_coord2=cube2.coord('time')\n time_units2=time_coord2.units\n #\n new_time_vals=[time_units2.date2num(time_units1.num2date(xx)) for xx in time_coord1.points]\n new_time_coord=iris.coords.DimCoord(new_time_vals,standard_name='time',units=time_units2)\n #\n coord_names=[dimc.standard_name for dimc in cube1.dim_coords]\n time_index=coord_names.index('time')\n cube1.remove_coord('time')\n cube1.add_dim_coord(new_time_coord,time_index)","def get_time_unit(self, variables):\n if len(self.TIME_VARIABLE):\n # times = self._get_variable(variables, self.TIME_VARIABLE)[:]\n units = variables['time'].units\n return units\n else:\n return \"\"","def _generate_time_values(self):\r\n # Populate time values\r\n log('writing times', 'INFO')\r\n d1970 = datetime(1970, 1, 1, tzinfo=utc)\r\n time_array = [[int((self.start_datetime - d1970).total_seconds())]]\r\n \r\n datetime_nc_start_simulation = self.start_datetime\r\n for raw_nc_index, raw_nc in enumerate(self.raw_nc_list):\r\n \r\n raw_nc_time = raw_nc.get_time_array(datetime_simulation_start=datetime_nc_start_simulation,\r\n simulation_time_step_seconds=self.time_step_array[raw_nc_index])\r\n \r\n time_array.append(raw_nc_time)\r\n datetime_nc_start_simulation = datetime.utcfromtimestamp(raw_nc_time[-1])\r\n \r\n self.cf_nc.variables['time'][:] = np.concatenate(time_array)\r\n end_date = datetime.utcfromtimestamp(self.cf_nc.variables['time'][-1])\r\n self.cf_nc.time_coverage_start = self.start_datetime.isoformat() + 'Z'\r\n self.cf_nc.time_coverage_end = end_date.isoformat() + 'Z'","def result_array(self) -> np.ndarray:\n return np.array([r[\"time\"] for r in self.profile_result])","def get_time_slices(self):\n tot = []\n for clu in self._clusters:\n tot.extend(self._clusters[clu].to_dict()[:])\n #tot.sort()\n return tot","def _calc_time(time_lines: list) -> np.ndarray:\n time = [time_to_fraction_hour(line.split()[1]) for line in time_lines]\n return np.array(time)","def zeros(self):\n super(TimeCube, self).zeros()\n self.data = np.zeros([self.time_range[1]-self.time_range[0]]+self.cubesize, np.uint8)","def time(self):\n self.convert_window(\"Time\", \"seconds\", [\"centuries\", \"days\", \"decades\", \"femtoseconds\", \"fortnights\", \"hours\", \"microseconds\", \"millenia\", \"milliseconds\", \"minutes\", \"months(Common)\", \"months(Synodic)\", \"nanoseconds\", \"picoseconds\", \"quarters(Common)\", \"seconds\", \"shakes\", \"weeks\", \"years(Average Gregorian)\", \"years(Common)\", \"years(Julian)\", \"years(Leap)\", \"years(Tropical)\"])","def getTimeUnits(self):\n return _libsbml.Event_getTimeUnits(self)","def time(self):\r\n return UniformTime(length=self.__len__(), t0=self.t0,\r\n sampling_interval=self.sampling_interval,\r\n time_unit=self.time_unit)","def get_itime_section_data(date, time):\n return np.array([time, date.day, date.month, date.year, -2345, 1, 0, -2345, -2345, -2345, 0, 0, 0])","def time_units(self) -> str:\n return self._ll_tree_sequence.get_time_units()","def test_TimeArray_convert_unit():","def time_average(new_cube):\n\n time_average_cube = new_cube.collapsed('time', iris.analysis.MEAN)\n\n return time_average_cube","def getTimeUnits(self):\n return _libsbml.Model_getTimeUnits(self)","def get_time_array(array, axis_of_time_steps=2, start=0., end=1.):\r\n number_of_time_steps = np.shape(array)[axis_of_time_steps]\r\n return np.linspace(start, end, number_of_time_steps)","def get_time(self):\n return self._ticks","def getTimeUnits(self):\n return _libsbml.KineticLaw_getTimeUnits(self)","def test_get_integration_time_vals():\n test_file = os.path.join(DATA_PATH, \"paper_test_file.uvh5\")\n test_uv = UVData()\n test_uv.read(test_file)\n\n baseline_array = np.array(list(set(test_uv.baseline_array)))\n inttime_array = utils.get_integration_time(test_uv, reds=baseline_array)\n test_shape = (test_uv.Nbls, test_uv.Ntimes)\n test_array = test_uv.integration_time.copy()\n test_array = test_array.reshape(test_shape)\n assert np.allclose(test_array, inttime_array)","def t(self: Q) -> np.array:\n\n return np.array([self.t])","def get_time_step_values(self):\n return TensorMeshReader.get_time_step_values(self)","def get_time_step_values(self):\n return DiscretizeMeshReader.get_time_step_values(self)","def get_time_step_values(self):\n return MagObsReader.get_time_step_values(self)","def ensemble_times(self):\n return self['validtime'].values","def unit_ms(self):\n return (self.time_base / 1000.0) / 60.0","def get_time_step_values(self):\n return TensorMeshAppender.get_time_step_values(self)","def at(self, t):\r\n return TimeArray(self[self.index_at(t)], time_unit=self.time_unit)","def get_times(self):\n times = []\n for i in range(1, len(self.events)):\n times.append(self.events[i-1].elapsed_time(self.events[i]))\n return times","def getTimes():","def getTimes():","def getTimes():","def get_time(self, variables):\n if len(self.TIME_VARIABLE):\n return self._get_variable(variables, self.TIME_VARIABLE)\n else:\n return [0.]","def tas_cubes():\n ta_cube = iris.cube.Cube([1.0], var_name='ta')\n tas_cube = iris.cube.Cube([3.0], var_name='tas')\n return iris.cube.CubeList([ta_cube, tas_cube])","def get_time_step_values(self):\n return GravObsReader.get_time_step_values(self)","def get_timevars(chid):\n ftype = promote_type(chid, use_time=True)\n dat = (1*dbr.Map[ftype])()\n\n ret = libca.ca_array_get(ftype, 1, chid, dat)\n PySEVCHK('get_timevars', ret)\n poll()\n out = {}\n val = dat[0]\n for attr in ('status', 'severity', 'timestamp'):\n if hasattr(val, attr):\n out[attr] = getattr(val, attr)\n return out","def create_space_time_cube(point_layer: _FeatureSet,\r\n bin_size: float,\r\n bin_size_unit: str,\r\n time_step_interval: int,\r\n time_step_interval_unit: str,\r\n time_step_alignment: str=None,\r\n time_step_reference: _datetime=None,\r\n summary_fields: str=None,\r\n output_name: str=None,\r\n context: str=None,\r\n gis=None) -> DataFile:\r\n kwargs=locals()\r\n\r\n gis=_arcgis.env.active_gis if gis is None else gis\r\n url=gis.properties.helperServices.geoanalytics.url\r\n\r\n params={}\r\n for key, value in kwargs.items():\r\n if value is not None:\r\n params[key]=value\r\n\r\n _set_context(params)\r\n\r\n param_db={\r\n \"point_layer\": (_FeatureSet, \"pointLayer\"),\r\n \"bin_size\": (float, \"binSize\"),\r\n \"bin_size_unit\": (str, \"binSizeUnit\"),\r\n \"time_step_interval\": (int, \"timeStepInterval\"),\r\n \"time_step_interval_unit\": (str, \"timeStepIntervalUnit\"),\r\n \"time_step_alignment\": (str, \"timeStepAlignment\"),\r\n \"time_step_reference\": (_datetime, \"timeStepReference\"),\r\n \"summary_fields\": (str, \"summaryFields\"),\r\n \"output_name\": (str, \"outputName\"),\r\n \"context\": (str, \"context\"),\r\n \"output_cube\": (DataFile, \"Output Space Time Cube\"),\r\n }\r\n return_values=[\r\n {\"name\": \"output_cube\", \"display_name\": \"Output Space Time Cube\", \"type\": DataFile},\r\n ]\r\n\r\n return _execute_gp_tool(gis, \"CreateSpaceTimeCube\", params, param_db, return_values, _use_async, url, True)","def times(self) -> int:\n return self._channel_arrays[0].shape[self.time_pos]","def measurements(self) -> NONEARRAY:\n pass","def read_times(self, slices=None):\n times = netCDF4.num2date(\n datetime.strptime(\n self.get_handler().SOURCE_START_DATE.split('.')[0],\n '%Y%m%d%H%M%S'\n )\n )\n return numpy.ma.array([times])","def _unit_ms(self):\n return (self.time_base / 1000.0) / 60.0","def time_analysis(self, method='MEAN'):\n self.cube = self.cube_coordinate_analysis(self.cube, self.time_coord, \n method)\n self.processes.append('time_analysis')\n return self.cube","def convert_to_joules(cube):\n\n assert 'W' in str(cube.units)\n assert 'days' in str(cube.coord('time').units)\n \n time_span_days = cube.coord('time').bounds[:, 1] - cube.coord('time').bounds[:, 0]\n time_span_seconds = time_span_days * 60 * 60 * 24\n \n cube.data = cube.data * uconv.broadcast_array(time_span_seconds, 0, cube.shape)\n cube.units = str(cube.units).replace('W', 'J')\n \n return cube","def std(self, *args, **kwargs):\r\n ret = TimeArray(np.ndarray.std(self, *args,**kwargs),\r\n time_unit=base_unit)\r\n ret.convert_unit(self.time_unit)\r\n return ret","def peak_time(self):\n return np.array([self.wftime[ch][self.waveform[ch].argmax()] for ch in range(self.nchannels)])","def __repr__(self):\r\n\r\n # If the input is a single int/float (with no shape) return a 'scalar'\r\n # time-point:\r\n if self.shape == ():\r\n return \"%r %s\" % (int(self) / float(self._conversion_factor),\r\n self.time_unit)\r\n # Otherwise, return the TimeArray representation:\r\n else:\r\n return np.ndarray.__repr__(self / float(self._conversion_factor)\r\n )[:-1] + \", time_unit='%s')\" % self.time_unit","def get_time_col(self):\n return self.time_col","def load_time(self) -> Tuple[np.ndarray, np.ndarray]:\n # filename = self.casedir / Path(\"times.txt\")\n filename = self.casedir\n assert filename.exists(), \"Cannot find {filename}\".format(filename=filename)\n return load_times(filename)","def _get_time(self) -> None:\n self.data[\"time\"] = np.zeros(len(self.data[\"yyyymmdd\"]), dtype=object)\n \n for idx, (yyyymmdd, hhmmss) in enumerate(zip(self.data[\"yyyymmdd\"], self.data[\"hhmmss\"])):\n year, month, day = yyyymmdd.split(\"/\")\n hour, minute, second = hhmmss.split(\":\")\n self.data[\"time\"][idx] = datetime(int(year), int(month), int(day), int(hour), int(minute), int(second))\n \n del self.data[\"yyyymmdd\"]\n del self.data[\"hhmmss\"]","def test_TimeArray_repr():","def get_time_points(self):\n return self._time","def get_time_cols(self):\n # Retrieve first column only\n time_cols = list()\n n = self.col_count\n for i in range(n): # check every column/attribute for time format\n row_data = str(self.data[0][i])\n try:\n time_ok, t_stamp = DataGP.test_time(row_data)\n if time_ok:\n time_cols.append(i)\n except ValueError:\n continue\n return np.array(time_cols)","def timeTime(self):\n return self._micros / 1000000.0","def u_t(self):\n\t\tdim = self.dim \n\t\ttim_all = self.tim_all\n\t\t#ctrl = self.ctrl\n\t\tH0 = self.H0\n\t\tHctrl = self.Hctrl\n\n\t\tu_all = np.zeros((tim_all+1,dim,dim),dtype = complex)\n\t\tu_all[0,:,:] = np.eye(dim)\n\n\t\tfor tim in xrange(tim_all):\n\t\t\tH = H0 + Hctrl[tim]#np.matrix( ctrl[i,tim] * np.array(Hctrl[i]))\n\t\t\tu_all[tim+1,:,:] = np.dot(self.u_dt(H,tim), u_all[tim,:,:])\n\n\n\t\treturn u_all","def test_get_integration_time_shape():\n test_file = os.path.join(DATA_PATH, \"paper_test_file.uvh5\")\n test_uv = UVData()\n test_uv.read(test_file)\n\n baseline_array = np.array(list(set(test_uv.baseline_array)))\n inttime_array = utils.get_integration_time(test_uv, reds=baseline_array)\n test_shape = (test_uv.Nbls, test_uv.Ntimes)\n assert test_shape == inttime_array.shape","def time_analysis(self, method='MEAN'):\n new_cubelist = []\n for cube in self.cubelist:\n new_cubelist.append(self.cube_coordinate_analysis(cube, \n self.time_coord, \n method))\n self.cubelist = iris.cube.CubeList(new_cubelist)\n self.processes.append('time_analysis')\n return self.cubelist","def __getTimeEvolution(self, target):\n omega = np.log(self._eigs[target]) / self.timeScales['training']['dt']\n van = np.exp(np.multiply(*np.meshgrid(omega, self._getTimeScale())))\n timeEvol = (van * self._amplitudes[target]).T\n return timeEvol","def readAll():\n result = _rc.readAttribute(OPTYPE.TIME_OF_FLIGHT)\n mm = bytesToIntArray(result, 2, signed=False)\n return [mm[0] / 10, mm[1] / 10]","def total_time(self):\n obs_times = self.clean_obs_times()\n return _np.sum(obs_times[:, 1] - obs_times[:, 0])","def test_fix_metadata_correct_time(self):\n fixed_cube = self.fix.fix_metadata([self.cube])[0]\n time_coord = fixed_cube.coord('time')\n np.testing.assert_allclose(time_coord.points, [0, 1])\n assert time_coord.bounds is None","def collapse_time(cube, ntimes, timestep):\n\n if timestep == None:\n print('Averaging over the %s time points' %(str(ntimes)))\n new_cube = cube.collapsed('time', iris.analysis.MEAN)\n else:\n assert new_cube.coords()[0] == 'time'\n new_cube = cube[timestep, :, :]\n\n return new_cube","def gen_time_axis(self):\n try:\n t_explosion = datetime.strptime(self.explosion_date, \"%Y %m %d\")\n t_since_explosion = []\n for i in range(len(self.year)):\n t_i = datetime.strptime(\n \"%d-%d-%d\" % (self.year[i], self.month[i], self.day[i]), \"%Y-%m-%d\")\n t_since_explosion.append((t_i - t_explosion).days)\n self.t = np.asarray(t_since_explosion)\n self.has_explosion_time = True\n return np.asarray(t_since_explosion)\n except TypeError:\n pass","def getDuration(self):\n #return np.sum(self.subintinfo['TSUBINT']) #This is constant.\n return np.sum(self.getSubintinfo('TSUBINT')) #This is constant.","def get_time_step_values(self):\n if self.need_to_read():\n self._read_up_front()\n return self._timesteps if self._timesteps is not None else None","def _return(self, ary, **kwargs):\n return TimeSamples(ary)","def energy_to_time(energy_ev=[], delay_us=np.NaN, source_to_detector_cm=np.NaN):\n # delay values is normal 2.99 us with NONE actual MCP delay settings\n energy_mev = energy_ev * 1000\n time_tot_us = np.sqrt(81.787 / energy_mev) * source_to_detector_cm / 0.3956\n time_record_us = time_tot_us - delay_us\n time_record_ns = time_record_us * 1000\n time_record_s = time_record_us / 1e6\n return time_record_us","def time_speed(self):\n time_speed = []\n for i in range (len(np.unique(self.pd.objid))):\n trajec = self.dataset.trajec(self.dataset.keys[i])\n times = trajec.time_epoch_secs + trajec.time_epoch_nsecs / 1e9\n time_speedy = np.vstack([times, trajec.speed])\n time_speed.append(time_speedy)\n return time_speed","def get_reltriggertimes(self):\n return np.array(self.trtimes)-self.soundstarttime","def get_measurements_by_time(self):\n data_path = os.path.abspath(\n os.path.join(\n os.path.dirname(os.path.realpath(__file__)),\n \"..\",\n \"data/NVB_rescale_dataset.p\",\n )\n )\n self.log_print([\"Getting experimental data from {}\".format(data_path)])\n self.measurements = pickle.load(open(data_path, \"rb\"))\n return self.measurements","def __get_time_span(self):\n\n nonzero = self.data[\"time\"].nonzero()\n return iso_time.time(self.data[\"time\"][nonzero[0][0]]), iso_time.time(\n self.data[\"time\"][nonzero[0][-1]])","def get_time_step_values(self):\n return GravGradReader.get_time_step_values(self)","def __get_times(self):\n data = self.simulate_file.readlines()\n data = list(map(str.strip, data))\n data = list(map(float, data))\n start = data[0]\n times = data[1:]\n return (start, times)","def samples(self):\n return np.full(self.duration, self._value)","def speed(data_array, time=1):\n dst = DataOperation.geo_m(data_array)\n speed_values = np.zeros(dst.size)\n count = 0\n for d in dst:\n speed_values[count] = d/time * 3.6# dystans jest w m, przedzial czasowy 1 s, a chcemy k/h\n count += 1\n return speed_values","def get_times(self):\n raise NotImplementedError(\"Abstract method not implemented.\")","def transit_times(self):\n try:\n self._transit_times\n self.nt\n except:\n return np.array([], dtype=float)\n return self._transit_times[:self.nt]","def calculate_time(ix, xi, wf):\n wf_len = len(wf)\n x_time = np.arange(ix, (ix + wf_len * xi), xi)\n return x_time","def _load_time(self):\n\n time_variables = ('time', 'Times', 'Itime', 'Itime2')\n got_time, missing_time = [], []\n for time in time_variables:\n # Since not all of the time_variables specified above are required, only try to load the data if they\n # exist. We'll raise an error if we don't find any of them though.\n if time in self.ds.variables:\n setattr(self.time, time, self.ds.variables[time][:])\n got_time.append(time)\n attributes = type('attributes', (object,), {})()\n for attribute in self.ds.variables[time].ncattrs():\n setattr(attributes, attribute, getattr(self.ds.variables[time], attribute))\n setattr(self.atts, time, attributes)\n else:\n missing_time.append(time)\n\n if len(missing_time) == len(time_variables):\n warn('No time variables found in the netCDF.')\n else:\n if 'Times' in got_time:\n # Overwrite the existing Times array with a more sensibly shaped one.\n self.time.Times = np.asarray([''.join(t.astype(str)).strip() for t in self.time.Times])\n\n # Make whatever we got into datetime objects and use those to make everything else. Note: the `time' variable\n # is often the one with the lowest precision, so use the others preferentially over that.\n if 'Times' not in got_time:\n if 'time' in got_time:\n _dates = num2date(self.time.time, units=getattr(self.ds.variables['time'], 'units'))\n elif 'Itime' in got_time and 'Itime2' in got_time:\n _dates = num2date(self.time.Itime + self.time.Itime2 / 1000.0 / 60 / 60, units=getattr(self.ds.variables['Itime'], 'units'))\n try:\n self.time.Times = np.array([datetime.strftime(d, '%Y-%m-%dT%H:%M:%S.%f') for d in _dates])\n except ValueError:\n self.time.Times = np.array([datetime.strftime(d, '%Y/%m/%d %H:%M:%S.%f') for d in _dates])\n # Add the relevant attribute for the Times variable.\n attributes = type('attributes', (object,), {})()\n setattr(attributes, 'time_zone', 'UTC')\n setattr(self.atts, 'Times', attributes)\n\n if 'time' not in got_time:\n if 'Times' in got_time:\n try:\n _dates = np.array([datetime.strptime(''.join(t.astype(str)).strip(), '%Y-%m-%dT%H:%M:%S.%f') for t in self.time.Times])\n except ValueError:\n _dates = np.array([datetime.strptime(''.join(t.astype(str)).strip(), '%Y/%m/%d %H:%M:%S.%f') for t in self.time.Times])\n elif 'Itime' in got_time and 'Itime2' in got_time:\n _dates = num2date(self.time.Itime + self.time.Itime2 / 1000.0 / 60 / 60, units=getattr(self.ds.variables['Itime'], 'units'))\n # We're making Modified Julian Days here to replicate FVCOM's 'time' variable.\n self.time.time = date2num(_dates, units='days since 1858-11-17 00:00:00')\n # Add the relevant attributes for the time variable.\n attributes = type('attributes', (object,), {})()\n setattr(attributes, 'units', 'days since 1858-11-17 00:00:00')\n setattr(attributes, 'long_name', 'time')\n setattr(attributes, 'format', 'modified julian day (MJD)')\n setattr(attributes, 'time_zone', 'UTC')\n setattr(self.atts, 'time', attributes)\n\n if 'Itime' not in got_time and 'Itime2' not in got_time:\n if 'Times' in got_time:\n try:\n _dates = np.array([datetime.strptime(''.join(t.astype(str)).strip(), '%Y-%m-%dT%H:%M:%S.%f') for t in self.time.Times])\n except ValueError:\n _dates = np.array([datetime.strptime(''.join(t.astype(str)).strip(), '%Y/%m/%d %H:%M:%S.%f') for t in self.time.Times])\n elif 'time' in got_time:\n _dates = num2date(self.time.time, units=getattr(self.ds.variables['time'], 'units'))\n # We're making Modified Julian Days here to replicate FVCOM's 'time' variable.\n _datenum = date2num(_dates, units='days since 1858-11-17 00:00:00')\n self.time.Itime = np.floor(_datenum)\n self.time.Itime2 = (_datenum - np.floor(_datenum)) * 1000 * 60 * 60 # microseconds since midnight\n attributes = type('attributes', (object,), {})()\n setattr(attributes, 'units', 'days since 1858-11-17 00:00:00')\n setattr(attributes, 'format', 'modified julian day (MJD)')\n setattr(attributes, 'time_zone', 'UTC')\n setattr(self.atts, 'Itime', attributes)\n attributes = type('attributes', (object,), {})()\n setattr(attributes, 'units', 'msec since 00:00:00')\n setattr(attributes, 'time_zone', 'UTC')\n setattr(self.atts, 'Itime2', attributes)\n\n # Additional nice-to-have time representations.\n if 'Times' in got_time:\n try:\n self.time.datetime = np.array([datetime.strptime(d, '%Y-%m-%dT%H:%M:%S.%f') for d in self.time.Times])\n except ValueError:\n self.time.datetime = np.array([datetime.strptime(d, '%Y/%m/%d %H:%M:%S.%f') for d in self.time.Times])\n attributes = type('attributes', (object,), {})()\n setattr(attributes, 'long_name', 'Python datetime.datetime')\n setattr(self.atts, 'datetime', attributes)\n else:\n self.time.datetime = _dates\n self.time.matlabtime = self.time.time + 678942.0 # convert to MATLAB-indexed times from Modified Julian Date.\n attributes = type('attributes', (object,), {})()\n setattr(attributes, 'long_name', 'MATLAB datenum')\n setattr(self.atts, 'matlabtime', attributes)\n\n # Clip everything to the time indices if we've been given them. Update the time dimension too.\n if 'time' in self._dims:\n if all([isinstance(i, (datetime, str)) for i in self._dims['time']]):\n # Convert datetime dimensions to indices in the currently loaded data.\n self._dims['time'][0] = self.time_to_index(self._dims['time'][0])\n self._dims['time'][1] = self.time_to_index(self._dims['time'][1]) + 1 # make the indexing inclusive\n for time in self.obj_iter(self.time):\n setattr(self.time, time, getattr(self.time, time)[self._dims['time'][0]:self._dims['time'][1]])\n self.dims.time = len(self.time.time)","def time_grid(time_step=30):\n if time_step < 1 or time_step > 60:\n raise ValueError('Time resolution should be between 0 and 60 [s]')\n half_step = time_step/SECONDS_PER_HOUR/2\n return np.arange(half_step, 24+half_step, half_step*2)","def get_time_nc(nc_file, tv='time'):\n from netCDF4 import MFDataset,num2date\n\n ds = MFDataset(nc_file)\n try:\n time = ds.variables[tv]\n except:\n tv='time_counter'\n ds.close()\n\n try:\n ds = MFDataset(nc_file)\n time = ds.variables[tv]\n if (hasattr(time , 'units') and hasattr(time , 'calendar')) == True:\n timestamps = num2date(time[:], time.units , time.calendar)\n elif hasattr(time , 'units'):\n timestamps = num2date(time[:], time.units)\n else:\n timestamps = num2date(time[:])\n ds.close()\n except Exception as e:\n raise Exception\n return timestamps","def get_time(self) -> float:\n raise NotImplementedError()","def time_division(annuli):\n \n time_div=np.empty(len(annuli),dtype=int)\n for annulus in range(len(annuli)):\n r = annuli[annulus]\n time_div[annulus]=int(viscous_timescale(r) * sample_ratio)\n return time_div","def get_time_step_values(self):\n return OcTreeReader.get_time_step_values(self)","def get_time_step_values(self):\n return TopoReader.get_time_step_values(self)","def test_TimeArray_init_int64():\r\n time = ts.TimeArray(np.int64(1))\r\n npt.assert_equal(time.__repr__(), '1.0 s')\r\n\r\n pass","def getTime(self) -> float:\n return self.t","def get_time(self):\n clock = self.pipeline.get_clock()\n tm = clock.get_internal_time()\n return tm / 1.e9","def n(self):\n return self._time_axis.size"],"string":"[\n \"def time(self):\\n return self.time_array\",\n \"def time_axis_array(self):\\n return self._time_axis.get_array()\",\n \"def arr_time(self):\\n return self._arr_time\",\n \"def times(self):\\n if self._times is None:\\n self._times = np.zeros((self.ntimestep), dtype=np.float64)\\n for record in range(self.ntimestep):\\n self._times[record] = self.get_data_time(record)\\n\\n return self._times\",\n \"def _write_time_cube(self, cube, key_list):\\n data = cube.data[:]\\n coords = cube.coord('time')[:]\\n for t in range(0, data.shape[0]):\\n value = round_variable(self.input_data.get_value(\\n InputType.VARIABLE)[0], data[t])\\n with iris.FUTURE.context(cell_datetime_objects=True):\\n time_str = coords[t].cell(\\n 0).point.strftime('%Y-%m-%d')\\n try:\\n self.data_dict[time_str].append(value)\\n except KeyError:\\n key_list.append(time_str)\\n self.data_dict[time_str] = [value]\",\n \"def get_time(start, stop, step = 1):\\n # reshape array into columns from row\\n return numpy.reshape(numpy.array(range(start, stop, step)), (-1,1))\",\n \"def time_list(self):\\n return (self.N_T * (np.arange(self.N_itr) + 1) /\\n self.N_itr * 1000 * self.DT)\",\n \"def rt_arr_time(self):\\n return self._rt_arr_time\",\n \"def get_time(self):\\n return numpy.linspace(self.header.time_gate_start, \\\\\\n self.header.time_gate_stop, self.num_time_bins())\",\n \"def time(self):\\n return self[self.time_columns]\",\n \"def time(self):\\n return self[self.time_columns]\",\n \"def unit_array(self):\\n return self._data_array.values * units(self._units)\",\n \"def get_tim(self):\\n return self.sum(axis=0)\",\n \"def conv_time_units(cube1,cube2):\\n time_coord1=cube1.coord('time')\\n time_units1=time_coord1.units\\n #\\n time_coord2=cube2.coord('time')\\n time_units2=time_coord2.units\\n #\\n new_time_vals=[time_units2.date2num(time_units1.num2date(xx)) for xx in time_coord1.points]\\n new_time_coord=iris.coords.DimCoord(new_time_vals,standard_name='time',units=time_units2)\\n #\\n coord_names=[dimc.standard_name for dimc in cube1.dim_coords]\\n time_index=coord_names.index('time')\\n cube1.remove_coord('time')\\n cube1.add_dim_coord(new_time_coord,time_index)\",\n \"def get_time_unit(self, variables):\\n if len(self.TIME_VARIABLE):\\n # times = self._get_variable(variables, self.TIME_VARIABLE)[:]\\n units = variables['time'].units\\n return units\\n else:\\n return \\\"\\\"\",\n \"def _generate_time_values(self):\\r\\n # Populate time values\\r\\n log('writing times', 'INFO')\\r\\n d1970 = datetime(1970, 1, 1, tzinfo=utc)\\r\\n time_array = [[int((self.start_datetime - d1970).total_seconds())]]\\r\\n \\r\\n datetime_nc_start_simulation = self.start_datetime\\r\\n for raw_nc_index, raw_nc in enumerate(self.raw_nc_list):\\r\\n \\r\\n raw_nc_time = raw_nc.get_time_array(datetime_simulation_start=datetime_nc_start_simulation,\\r\\n simulation_time_step_seconds=self.time_step_array[raw_nc_index])\\r\\n \\r\\n time_array.append(raw_nc_time)\\r\\n datetime_nc_start_simulation = datetime.utcfromtimestamp(raw_nc_time[-1])\\r\\n \\r\\n self.cf_nc.variables['time'][:] = np.concatenate(time_array)\\r\\n end_date = datetime.utcfromtimestamp(self.cf_nc.variables['time'][-1])\\r\\n self.cf_nc.time_coverage_start = self.start_datetime.isoformat() + 'Z'\\r\\n self.cf_nc.time_coverage_end = end_date.isoformat() + 'Z'\",\n \"def result_array(self) -> np.ndarray:\\n return np.array([r[\\\"time\\\"] for r in self.profile_result])\",\n \"def get_time_slices(self):\\n tot = []\\n for clu in self._clusters:\\n tot.extend(self._clusters[clu].to_dict()[:])\\n #tot.sort()\\n return tot\",\n \"def _calc_time(time_lines: list) -> np.ndarray:\\n time = [time_to_fraction_hour(line.split()[1]) for line in time_lines]\\n return np.array(time)\",\n \"def zeros(self):\\n super(TimeCube, self).zeros()\\n self.data = np.zeros([self.time_range[1]-self.time_range[0]]+self.cubesize, np.uint8)\",\n \"def time(self):\\n self.convert_window(\\\"Time\\\", \\\"seconds\\\", [\\\"centuries\\\", \\\"days\\\", \\\"decades\\\", \\\"femtoseconds\\\", \\\"fortnights\\\", \\\"hours\\\", \\\"microseconds\\\", \\\"millenia\\\", \\\"milliseconds\\\", \\\"minutes\\\", \\\"months(Common)\\\", \\\"months(Synodic)\\\", \\\"nanoseconds\\\", \\\"picoseconds\\\", \\\"quarters(Common)\\\", \\\"seconds\\\", \\\"shakes\\\", \\\"weeks\\\", \\\"years(Average Gregorian)\\\", \\\"years(Common)\\\", \\\"years(Julian)\\\", \\\"years(Leap)\\\", \\\"years(Tropical)\\\"])\",\n \"def getTimeUnits(self):\\n return _libsbml.Event_getTimeUnits(self)\",\n \"def time(self):\\r\\n return UniformTime(length=self.__len__(), t0=self.t0,\\r\\n sampling_interval=self.sampling_interval,\\r\\n time_unit=self.time_unit)\",\n \"def get_itime_section_data(date, time):\\n return np.array([time, date.day, date.month, date.year, -2345, 1, 0, -2345, -2345, -2345, 0, 0, 0])\",\n \"def time_units(self) -> str:\\n return self._ll_tree_sequence.get_time_units()\",\n \"def test_TimeArray_convert_unit():\",\n \"def time_average(new_cube):\\n\\n time_average_cube = new_cube.collapsed('time', iris.analysis.MEAN)\\n\\n return time_average_cube\",\n \"def getTimeUnits(self):\\n return _libsbml.Model_getTimeUnits(self)\",\n \"def get_time_array(array, axis_of_time_steps=2, start=0., end=1.):\\r\\n number_of_time_steps = np.shape(array)[axis_of_time_steps]\\r\\n return np.linspace(start, end, number_of_time_steps)\",\n \"def get_time(self):\\n return self._ticks\",\n \"def getTimeUnits(self):\\n return _libsbml.KineticLaw_getTimeUnits(self)\",\n \"def test_get_integration_time_vals():\\n test_file = os.path.join(DATA_PATH, \\\"paper_test_file.uvh5\\\")\\n test_uv = UVData()\\n test_uv.read(test_file)\\n\\n baseline_array = np.array(list(set(test_uv.baseline_array)))\\n inttime_array = utils.get_integration_time(test_uv, reds=baseline_array)\\n test_shape = (test_uv.Nbls, test_uv.Ntimes)\\n test_array = test_uv.integration_time.copy()\\n test_array = test_array.reshape(test_shape)\\n assert np.allclose(test_array, inttime_array)\",\n \"def t(self: Q) -> np.array:\\n\\n return np.array([self.t])\",\n \"def get_time_step_values(self):\\n return TensorMeshReader.get_time_step_values(self)\",\n \"def get_time_step_values(self):\\n return DiscretizeMeshReader.get_time_step_values(self)\",\n \"def get_time_step_values(self):\\n return MagObsReader.get_time_step_values(self)\",\n \"def ensemble_times(self):\\n return self['validtime'].values\",\n \"def unit_ms(self):\\n return (self.time_base / 1000.0) / 60.0\",\n \"def get_time_step_values(self):\\n return TensorMeshAppender.get_time_step_values(self)\",\n \"def at(self, t):\\r\\n return TimeArray(self[self.index_at(t)], time_unit=self.time_unit)\",\n \"def get_times(self):\\n times = []\\n for i in range(1, len(self.events)):\\n times.append(self.events[i-1].elapsed_time(self.events[i]))\\n return times\",\n \"def getTimes():\",\n \"def getTimes():\",\n \"def getTimes():\",\n \"def get_time(self, variables):\\n if len(self.TIME_VARIABLE):\\n return self._get_variable(variables, self.TIME_VARIABLE)\\n else:\\n return [0.]\",\n \"def tas_cubes():\\n ta_cube = iris.cube.Cube([1.0], var_name='ta')\\n tas_cube = iris.cube.Cube([3.0], var_name='tas')\\n return iris.cube.CubeList([ta_cube, tas_cube])\",\n \"def get_time_step_values(self):\\n return GravObsReader.get_time_step_values(self)\",\n \"def get_timevars(chid):\\n ftype = promote_type(chid, use_time=True)\\n dat = (1*dbr.Map[ftype])()\\n\\n ret = libca.ca_array_get(ftype, 1, chid, dat)\\n PySEVCHK('get_timevars', ret)\\n poll()\\n out = {}\\n val = dat[0]\\n for attr in ('status', 'severity', 'timestamp'):\\n if hasattr(val, attr):\\n out[attr] = getattr(val, attr)\\n return out\",\n \"def create_space_time_cube(point_layer: _FeatureSet,\\r\\n bin_size: float,\\r\\n bin_size_unit: str,\\r\\n time_step_interval: int,\\r\\n time_step_interval_unit: str,\\r\\n time_step_alignment: str=None,\\r\\n time_step_reference: _datetime=None,\\r\\n summary_fields: str=None,\\r\\n output_name: str=None,\\r\\n context: str=None,\\r\\n gis=None) -> DataFile:\\r\\n kwargs=locals()\\r\\n\\r\\n gis=_arcgis.env.active_gis if gis is None else gis\\r\\n url=gis.properties.helperServices.geoanalytics.url\\r\\n\\r\\n params={}\\r\\n for key, value in kwargs.items():\\r\\n if value is not None:\\r\\n params[key]=value\\r\\n\\r\\n _set_context(params)\\r\\n\\r\\n param_db={\\r\\n \\\"point_layer\\\": (_FeatureSet, \\\"pointLayer\\\"),\\r\\n \\\"bin_size\\\": (float, \\\"binSize\\\"),\\r\\n \\\"bin_size_unit\\\": (str, \\\"binSizeUnit\\\"),\\r\\n \\\"time_step_interval\\\": (int, \\\"timeStepInterval\\\"),\\r\\n \\\"time_step_interval_unit\\\": (str, \\\"timeStepIntervalUnit\\\"),\\r\\n \\\"time_step_alignment\\\": (str, \\\"timeStepAlignment\\\"),\\r\\n \\\"time_step_reference\\\": (_datetime, \\\"timeStepReference\\\"),\\r\\n \\\"summary_fields\\\": (str, \\\"summaryFields\\\"),\\r\\n \\\"output_name\\\": (str, \\\"outputName\\\"),\\r\\n \\\"context\\\": (str, \\\"context\\\"),\\r\\n \\\"output_cube\\\": (DataFile, \\\"Output Space Time Cube\\\"),\\r\\n }\\r\\n return_values=[\\r\\n {\\\"name\\\": \\\"output_cube\\\", \\\"display_name\\\": \\\"Output Space Time Cube\\\", \\\"type\\\": DataFile},\\r\\n ]\\r\\n\\r\\n return _execute_gp_tool(gis, \\\"CreateSpaceTimeCube\\\", params, param_db, return_values, _use_async, url, True)\",\n \"def times(self) -> int:\\n return self._channel_arrays[0].shape[self.time_pos]\",\n \"def measurements(self) -> NONEARRAY:\\n pass\",\n \"def read_times(self, slices=None):\\n times = netCDF4.num2date(\\n datetime.strptime(\\n self.get_handler().SOURCE_START_DATE.split('.')[0],\\n '%Y%m%d%H%M%S'\\n )\\n )\\n return numpy.ma.array([times])\",\n \"def _unit_ms(self):\\n return (self.time_base / 1000.0) / 60.0\",\n \"def time_analysis(self, method='MEAN'):\\n self.cube = self.cube_coordinate_analysis(self.cube, self.time_coord, \\n method)\\n self.processes.append('time_analysis')\\n return self.cube\",\n \"def convert_to_joules(cube):\\n\\n assert 'W' in str(cube.units)\\n assert 'days' in str(cube.coord('time').units)\\n \\n time_span_days = cube.coord('time').bounds[:, 1] - cube.coord('time').bounds[:, 0]\\n time_span_seconds = time_span_days * 60 * 60 * 24\\n \\n cube.data = cube.data * uconv.broadcast_array(time_span_seconds, 0, cube.shape)\\n cube.units = str(cube.units).replace('W', 'J')\\n \\n return cube\",\n \"def std(self, *args, **kwargs):\\r\\n ret = TimeArray(np.ndarray.std(self, *args,**kwargs),\\r\\n time_unit=base_unit)\\r\\n ret.convert_unit(self.time_unit)\\r\\n return ret\",\n \"def peak_time(self):\\n return np.array([self.wftime[ch][self.waveform[ch].argmax()] for ch in range(self.nchannels)])\",\n \"def __repr__(self):\\r\\n\\r\\n # If the input is a single int/float (with no shape) return a 'scalar'\\r\\n # time-point:\\r\\n if self.shape == ():\\r\\n return \\\"%r %s\\\" % (int(self) / float(self._conversion_factor),\\r\\n self.time_unit)\\r\\n # Otherwise, return the TimeArray representation:\\r\\n else:\\r\\n return np.ndarray.__repr__(self / float(self._conversion_factor)\\r\\n )[:-1] + \\\", time_unit='%s')\\\" % self.time_unit\",\n \"def get_time_col(self):\\n return self.time_col\",\n \"def load_time(self) -> Tuple[np.ndarray, np.ndarray]:\\n # filename = self.casedir / Path(\\\"times.txt\\\")\\n filename = self.casedir\\n assert filename.exists(), \\\"Cannot find {filename}\\\".format(filename=filename)\\n return load_times(filename)\",\n \"def _get_time(self) -> None:\\n self.data[\\\"time\\\"] = np.zeros(len(self.data[\\\"yyyymmdd\\\"]), dtype=object)\\n \\n for idx, (yyyymmdd, hhmmss) in enumerate(zip(self.data[\\\"yyyymmdd\\\"], self.data[\\\"hhmmss\\\"])):\\n year, month, day = yyyymmdd.split(\\\"/\\\")\\n hour, minute, second = hhmmss.split(\\\":\\\")\\n self.data[\\\"time\\\"][idx] = datetime(int(year), int(month), int(day), int(hour), int(minute), int(second))\\n \\n del self.data[\\\"yyyymmdd\\\"]\\n del self.data[\\\"hhmmss\\\"]\",\n \"def test_TimeArray_repr():\",\n \"def get_time_points(self):\\n return self._time\",\n \"def get_time_cols(self):\\n # Retrieve first column only\\n time_cols = list()\\n n = self.col_count\\n for i in range(n): # check every column/attribute for time format\\n row_data = str(self.data[0][i])\\n try:\\n time_ok, t_stamp = DataGP.test_time(row_data)\\n if time_ok:\\n time_cols.append(i)\\n except ValueError:\\n continue\\n return np.array(time_cols)\",\n \"def timeTime(self):\\n return self._micros / 1000000.0\",\n \"def u_t(self):\\n\\t\\tdim = self.dim \\n\\t\\ttim_all = self.tim_all\\n\\t\\t#ctrl = self.ctrl\\n\\t\\tH0 = self.H0\\n\\t\\tHctrl = self.Hctrl\\n\\n\\t\\tu_all = np.zeros((tim_all+1,dim,dim),dtype = complex)\\n\\t\\tu_all[0,:,:] = np.eye(dim)\\n\\n\\t\\tfor tim in xrange(tim_all):\\n\\t\\t\\tH = H0 + Hctrl[tim]#np.matrix( ctrl[i,tim] * np.array(Hctrl[i]))\\n\\t\\t\\tu_all[tim+1,:,:] = np.dot(self.u_dt(H,tim), u_all[tim,:,:])\\n\\n\\n\\t\\treturn u_all\",\n \"def test_get_integration_time_shape():\\n test_file = os.path.join(DATA_PATH, \\\"paper_test_file.uvh5\\\")\\n test_uv = UVData()\\n test_uv.read(test_file)\\n\\n baseline_array = np.array(list(set(test_uv.baseline_array)))\\n inttime_array = utils.get_integration_time(test_uv, reds=baseline_array)\\n test_shape = (test_uv.Nbls, test_uv.Ntimes)\\n assert test_shape == inttime_array.shape\",\n \"def time_analysis(self, method='MEAN'):\\n new_cubelist = []\\n for cube in self.cubelist:\\n new_cubelist.append(self.cube_coordinate_analysis(cube, \\n self.time_coord, \\n method))\\n self.cubelist = iris.cube.CubeList(new_cubelist)\\n self.processes.append('time_analysis')\\n return self.cubelist\",\n \"def __getTimeEvolution(self, target):\\n omega = np.log(self._eigs[target]) / self.timeScales['training']['dt']\\n van = np.exp(np.multiply(*np.meshgrid(omega, self._getTimeScale())))\\n timeEvol = (van * self._amplitudes[target]).T\\n return timeEvol\",\n \"def readAll():\\n result = _rc.readAttribute(OPTYPE.TIME_OF_FLIGHT)\\n mm = bytesToIntArray(result, 2, signed=False)\\n return [mm[0] / 10, mm[1] / 10]\",\n \"def total_time(self):\\n obs_times = self.clean_obs_times()\\n return _np.sum(obs_times[:, 1] - obs_times[:, 0])\",\n \"def test_fix_metadata_correct_time(self):\\n fixed_cube = self.fix.fix_metadata([self.cube])[0]\\n time_coord = fixed_cube.coord('time')\\n np.testing.assert_allclose(time_coord.points, [0, 1])\\n assert time_coord.bounds is None\",\n \"def collapse_time(cube, ntimes, timestep):\\n\\n if timestep == None:\\n print('Averaging over the %s time points' %(str(ntimes)))\\n new_cube = cube.collapsed('time', iris.analysis.MEAN)\\n else:\\n assert new_cube.coords()[0] == 'time'\\n new_cube = cube[timestep, :, :]\\n\\n return new_cube\",\n \"def gen_time_axis(self):\\n try:\\n t_explosion = datetime.strptime(self.explosion_date, \\\"%Y %m %d\\\")\\n t_since_explosion = []\\n for i in range(len(self.year)):\\n t_i = datetime.strptime(\\n \\\"%d-%d-%d\\\" % (self.year[i], self.month[i], self.day[i]), \\\"%Y-%m-%d\\\")\\n t_since_explosion.append((t_i - t_explosion).days)\\n self.t = np.asarray(t_since_explosion)\\n self.has_explosion_time = True\\n return np.asarray(t_since_explosion)\\n except TypeError:\\n pass\",\n \"def getDuration(self):\\n #return np.sum(self.subintinfo['TSUBINT']) #This is constant.\\n return np.sum(self.getSubintinfo('TSUBINT')) #This is constant.\",\n \"def get_time_step_values(self):\\n if self.need_to_read():\\n self._read_up_front()\\n return self._timesteps if self._timesteps is not None else None\",\n \"def _return(self, ary, **kwargs):\\n return TimeSamples(ary)\",\n \"def energy_to_time(energy_ev=[], delay_us=np.NaN, source_to_detector_cm=np.NaN):\\n # delay values is normal 2.99 us with NONE actual MCP delay settings\\n energy_mev = energy_ev * 1000\\n time_tot_us = np.sqrt(81.787 / energy_mev) * source_to_detector_cm / 0.3956\\n time_record_us = time_tot_us - delay_us\\n time_record_ns = time_record_us * 1000\\n time_record_s = time_record_us / 1e6\\n return time_record_us\",\n \"def time_speed(self):\\n time_speed = []\\n for i in range (len(np.unique(self.pd.objid))):\\n trajec = self.dataset.trajec(self.dataset.keys[i])\\n times = trajec.time_epoch_secs + trajec.time_epoch_nsecs / 1e9\\n time_speedy = np.vstack([times, trajec.speed])\\n time_speed.append(time_speedy)\\n return time_speed\",\n \"def get_reltriggertimes(self):\\n return np.array(self.trtimes)-self.soundstarttime\",\n \"def get_measurements_by_time(self):\\n data_path = os.path.abspath(\\n os.path.join(\\n os.path.dirname(os.path.realpath(__file__)),\\n \\\"..\\\",\\n \\\"data/NVB_rescale_dataset.p\\\",\\n )\\n )\\n self.log_print([\\\"Getting experimental data from {}\\\".format(data_path)])\\n self.measurements = pickle.load(open(data_path, \\\"rb\\\"))\\n return self.measurements\",\n \"def __get_time_span(self):\\n\\n nonzero = self.data[\\\"time\\\"].nonzero()\\n return iso_time.time(self.data[\\\"time\\\"][nonzero[0][0]]), iso_time.time(\\n self.data[\\\"time\\\"][nonzero[0][-1]])\",\n \"def get_time_step_values(self):\\n return GravGradReader.get_time_step_values(self)\",\n \"def __get_times(self):\\n data = self.simulate_file.readlines()\\n data = list(map(str.strip, data))\\n data = list(map(float, data))\\n start = data[0]\\n times = data[1:]\\n return (start, times)\",\n \"def samples(self):\\n return np.full(self.duration, self._value)\",\n \"def speed(data_array, time=1):\\n dst = DataOperation.geo_m(data_array)\\n speed_values = np.zeros(dst.size)\\n count = 0\\n for d in dst:\\n speed_values[count] = d/time * 3.6# dystans jest w m, przedzial czasowy 1 s, a chcemy k/h\\n count += 1\\n return speed_values\",\n \"def get_times(self):\\n raise NotImplementedError(\\\"Abstract method not implemented.\\\")\",\n \"def transit_times(self):\\n try:\\n self._transit_times\\n self.nt\\n except:\\n return np.array([], dtype=float)\\n return self._transit_times[:self.nt]\",\n \"def calculate_time(ix, xi, wf):\\n wf_len = len(wf)\\n x_time = np.arange(ix, (ix + wf_len * xi), xi)\\n return x_time\",\n \"def _load_time(self):\\n\\n time_variables = ('time', 'Times', 'Itime', 'Itime2')\\n got_time, missing_time = [], []\\n for time in time_variables:\\n # Since not all of the time_variables specified above are required, only try to load the data if they\\n # exist. We'll raise an error if we don't find any of them though.\\n if time in self.ds.variables:\\n setattr(self.time, time, self.ds.variables[time][:])\\n got_time.append(time)\\n attributes = type('attributes', (object,), {})()\\n for attribute in self.ds.variables[time].ncattrs():\\n setattr(attributes, attribute, getattr(self.ds.variables[time], attribute))\\n setattr(self.atts, time, attributes)\\n else:\\n missing_time.append(time)\\n\\n if len(missing_time) == len(time_variables):\\n warn('No time variables found in the netCDF.')\\n else:\\n if 'Times' in got_time:\\n # Overwrite the existing Times array with a more sensibly shaped one.\\n self.time.Times = np.asarray([''.join(t.astype(str)).strip() for t in self.time.Times])\\n\\n # Make whatever we got into datetime objects and use those to make everything else. Note: the `time' variable\\n # is often the one with the lowest precision, so use the others preferentially over that.\\n if 'Times' not in got_time:\\n if 'time' in got_time:\\n _dates = num2date(self.time.time, units=getattr(self.ds.variables['time'], 'units'))\\n elif 'Itime' in got_time and 'Itime2' in got_time:\\n _dates = num2date(self.time.Itime + self.time.Itime2 / 1000.0 / 60 / 60, units=getattr(self.ds.variables['Itime'], 'units'))\\n try:\\n self.time.Times = np.array([datetime.strftime(d, '%Y-%m-%dT%H:%M:%S.%f') for d in _dates])\\n except ValueError:\\n self.time.Times = np.array([datetime.strftime(d, '%Y/%m/%d %H:%M:%S.%f') for d in _dates])\\n # Add the relevant attribute for the Times variable.\\n attributes = type('attributes', (object,), {})()\\n setattr(attributes, 'time_zone', 'UTC')\\n setattr(self.atts, 'Times', attributes)\\n\\n if 'time' not in got_time:\\n if 'Times' in got_time:\\n try:\\n _dates = np.array([datetime.strptime(''.join(t.astype(str)).strip(), '%Y-%m-%dT%H:%M:%S.%f') for t in self.time.Times])\\n except ValueError:\\n _dates = np.array([datetime.strptime(''.join(t.astype(str)).strip(), '%Y/%m/%d %H:%M:%S.%f') for t in self.time.Times])\\n elif 'Itime' in got_time and 'Itime2' in got_time:\\n _dates = num2date(self.time.Itime + self.time.Itime2 / 1000.0 / 60 / 60, units=getattr(self.ds.variables['Itime'], 'units'))\\n # We're making Modified Julian Days here to replicate FVCOM's 'time' variable.\\n self.time.time = date2num(_dates, units='days since 1858-11-17 00:00:00')\\n # Add the relevant attributes for the time variable.\\n attributes = type('attributes', (object,), {})()\\n setattr(attributes, 'units', 'days since 1858-11-17 00:00:00')\\n setattr(attributes, 'long_name', 'time')\\n setattr(attributes, 'format', 'modified julian day (MJD)')\\n setattr(attributes, 'time_zone', 'UTC')\\n setattr(self.atts, 'time', attributes)\\n\\n if 'Itime' not in got_time and 'Itime2' not in got_time:\\n if 'Times' in got_time:\\n try:\\n _dates = np.array([datetime.strptime(''.join(t.astype(str)).strip(), '%Y-%m-%dT%H:%M:%S.%f') for t in self.time.Times])\\n except ValueError:\\n _dates = np.array([datetime.strptime(''.join(t.astype(str)).strip(), '%Y/%m/%d %H:%M:%S.%f') for t in self.time.Times])\\n elif 'time' in got_time:\\n _dates = num2date(self.time.time, units=getattr(self.ds.variables['time'], 'units'))\\n # We're making Modified Julian Days here to replicate FVCOM's 'time' variable.\\n _datenum = date2num(_dates, units='days since 1858-11-17 00:00:00')\\n self.time.Itime = np.floor(_datenum)\\n self.time.Itime2 = (_datenum - np.floor(_datenum)) * 1000 * 60 * 60 # microseconds since midnight\\n attributes = type('attributes', (object,), {})()\\n setattr(attributes, 'units', 'days since 1858-11-17 00:00:00')\\n setattr(attributes, 'format', 'modified julian day (MJD)')\\n setattr(attributes, 'time_zone', 'UTC')\\n setattr(self.atts, 'Itime', attributes)\\n attributes = type('attributes', (object,), {})()\\n setattr(attributes, 'units', 'msec since 00:00:00')\\n setattr(attributes, 'time_zone', 'UTC')\\n setattr(self.atts, 'Itime2', attributes)\\n\\n # Additional nice-to-have time representations.\\n if 'Times' in got_time:\\n try:\\n self.time.datetime = np.array([datetime.strptime(d, '%Y-%m-%dT%H:%M:%S.%f') for d in self.time.Times])\\n except ValueError:\\n self.time.datetime = np.array([datetime.strptime(d, '%Y/%m/%d %H:%M:%S.%f') for d in self.time.Times])\\n attributes = type('attributes', (object,), {})()\\n setattr(attributes, 'long_name', 'Python datetime.datetime')\\n setattr(self.atts, 'datetime', attributes)\\n else:\\n self.time.datetime = _dates\\n self.time.matlabtime = self.time.time + 678942.0 # convert to MATLAB-indexed times from Modified Julian Date.\\n attributes = type('attributes', (object,), {})()\\n setattr(attributes, 'long_name', 'MATLAB datenum')\\n setattr(self.atts, 'matlabtime', attributes)\\n\\n # Clip everything to the time indices if we've been given them. Update the time dimension too.\\n if 'time' in self._dims:\\n if all([isinstance(i, (datetime, str)) for i in self._dims['time']]):\\n # Convert datetime dimensions to indices in the currently loaded data.\\n self._dims['time'][0] = self.time_to_index(self._dims['time'][0])\\n self._dims['time'][1] = self.time_to_index(self._dims['time'][1]) + 1 # make the indexing inclusive\\n for time in self.obj_iter(self.time):\\n setattr(self.time, time, getattr(self.time, time)[self._dims['time'][0]:self._dims['time'][1]])\\n self.dims.time = len(self.time.time)\",\n \"def time_grid(time_step=30):\\n if time_step < 1 or time_step > 60:\\n raise ValueError('Time resolution should be between 0 and 60 [s]')\\n half_step = time_step/SECONDS_PER_HOUR/2\\n return np.arange(half_step, 24+half_step, half_step*2)\",\n \"def get_time_nc(nc_file, tv='time'):\\n from netCDF4 import MFDataset,num2date\\n\\n ds = MFDataset(nc_file)\\n try:\\n time = ds.variables[tv]\\n except:\\n tv='time_counter'\\n ds.close()\\n\\n try:\\n ds = MFDataset(nc_file)\\n time = ds.variables[tv]\\n if (hasattr(time , 'units') and hasattr(time , 'calendar')) == True:\\n timestamps = num2date(time[:], time.units , time.calendar)\\n elif hasattr(time , 'units'):\\n timestamps = num2date(time[:], time.units)\\n else:\\n timestamps = num2date(time[:])\\n ds.close()\\n except Exception as e:\\n raise Exception\\n return timestamps\",\n \"def get_time(self) -> float:\\n raise NotImplementedError()\",\n \"def time_division(annuli):\\n \\n time_div=np.empty(len(annuli),dtype=int)\\n for annulus in range(len(annuli)):\\n r = annuli[annulus]\\n time_div[annulus]=int(viscous_timescale(r) * sample_ratio)\\n return time_div\",\n \"def get_time_step_values(self):\\n return OcTreeReader.get_time_step_values(self)\",\n \"def get_time_step_values(self):\\n return TopoReader.get_time_step_values(self)\",\n \"def test_TimeArray_init_int64():\\r\\n time = ts.TimeArray(np.int64(1))\\r\\n npt.assert_equal(time.__repr__(), '1.0 s')\\r\\n\\r\\n pass\",\n \"def getTime(self) -> float:\\n return self.t\",\n \"def get_time(self):\\n clock = self.pipeline.get_clock()\\n tm = clock.get_internal_time()\\n return tm / 1.e9\",\n \"def n(self):\\n return self._time_axis.size\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.7211374","0.6856966","0.68256146","0.67285633","0.65972865","0.6441097","0.63960433","0.6338288","0.6300424","0.6298656","0.6298656","0.62866175","0.62780577","0.62295645","0.6061472","0.6057796","0.6039089","0.60030895","0.5996386","0.59960365","0.59915805","0.59800357","0.597387","0.59660053","0.5950912","0.5950013","0.59471023","0.5930928","0.58964217","0.5891868","0.5889522","0.58860797","0.5884254","0.5872069","0.5845785","0.58231324","0.5795611","0.5789531","0.5789058","0.5784964","0.57608914","0.57594776","0.57594776","0.57594776","0.57579356","0.57463574","0.5717856","0.5717725","0.5717632","0.5714053","0.5703278","0.5691757","0.5677285","0.5669396","0.56659645","0.56609404","0.5655735","0.565349","0.56326824","0.562708","0.5622144","0.5616855","0.5611861","0.5592793","0.55898684","0.557938","0.5561613","0.55164444","0.54955786","0.54869455","0.54852515","0.5469146","0.5468242","0.5466911","0.54660356","0.54650563","0.54606926","0.5455863","0.54459065","0.54451054","0.54414403","0.5404556","0.5403281","0.5394663","0.53943753","0.5393605","0.5390324","0.5388052","0.5386248","0.53754","0.5373519","0.53720057","0.53709143","0.5368637","0.53681433","0.5362131","0.53604114","0.53480554","0.53449714","0.53413993"],"string":"[\n \"0.7211374\",\n \"0.6856966\",\n \"0.68256146\",\n \"0.67285633\",\n \"0.65972865\",\n \"0.6441097\",\n \"0.63960433\",\n \"0.6338288\",\n \"0.6300424\",\n \"0.6298656\",\n \"0.6298656\",\n \"0.62866175\",\n \"0.62780577\",\n \"0.62295645\",\n \"0.6061472\",\n \"0.6057796\",\n \"0.6039089\",\n \"0.60030895\",\n \"0.5996386\",\n \"0.59960365\",\n \"0.59915805\",\n \"0.59800357\",\n \"0.597387\",\n \"0.59660053\",\n \"0.5950912\",\n \"0.5950013\",\n \"0.59471023\",\n \"0.5930928\",\n \"0.58964217\",\n \"0.5891868\",\n \"0.5889522\",\n \"0.58860797\",\n \"0.5884254\",\n \"0.5872069\",\n \"0.5845785\",\n \"0.58231324\",\n \"0.5795611\",\n \"0.5789531\",\n \"0.5789058\",\n \"0.5784964\",\n \"0.57608914\",\n \"0.57594776\",\n \"0.57594776\",\n \"0.57594776\",\n \"0.57579356\",\n \"0.57463574\",\n \"0.5717856\",\n \"0.5717725\",\n \"0.5717632\",\n \"0.5714053\",\n \"0.5703278\",\n \"0.5691757\",\n \"0.5677285\",\n \"0.5669396\",\n \"0.56659645\",\n \"0.56609404\",\n \"0.5655735\",\n \"0.565349\",\n \"0.56326824\",\n \"0.562708\",\n \"0.5622144\",\n \"0.5616855\",\n \"0.5611861\",\n \"0.5592793\",\n \"0.55898684\",\n \"0.557938\",\n \"0.5561613\",\n \"0.55164444\",\n \"0.54955786\",\n \"0.54869455\",\n \"0.54852515\",\n \"0.5469146\",\n \"0.5468242\",\n \"0.5466911\",\n \"0.54660356\",\n \"0.54650563\",\n \"0.54606926\",\n \"0.5455863\",\n \"0.54459065\",\n \"0.54451054\",\n \"0.54414403\",\n \"0.5404556\",\n \"0.5403281\",\n \"0.5394663\",\n \"0.53943753\",\n \"0.5393605\",\n \"0.5390324\",\n \"0.5388052\",\n \"0.5386248\",\n \"0.53754\",\n \"0.5373519\",\n \"0.53720057\",\n \"0.53709143\",\n \"0.5368637\",\n \"0.53681433\",\n \"0.5362131\",\n \"0.53604114\",\n \"0.53480554\",\n \"0.53449714\",\n \"0.53413993\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.6944582"},"document_rank":{"kind":"string","value":"1"}}},{"rowIdx":24985,"cells":{"query":{"kind":"string","value":"Returns a numpy array containing the frequency values for the cube's spectral dimension, as well as the axis's unit."},"document":{"kind":"string","value":"def wavelength_axis(self):\n if 'WAVE' not in self.axes_wcs.wcs.ctype:\n raise cu.CubeError(2,\n 'No energy (wavelength, frequency) axis found')\n axis = 0 if self.axes_wcs.wcs.ctype[0] == 'WAVE' else 1\n delta = self.axes_wcs.wcs.cdelt[axis]\n crpix = self.axes_wcs.wcs.crpix[axis]\n crval = self.axes_wcs.wcs.crval[axis]\n start = crval - crpix * delta\n stop = start + self.data.shape[-1 - axis] * delta\n cunit = u.Unit(self.axes_wcs.wcs.cunit[axis])\n return np.linspace(start, stop, num=self.data.shape[-1 - axis]) * cunit"},"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 frequencies(self):\r\n\r\n self.method['Fs'] = self.method.get('Fs', self.input.sampling_rate)\r\n NFFT = self.method.get('NFFT', 64)\r\n Fs = self.method.get('Fs')\r\n freqs = tsu.get_freqs(Fs, NFFT)\r\n lb_idx, ub_idx = tsu.get_bounds(freqs, self.lb, self.ub)\r\n\r\n return freqs[lb_idx:ub_idx]","def frequencies(self):\n radii = self.radii\n freqs = (1 / (self.shape[0] * self.pixel[0])) * radii\n return freqs","def frequencies(self):\r\n\r\n #XXX Use NFFT in the method in order to calculate these, without having\r\n #to calculate the spectrum:\r\n f, spectrum = tsa.get_spectra(self.input.data, method=self.method)\r\n return f","def get_freq_array(bandwidth, n_chans):\n return numpy.arange(n_chans)*float(bandwidth)/n_chans","def frequencies(self):\r\n\r\n # Get the sampling rate from the seed time-series:\r\n self.method['Fs'] = self.method.get('Fs', self.seed.sampling_rate)\r\n NFFT = self.method.get('NFFT', 64)\r\n Fs = self.method.get('Fs')\r\n freqs = tsu.get_freqs(Fs, NFFT)\r\n lb_idx, ub_idx = tsu.get_bounds(freqs, self.lb, self.ub)\r\n\r\n return freqs[lb_idx:ub_idx]","def get_frequencies(self):\n\n return self.get_array('frequencies')","def unit_array(self):\n return self._data_array.values * units(self._units)","def get_spectrum_freq(self):\n if not self.is_a_spectrum_file():\n raise TelemacException(\\\n \"This file does not seem to be a spectrum file\")\n\n nfreq = 0\n eps = 1e-6\n f_1 = 10e10\n f_2 = 10e10\n raisf = 0.\n for x, y in zip(self.meshx, self.meshy):\n if abs(x) <= eps and y >= 0.:\n nfreq += 1\n f_temp = y\n if f_temp < f_1:\n f_2 = f_1\n f_1 = f_temp\n elif f_temp < f_2:\n f_2 = f_temp\n\n raisf = f_2/f_1\n\n freqs = [f_1 * raisf**i for i in range(nfreq)]\n\n dfreqs = np.zeros(nfreq, dtype=np.float64)\n\n auxi = (raisf - 1.)/2.\n dfreqs[0] = auxi*freqs[0]\n for i in range(1, nfreq-1):\n dfreqs[i] = auxi*(freqs[i] + freqs[i-1])\n\n dfreqs[-1] = auxi*freqs[-2]\n\n return np.array(freqs), dfreqs","def get_frequencies(self):\n num_seconds = float(self.timestamps[-2] - self.timestamps[0]) / float(1000)\n samples_per_second = len(self.data) / num_seconds\n num_samples = len(self.data)\n oscilations_per_sample = [float(oscilations) / num_samples for oscilations in range(0, num_samples)]\n return [ops * samples_per_second for ops in oscilations_per_sample]","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 get_freq_grid():\n (bins_per_octave, n_octaves, _, _, f_min, _) = get_hcqt_params()\n freq_grid = librosa.cqt_frequencies(\n bins_per_octave*n_octaves, f_min, bins_per_octave=bins_per_octave\n )\n return freq_grid","def to_frequency(self):\n\n if self.unit == 'f_nu':\n raise ValueError('Dispersion is already in frequency.')\n\n elif self.unit == 'f_lam':\n self.flux = self.flux * self.dispersion**2 / (c.value * 1e+10)\n self.dispersion = (c.value * 1e+10) / self.dispersion\n\n self.flux = np.flip(self.flux, axis=0)\n self.dispersion = np.flip(self.dispersion, axis=0)\n\n elif self.unit == 'f_loglam':\n self.to_wavelength()\n self.to_frequency()\n else :\n raise ValueError('Spectrum unit not recognized: ', self.unit)\n\n self.unit = 'f_nu'","def frequencies(self):\n return self._frequencies","def getFreqsForImage(img, header='', spectralaxis=-1, unit='GHz'):\n if (header == ''):\n header = imhead(img,mode='list')\n myia = createCasaTool(iatool)\n myia.open(img)\n if (spectralaxis < 0):\n spectralaxis = findSpectralAxis(myia)\n startchan = [None,None,None,None]\n stopchan = [None,None,None,None]\n startchan[spectralaxis] = 0\n nchan = header['shape'][spectralaxis]\n stopchan[spectralaxis] = nchan\n myqa = createCasaTool(qatool)\n m0 = myia.coordmeasures(startchan)['measure']['spectral']['frequency']['m0']\n m1 = myia.coordmeasures(stopchan)['measure']['spectral']['frequency']['m0']\n f0 = myqa.convert('%.15e %s' % (m0['value'], m0['unit']), unit)\n f1 = myqa.convert('%.15e %s' % (m1['value'], m1['unit']), unit)\n freqs = np.linspace(f0['value'],f1['value'],nchan)\n myia.close()\n myqa.done()\n return freqs","def frequencies(self):\n if self.getn(\"frequency/type\") == \"custom\":\n # The value is validated to be a float list\n frequencies = self.getn(\"frequency/frequencies\")\n else:\n # Calculate the frequency values\n start = self.getn(\"frequency/start\")\n stop = self.getn(\"frequency/stop\")\n step = self.getn(\"frequency/step\")\n num = int((stop - start) / step + 1)\n frequencies = [start + step*i for i in range(num)]\n return frequencies","def getQuasiFreqs(prcntVol):\n nPoints = shape(self.__coeffOmega)[0]\n nModes = shape(self.__coeffOmega)[1]\n fittedFreqs = zeros(shape = (nPoints, nModes) )\n for i in range( nPoints ):\n for j in range( nModes ):\n p = self.__coeffOmega[i,j]\n fittedFreqs[i,j] = p[0]*prcntVol\n return (fittedFreqs+1.0)*self.__omega0","def get_frequency(self, **kwargs):\n #self.resource.clear()\n channel = kwargs.get(\"channel\", self.active_channel)\n use_log = \"LOG\" in self.scpi.query_sweep_type(channel).upper()\n f_start = self.scpi.query_f_start(channel)\n f_stop = self.scpi.query_f_stop(channel)\n f_npoints = self.scpi.query_sweep_n_points(channel)\n if use_log:\n freq = np.logspace(np.log10(f_start), np.log10(f_stop), f_npoints)\n else:\n freq = np.linspace(f_start, f_stop, f_npoints)\n\n frequency = skrf.Frequency.from_f(freq, unit=\"Hz\")\n frequency.unit = kwargs.get(\"f_unit\", \"Hz\")\n return frequency","def freq():","def get_frequency(self,):\n\n # TODO: Find way to appropriately reconvert the frequency to its initial\n # TODO: Value or alert that the value is APPROXIMATE\n FTW = int (0)\n freq = int(0)\n\n FTW_bytes = self._read('CFTW0')\n FTW = FTW.from_bytes(FTW_bytes,'big')\n freq = FTW*self.clock_freq/2**32\n\n print('Latest frequency set: ', \"{:.2e}\".format(freq), 'Hz')\n print(['%.2e' % elem for elem in self.frequencies])\n\n return self.frequencies","def countFreq(self,document):\n self.document = document\n vocab=['python','js','android','php','django','javascript','oracle','ruby','rails','java']\n cnt_vector = CountVectorizer(vocabulary=vocab)\n self.freq_term_matrix = cnt_vector.fit_transform(self.document)\n return self.freq_term_matrix.toarray()","def frequency(self):\n return self._pca.frequency","def numberOfChannelsInCube(img, returnFreqs=False, returnChannelWidth=False, \n verbose=False, header=None, faster=False):\n if (header is None):\n print \"imhead\", # the comma prevents the newline so that ...10...20 will be on same line\n if faster:\n header = imheadlist(img, omitBeam=True)\n else:\n header = imhead(img,mode='list')\n if (header is None):\n print \"imhead failed -- this may not be a CASA or FITS image cube.\"\n return\n nchan = 1\n for axis in range(3,5):\n if ('ctype'+str(axis) in header.keys()):\n if (header['ctype'+str(axis)] in ['Frequency','Velocity']):\n nchan = header['shape'][axis-1]\n break\n firstFreq = 0\n lastFreq = 0\n if ('ctype4' not in header.keys()):\n print \"There is no fourth axis in this image.\"\n elif (header['ctype4'].lower().find('freq') >= 0):\n crpix = header['crpix4']\n crval = header['crval4']\n cdelt = header['cdelt4']\n firstFreq = crval + (0-crpix)*cdelt\n lastFreq = crval + (nchan-1-crpix)*cdelt\n if (verbose):\n print \"Channel 0 = %.0f Hz\" % (firstFreq)\n print \"Channel %d = %.0f Hz\" % (nchan-1,lastFreq)\n elif (header['ctype3'].lower().find('freq') >= 0):\n crpix = header['crpix3']\n crval = header['crval3']\n cdelt = header['cdelt3']\n firstFreq = crval + (0-crpix)*cdelt\n lastFreq = crval + (nchan-1-crpix)*cdelt\n if (verbose):\n print \"Channel 0 = %.0f Hz\" % (firstFreq)\n print \"Channel %d = %.0f Hz\" % (nchan-1,lastFreq)\n else:\n casalogPost(\"Neither the third or fourth axis is frequency.\")\n if (returnFreqs):\n if (returnChannelWidth):\n return(nchan,firstFreq,lastFreq,cdelt)\n else:\n return(nchan,firstFreq,lastFreq)\n else:\n if (returnChannelWidth):\n return(nchan,cdelt)\n else:\n return(nchan)","def calculateenergy_freqdomain(input_signal_or_spectrum):\n if isinstance(input_signal_or_spectrum, (sumpf.Signal)):\n ip = sumpf.modules.FourierTransform(signal=input_signal_or_spectrum).GetSpectrum()\n else:\n ip = input_signal_or_spectrum\n energy_allchannels = []\n for c in ip.GetChannels():\n energy_singlechannel = []\n for s in c:\n energy_singlechannel.append(abs(s) ** 2)\n energy_allchannels.append(numpy.sum(energy_singlechannel))\n return energy_allchannels","def get_wavelength_array(self):\n return self.Me.get_wavelength_array()","def fourier_freqs(times):\n # get the number of samples and the sample rate\n N = len(times)\n dt = np.mean(np.diff(times))\n\n # get the Nyquist frequency\n f_nyq = 1.0 / (2 * dt)\n\n # return the frequency array\n return np.linspace(-f_nyq, f_nyq, N, endpoint=False)","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 frequency(self):\n index = self._ordered_input_names.index('frequency')\n return self._inputs[index]","def GetFrequency(self):\n ...","def frequency(self) -> NumType:\n return self._freq","def test_Frequency():\r\n tuc = ts.time_unit_conversion\r\n for unit in ['ns', 'ms', 's', None]:\r\n f = ts.Frequency(1, time_unit=unit)\r\n npt.assert_equal(f.to_period(), tuc[unit])\r\n\r\n f = ts.Frequency(1000, time_unit=unit)\r\n npt.assert_equal(f.to_period(), tuc[unit] / 1000)\r\n\r\n f = ts.Frequency(0.001, time_unit=unit)\r\n npt.assert_equal(f.to_period(), tuc[unit] * 1000)","def prep_natural_frequency(self) -> np.ndarray:\n\n params = self.freq_params\n\n x = gauss_width(**params)\n weights = gaussian(x, **params)\n prob = weights/np.sum(weights) # pdf for weights\n\n rng = np.random.default_rng()\n frequency = rng.choice(x, size=np.prod(self.ic.shape), p=prob, replace=True)\n\n print(f' natural frequency stats in hz:\\n'\n f' mean: {np.round(np.mean(frequency),3)}\\n'\n f' st dev: {np.round(np.std(frequency),3)}\\n'\n f' converted to phase angle on output')\n return frequency*np.pi*2","def get_frequency(self):\r\n x = self.query('FREQ?')\r\n if x == None: return None\r\n return float(x)","def get_frequency(self):\r\n _debug('simq03b_api.get_frequency')\r\n \r\n x = self.query('SOUR:FREQ:CW?')\r\n if x == None: return None\r\n return float(x)","def _fftfreq(self, n):\r\n val = 1.0 / n\r\n N = floor((n - 1) / 2) + 1\r\n results = [i for i in range(0, int(N))]\r\n p1 = [i for i in range(0, int(n))]\r\n for k in range(0, int(N)):\r\n results[k] = k * val\r\n for j in range(0, int(n)):\r\n results[j] = -floor(n / 2) - (N - j) * val\r\n return results","def spectral_axis(self):\n\n if self._wcs is None:\n spec_axis = np.arange(self.size) * u.one\n else:\n spec_axis = self.wcs.wcs_pix2world(np.arange(self.size), 0)[0] * \\\n u.Unit(self.wcs.wcs.cunit[0])\n if self._spectral_unit is not None:\n spec_axis = spec_axis.to(self._spectral_unit)\n\n return spec_axis","def getFreq(self,):\n\t\treturn self.freq;","def getFreq(self, col = None, sym = None):\n if (col == None):\n return [y.getFreq() for y in self.counts]\n else:\n return self.counts[col].getFreq(sym)","def get_freq(self, surface_option=None, a=[]):\n\n if (surface_option is None) or (len(a) == 0): return self.modes['freq']\n return self.modes['freq'] + self.get_surface_correction(surface_option, a)","def get_list_frequencies(self):\r\n _debug('simq03b_api.get_list_frequencies')\r\n \r\n s = self.query('SOUR:LIST:FREQ?')\r\n if s == None: return None\r\n a = []\r\n n = 0\r\n for x in s.split(','):\r\n try:\r\n a.append(float(x.strip()))\r\n except:\r\n print('ERROR get_list_frequencies(): non-float in list ', n, x)\r\n n += 1\r\n return a","def get_ks(self, shape):\n import numpy as np\n N0, N1, N2 = shape[1:]\n Ks = np.zeros(shape)\n Ks[0] = np.fft.fftfreq(N0)[:,None,None]*2*N0*np.pi\n Ks[1] = np.fft.fftfreq(N1)[None,:,None]*2*N1*np.pi\n Ks[2] = np.fft.fftfreq(N2)[None,None,:]*2*N2*np.pi\n return Ks","def freqspace(dim):\n f1 = [] \n if dim % 2 == 0: \n for i in range(-dim, dim-1, 2):\n ft = float(i) / float(dim)\n f1.append(ft) \n else: \n for i in range(-dim+1, dim, 2):\n ft = float(i) / float(dim)\n f1.append(ft) \n return f1","def fft_frequencies(sr=22050, n_fft=2048):\n\n return np.linspace(0, float(sr) / 2, int(1 + n_fft // 2), endpoint=True)","def get_frequency(self):\r\n x = self.query('SOUR:FREQ:CW?')\r\n if x == None: return None\r\n return float(x)","def get_frequency(self):\r\n x = self.query('SOUR:FREQ:CW?')\r\n if x == None: return None\r\n return float(x)","def Q(self):\n return np.array(list(self.center_frequencies)) \\\n / np.array(list(self.bandwidths))","def freqscale(self):\n index = self._ordered_input_names.index('freqscale')\n return self._inputs[index]","def _uniform_freqs(Nd, xp=np):\n if xp.isscalar(Nd):\n Nd = (Nd,)\n ndim = len(Nd)\n fs = [2 * np.pi * xp.arange(Nd[d]) / Nd[d] for d in range(ndim)]\n fs = xp.meshgrid(*fs, indexing=\"ij\")\n fs = [f.reshape((-1, 1), order=\"F\") for f in fs]\n return xp.hstack(fs)","def getAxisUnits(self, dim=0): \n return self.__axis_units__[dim]","def get_frequency(self):\r\n return self.f","def get_frequency(self, c, channel=-1):\n if (channel == -1):\n channel = self.guess_channel()\n\n try:\n frequency = self.binding.get_frequency_num(channel)\n return frequency * THz;\n except Exception, e:\n return self.handle_wavemeter_error(e)","def get_length(self):\r\n check_mixer()\r\n frequency, format, channels = (ffi.new('int*'), ffi.new('uint16_t*'),\r\n ffi.new('int*'))\r\n sdl.Mix_QuerySpec(frequency, format, channels)\r\n if format == sdl.AUDIO_S8 or format == sdl.AUDIO_U8:\r\n mixerbytes = 1.0\r\n else:\r\n mixerbytes = 2.0\r\n numsamples = self.chunk.alen / mixerbytes / channels[0]\r\n return numsamples / frequency[0]","def freq(self) -> int:","def get_cw_freq(self):\n return self.get_frequency(self.synth)","def frequency(self):\n return float(self.get_frequency())","def get_freqs(filename):\n full = io.read_file(filename)\n full = full.strip('\\n')\n full = full.split('[1/cm]')[1].split('Zero')[0]\n full = full.split()\n nfreqs = full[0]\n freqs = full[1:]\n # [freq=float(freq) for freq in freqs]\n freqs = np.array(list(map(float, freqs)))\n a = freqs.argsort()[::-1]\n freqs = np.sort(freqs)[::-1]\n return freqs.tolist(), a.tolist()","def get_list_frequencies(self):\r\n return self.fs","def get_list_frequencies(self):\r\n s = self.query('LIST:FREQ?')\r\n if s == None: return None\r\n a = []\r\n n = 0\r\n for x in s.split(','):\r\n try:\r\n a.append(float(x.strip()))\r\n except:\r\n print('ERROR get_list_frequencies(): non-float in list ', n, x)\r\n n += 1\r\n return a","def width(self):\n return np.array([f.width() for f in self])","def frequency(self):\n return self.reference_clock_speed / 4096 / self.prescale_reg","def ps_freq_axis(dt, n):\n\n frequency = sp.arange(n//2, dtype=float)\n df = 1.0/dt/n\n frequency *= df\n return frequency","def convert_to_spectral_cube(self):\n if self.data.ndim == 4:\n raise cu.CubeError(4, \"Too many dimensions: Can only convert a \" +\n \"3D cube. Slice the cube before converting\")\n if 'WAVE' not in self.axes_wcs.wcs.ctype:\n raise cu.CubeError(2, 'Spectral axis needed to create a spectrum')\n axis = 0 if self.axes_wcs.wcs.ctype[-1] == 'WAVE' else 1\n coordaxes = [1, 2] if axis == 0 else [0, 2] # Non-spectral axes\n newwcs = wu.reindex_wcs(self.axes_wcs, np.arary(coordaxes))\n time_or_x_size = self.data.shape[coordaxes[1]]\n y_size = self.data.shape[coordaxes[0]]\n spectra = np.empty((time_or_x_size, y_size), dtype=Spectrum)\n for i in range(time_or_x_size):\n for j in range(y_size):\n spectra[i][j] = self.slice_to_spectrum(i, j)\n return SpectralCube(spectra, newwcs, self.meta)","def center_frequencies(self):\n return (band.center_frequency for band in self)","def get_ao_manual_control_freq( channel ):\n freq = float64(0)\n CALL('GetPhysicalChanAOManualControlFreq', channel, byref(freq))\n return freq.value","def samp_from_freq(n_samples):\n datapath = os.path.normpath(os.getcwd()+os.sep+os.pardir+os.sep+\"Dataset\"+os.sep+\"All_channels_500hz.npy\")\n data = np.load(datapath)\n fourier = np.fft.rfft(data,axis=0)\n fourier_mean = np.mean(fourier,axis=1)\n print(fourier.shape)\n print(fourier_mean.shape)\n signal = np.fft.irfft(fourier_mean)[1:]\n plt.plot(fourier_mean[1:])\n plt.show()\n plt.plot(signal)\n plt.show()\n #Generating frequency spectrum\n \"\"\"\n x = np.linspace(0,100,251)\n x2 = np.linspace(0,5,251)\n spectrum = 50*np.exp(-(x-30)**2/2)\n spectrum += 60*np.sin(np.random.randn(251)*2*np.pi)*np.exp(-x2)\n #spectrum += np.random.randn(251)\n plt.plot(spectrum)\n plt.show()\n signal = np.fft.irfft(spectrum)\n plt.plot(signal)\n plt.show()\n \"\"\"\n signal = None\n return signal","def freqs(self, xs):\n return [self.freq(x) for x in xs]","def Hz(self,kx,ky):\n return self.m-2.*self.t2*np.sin(self.phi)*(np.sin(3.*kx/2.+np.sqrt(3.)*ky/2.)+np.sin(-3.*kx/2.+np.sqrt(3.)*ky/2.)+np.sin(-np.sqrt(3.)*ky))","def getFreq(self, sym = None):\n if self.tot > 0:\n if sym == None:\n freq = tuple([ y / self.tot for y in self.cnt ])\n return freq\n else:\n idx = self.alpha.getIndex( sym )\n return self.cnt[idx] / self.tot\n return None","def all_modes(self):\n\n with open(f'gj_{self.molecule.name}.log', 'r') as gj_log_file:\n\n lines = gj_log_file.readlines()\n freqs = []\n\n # Stores indices of rows which will be used\n freq_positions = []\n for count, line in enumerate(lines):\n if line.startswith(' Frequencies'):\n freq_positions.append(count)\n\n for pos in freq_positions:\n freqs.extend(float(num) for num in lines[pos].split()[2:])\n\n return array(freqs)","def get_frequency(self):\r\n return self._api.get_frequency()","def freq_of_t(self, times):\n y = np.zeros(len(times))\n amplitudes, phases = self._ampl_phase(self.fourier_coeffs)\n for n, (ampl, phase) in enumerate(zip(amplitudes, phases)):\n omega_n = 2*np.pi*self.pzt_freq*(n+1)\n y+=ampl*np.cos(omega_n*times + phase)\n return y","def get_frequency(time_series):\n if len(time_series.index) == 0:\n return 0\n ft = np.fft.rfft(time_series)\n return np.fft.fftfreq(len(time_series))[np.argmax(abs(ft))]","def getMeasures():","def get_spectrum(self) -> pd.Series:\n short_time_spectrum = self.get_short_time_spectrum()\n raw_spectrum = short_time_spectrum.sum(axis=1)\n frequencies = librosa.fft_frequencies(\n sr=self.sample_rate,\n n_fft=self.n_fft\n )\n spectrum = pd.Series(raw_spectrum, frequencies)\n return spectrum","def raw_counts(self):\n return np.array([1, 2, 3])","def raw_counts(self):\n return np.array([1, 2, 3])","def getAllSpectrumMeasurements(self): \n return self.spectrum","def rfft2d_freqs(h, w):\n fy = np.fft.fftfreq(h)[:, None]\n fx = np.fft.fftfreq(w)\n return np.sqrt(fx * fx + fy * fy)","def get_list_frequencies(self):\r\n s = self.query('SOUR1:LIST:FREQ?')\r\n if s == None: return None\r\n a = []\r\n n = 0\r\n for x in s.split(','):\r\n try:\r\n a.append(float(x.strip()))\r\n except:\r\n print('ERROR get_list_frequencies(): non-float in list ', n, x)\r\n n += 1\r\n return a","def get_list_frequencies(self):\r\n s = self.query('SOUR1:LIST:FREQ?')\r\n if s == None: return None\r\n a = []\r\n n = 0\r\n for x in s.split(','):\r\n try:\r\n a.append(float(x.strip()))\r\n except:\r\n print('ERROR get_list_frequencies(): non-float in list ', n, x)\r\n n += 1\r\n return a","def frequency(self):\n return self.reference_clock_speed / 4096 / self.prescale_reg","def validate_freqs_array(data, axis=None):\n if (data < 0).any():\n raise ValueError(\"negative frequency not allowed\")\n\n # we explicitly ignore nan\n result = data.sum(axis=axis)\n if not numpy.allclose(result[numpy.isnan(result) == False], 1):\n raise ValueError(\"invalid frequencies, sum(axis=1) is not equal to 1\")","def freqspace2(dim):\n (minval, maxval) = (-dim, dim-1) if (dim % 2 == 0) else (1-dim, dim)\n return np.asarray(range(minval,maxval,2)) / dim","def get_freqs(Fs, n):\r\n\r\n return np.linspace(0, float(Fs) / 2, float(n) / 2 + 1)","def wave_samples(self):\n return self._quantized_subsamples","def measure_program(self, channels: Iterable[str]) -> Dict[str, numpy.ndarray]:","def gen_freqs(ndata, dt):\n dn = 2 # if you like the central frequency to be negative, change dn to 1\n return 1/(ndata*dt) * np.hstack((np.arange(0, (ndata+dn)//2),\n np.arange(-(ndata+dn)//2+dn, 0)))","def get_freq(self):\n return self.freq","def raw_counts(self):\n return np.array([[1, 2], [3, 4], [5, 6]])","def get_fft(u: np.ndarray, n: int) -> np.ndarray:\n\n # We get the fft of each time slice.\n num_slices = u.shape[0]\n ut = np.empty(u.shape, dtype=complex) # shape (20, 262144)\n for s in range(num_slices):\n # We reshape each slice into a 3D cube.\n u_slice = np.reshape(u[s,:], (n, n, n)) # shape (64, 64, 64)\n # We then take the fft of the 3D cube and add it to ut.\n ut_slice = np.fft.fftshift(np.fft.fftn(u_slice)) # shape (64, 64, 64)\n ut[s, :] = ut_slice.flatten()\n\n return ut","def get_scale_freq():\n return sf / 2 / (num_freq-1)","def get_center_freq(self, chan=0):\n return _uhd_swig.usrp_sink_get_center_freq(self, chan)","def _get_frequencies(data, col, col_vals, agg_col, agg_unit, agg_to_data):\n interesting_data = None\n frequencies = {}\n for col_val in col_vals:\n frequencies[col_val] = 0\n # We can't just use collections.Counter() because frequencies.keys() is used to determine\n # the range of possible values in other functions.\n if _PANDAS_AVAILABLE and isinstance(data, pd.DataFrame):\n interesting_data = agg_to_data[agg_unit][col]\n for name in interesting_data:\n if name in frequencies:\n frequencies[name] = frequencies[name] + 1\n else: # Assumes it is an np.ndarray\n for row in itertools.ifilter(lambda row : row[agg_col] == agg_unit, data):\n if row[col] in frequencies:\n frequencies[row[col]] += 1\n return frequencies, interesting_data","def get_frequency(self):\n\n #TODO\n\n\n self.__running_time = round(time.time() * 1000) - self.__running_time\n\n return self.__frequency_dict","def in_freq(self):\n if self._in_freq is None:\n self._in_freq = np.fft.rfft(self._in_time)\n return self._in_freq","def spectral_variance(data, fft_data):\n return np.var(np.abs(fft_data))","def get_wavelengths(system, info=False):\n\n system_data = system.SystemData\n wavelengths = system_data.Wavelengths\n N_wavelengths = wavelengths.NumberOfWavelengths\n\n if info is True:\n print(\"\\nReading Wavelengths\")\n print(\"Total Number of Wavelengths: %d\" % N_wavelengths)\n\n wavelength_array = np.zeros(N_wavelengths)\n\n for k in np.arange(1, N_wavelengths + 1):\n _wave = wavelengths.GetWavelength(k).Wavelength\n wavelength_array[k - 1] = _wave\n\n if info is True:\n print(\"%.5f microns\" % _wave)\n\n return wavelength_array","def measure_freq_simple(self, freq, resolution, channel):\n if 0 < channel <= 3:\n self.write(\":MEASURE:FREQ? {0}Hz {1}, (@{2})\".format(freq, resolution, channel))","def Get_Meas_Res_Wave_Count(self, mode, ch=1):\n rdStr = self.query(f':MEAS{ch}:RES:WFMC? {mode}')\n return rdStr","def _ica_by_freq(S):\n \n n_samples, n_frames , n_frequencies= S.shape\n T = np.zeros(S.shape, dtype=np.complex64)\n WK = np.zeros([n_samples, n_samples, n_frequencies], dtype=np.complex64)\n\n for l in range(n_frequencies):\n M = S[:,:,l].T\n M = M.astype(np.complex64)\n M /= M.std(axis = 0)\n ica = ComplexFastICA(n_components=n_samples)\n N = ica.fit_transform(M).T\n T[:,:,l] = N\n WK[:,:,l] = ica.components_\n\n return T, WK","def get_fft(self, x, y, z):\n avg = (np.array(x) + np.array(y) + np.array(z))/3\n return np.abs(fft(avg)/len(avg))[1:len(avg)//2]"],"string":"[\n \"def frequencies(self):\\r\\n\\r\\n self.method['Fs'] = self.method.get('Fs', self.input.sampling_rate)\\r\\n NFFT = self.method.get('NFFT', 64)\\r\\n Fs = self.method.get('Fs')\\r\\n freqs = tsu.get_freqs(Fs, NFFT)\\r\\n lb_idx, ub_idx = tsu.get_bounds(freqs, self.lb, self.ub)\\r\\n\\r\\n return freqs[lb_idx:ub_idx]\",\n \"def frequencies(self):\\n radii = self.radii\\n freqs = (1 / (self.shape[0] * self.pixel[0])) * radii\\n return freqs\",\n \"def frequencies(self):\\r\\n\\r\\n #XXX Use NFFT in the method in order to calculate these, without having\\r\\n #to calculate the spectrum:\\r\\n f, spectrum = tsa.get_spectra(self.input.data, method=self.method)\\r\\n return f\",\n \"def get_freq_array(bandwidth, n_chans):\\n return numpy.arange(n_chans)*float(bandwidth)/n_chans\",\n \"def frequencies(self):\\r\\n\\r\\n # Get the sampling rate from the seed time-series:\\r\\n self.method['Fs'] = self.method.get('Fs', self.seed.sampling_rate)\\r\\n NFFT = self.method.get('NFFT', 64)\\r\\n Fs = self.method.get('Fs')\\r\\n freqs = tsu.get_freqs(Fs, NFFT)\\r\\n lb_idx, ub_idx = tsu.get_bounds(freqs, self.lb, self.ub)\\r\\n\\r\\n return freqs[lb_idx:ub_idx]\",\n \"def get_frequencies(self):\\n\\n return self.get_array('frequencies')\",\n \"def unit_array(self):\\n return self._data_array.values * units(self._units)\",\n \"def get_spectrum_freq(self):\\n if not self.is_a_spectrum_file():\\n raise TelemacException(\\\\\\n \\\"This file does not seem to be a spectrum file\\\")\\n\\n nfreq = 0\\n eps = 1e-6\\n f_1 = 10e10\\n f_2 = 10e10\\n raisf = 0.\\n for x, y in zip(self.meshx, self.meshy):\\n if abs(x) <= eps and y >= 0.:\\n nfreq += 1\\n f_temp = y\\n if f_temp < f_1:\\n f_2 = f_1\\n f_1 = f_temp\\n elif f_temp < f_2:\\n f_2 = f_temp\\n\\n raisf = f_2/f_1\\n\\n freqs = [f_1 * raisf**i for i in range(nfreq)]\\n\\n dfreqs = np.zeros(nfreq, dtype=np.float64)\\n\\n auxi = (raisf - 1.)/2.\\n dfreqs[0] = auxi*freqs[0]\\n for i in range(1, nfreq-1):\\n dfreqs[i] = auxi*(freqs[i] + freqs[i-1])\\n\\n dfreqs[-1] = auxi*freqs[-2]\\n\\n return np.array(freqs), dfreqs\",\n \"def get_frequencies(self):\\n num_seconds = float(self.timestamps[-2] - self.timestamps[0]) / float(1000)\\n samples_per_second = len(self.data) / num_seconds\\n num_samples = len(self.data)\\n oscilations_per_sample = [float(oscilations) / num_samples for oscilations in range(0, num_samples)]\\n return [ops * samples_per_second for ops in oscilations_per_sample]\",\n \"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]\",\n \"def get_freq_grid():\\n (bins_per_octave, n_octaves, _, _, f_min, _) = get_hcqt_params()\\n freq_grid = librosa.cqt_frequencies(\\n bins_per_octave*n_octaves, f_min, bins_per_octave=bins_per_octave\\n )\\n return freq_grid\",\n \"def to_frequency(self):\\n\\n if self.unit == 'f_nu':\\n raise ValueError('Dispersion is already in frequency.')\\n\\n elif self.unit == 'f_lam':\\n self.flux = self.flux * self.dispersion**2 / (c.value * 1e+10)\\n self.dispersion = (c.value * 1e+10) / self.dispersion\\n\\n self.flux = np.flip(self.flux, axis=0)\\n self.dispersion = np.flip(self.dispersion, axis=0)\\n\\n elif self.unit == 'f_loglam':\\n self.to_wavelength()\\n self.to_frequency()\\n else :\\n raise ValueError('Spectrum unit not recognized: ', self.unit)\\n\\n self.unit = 'f_nu'\",\n \"def frequencies(self):\\n return self._frequencies\",\n \"def getFreqsForImage(img, header='', spectralaxis=-1, unit='GHz'):\\n if (header == ''):\\n header = imhead(img,mode='list')\\n myia = createCasaTool(iatool)\\n myia.open(img)\\n if (spectralaxis < 0):\\n spectralaxis = findSpectralAxis(myia)\\n startchan = [None,None,None,None]\\n stopchan = [None,None,None,None]\\n startchan[spectralaxis] = 0\\n nchan = header['shape'][spectralaxis]\\n stopchan[spectralaxis] = nchan\\n myqa = createCasaTool(qatool)\\n m0 = myia.coordmeasures(startchan)['measure']['spectral']['frequency']['m0']\\n m1 = myia.coordmeasures(stopchan)['measure']['spectral']['frequency']['m0']\\n f0 = myqa.convert('%.15e %s' % (m0['value'], m0['unit']), unit)\\n f1 = myqa.convert('%.15e %s' % (m1['value'], m1['unit']), unit)\\n freqs = np.linspace(f0['value'],f1['value'],nchan)\\n myia.close()\\n myqa.done()\\n return freqs\",\n \"def frequencies(self):\\n if self.getn(\\\"frequency/type\\\") == \\\"custom\\\":\\n # The value is validated to be a float list\\n frequencies = self.getn(\\\"frequency/frequencies\\\")\\n else:\\n # Calculate the frequency values\\n start = self.getn(\\\"frequency/start\\\")\\n stop = self.getn(\\\"frequency/stop\\\")\\n step = self.getn(\\\"frequency/step\\\")\\n num = int((stop - start) / step + 1)\\n frequencies = [start + step*i for i in range(num)]\\n return frequencies\",\n \"def getQuasiFreqs(prcntVol):\\n nPoints = shape(self.__coeffOmega)[0]\\n nModes = shape(self.__coeffOmega)[1]\\n fittedFreqs = zeros(shape = (nPoints, nModes) )\\n for i in range( nPoints ):\\n for j in range( nModes ):\\n p = self.__coeffOmega[i,j]\\n fittedFreqs[i,j] = p[0]*prcntVol\\n return (fittedFreqs+1.0)*self.__omega0\",\n \"def get_frequency(self, **kwargs):\\n #self.resource.clear()\\n channel = kwargs.get(\\\"channel\\\", self.active_channel)\\n use_log = \\\"LOG\\\" in self.scpi.query_sweep_type(channel).upper()\\n f_start = self.scpi.query_f_start(channel)\\n f_stop = self.scpi.query_f_stop(channel)\\n f_npoints = self.scpi.query_sweep_n_points(channel)\\n if use_log:\\n freq = np.logspace(np.log10(f_start), np.log10(f_stop), f_npoints)\\n else:\\n freq = np.linspace(f_start, f_stop, f_npoints)\\n\\n frequency = skrf.Frequency.from_f(freq, unit=\\\"Hz\\\")\\n frequency.unit = kwargs.get(\\\"f_unit\\\", \\\"Hz\\\")\\n return frequency\",\n \"def freq():\",\n \"def get_frequency(self,):\\n\\n # TODO: Find way to appropriately reconvert the frequency to its initial\\n # TODO: Value or alert that the value is APPROXIMATE\\n FTW = int (0)\\n freq = int(0)\\n\\n FTW_bytes = self._read('CFTW0')\\n FTW = FTW.from_bytes(FTW_bytes,'big')\\n freq = FTW*self.clock_freq/2**32\\n\\n print('Latest frequency set: ', \\\"{:.2e}\\\".format(freq), 'Hz')\\n print(['%.2e' % elem for elem in self.frequencies])\\n\\n return self.frequencies\",\n \"def countFreq(self,document):\\n self.document = document\\n vocab=['python','js','android','php','django','javascript','oracle','ruby','rails','java']\\n cnt_vector = CountVectorizer(vocabulary=vocab)\\n self.freq_term_matrix = cnt_vector.fit_transform(self.document)\\n return self.freq_term_matrix.toarray()\",\n \"def frequency(self):\\n return self._pca.frequency\",\n \"def numberOfChannelsInCube(img, returnFreqs=False, returnChannelWidth=False, \\n verbose=False, header=None, faster=False):\\n if (header is None):\\n print \\\"imhead\\\", # the comma prevents the newline so that ...10...20 will be on same line\\n if faster:\\n header = imheadlist(img, omitBeam=True)\\n else:\\n header = imhead(img,mode='list')\\n if (header is None):\\n print \\\"imhead failed -- this may not be a CASA or FITS image cube.\\\"\\n return\\n nchan = 1\\n for axis in range(3,5):\\n if ('ctype'+str(axis) in header.keys()):\\n if (header['ctype'+str(axis)] in ['Frequency','Velocity']):\\n nchan = header['shape'][axis-1]\\n break\\n firstFreq = 0\\n lastFreq = 0\\n if ('ctype4' not in header.keys()):\\n print \\\"There is no fourth axis in this image.\\\"\\n elif (header['ctype4'].lower().find('freq') >= 0):\\n crpix = header['crpix4']\\n crval = header['crval4']\\n cdelt = header['cdelt4']\\n firstFreq = crval + (0-crpix)*cdelt\\n lastFreq = crval + (nchan-1-crpix)*cdelt\\n if (verbose):\\n print \\\"Channel 0 = %.0f Hz\\\" % (firstFreq)\\n print \\\"Channel %d = %.0f Hz\\\" % (nchan-1,lastFreq)\\n elif (header['ctype3'].lower().find('freq') >= 0):\\n crpix = header['crpix3']\\n crval = header['crval3']\\n cdelt = header['cdelt3']\\n firstFreq = crval + (0-crpix)*cdelt\\n lastFreq = crval + (nchan-1-crpix)*cdelt\\n if (verbose):\\n print \\\"Channel 0 = %.0f Hz\\\" % (firstFreq)\\n print \\\"Channel %d = %.0f Hz\\\" % (nchan-1,lastFreq)\\n else:\\n casalogPost(\\\"Neither the third or fourth axis is frequency.\\\")\\n if (returnFreqs):\\n if (returnChannelWidth):\\n return(nchan,firstFreq,lastFreq,cdelt)\\n else:\\n return(nchan,firstFreq,lastFreq)\\n else:\\n if (returnChannelWidth):\\n return(nchan,cdelt)\\n else:\\n return(nchan)\",\n \"def calculateenergy_freqdomain(input_signal_or_spectrum):\\n if isinstance(input_signal_or_spectrum, (sumpf.Signal)):\\n ip = sumpf.modules.FourierTransform(signal=input_signal_or_spectrum).GetSpectrum()\\n else:\\n ip = input_signal_or_spectrum\\n energy_allchannels = []\\n for c in ip.GetChannels():\\n energy_singlechannel = []\\n for s in c:\\n energy_singlechannel.append(abs(s) ** 2)\\n energy_allchannels.append(numpy.sum(energy_singlechannel))\\n return energy_allchannels\",\n \"def get_wavelength_array(self):\\n return self.Me.get_wavelength_array()\",\n \"def fourier_freqs(times):\\n # get the number of samples and the sample rate\\n N = len(times)\\n dt = np.mean(np.diff(times))\\n\\n # get the Nyquist frequency\\n f_nyq = 1.0 / (2 * dt)\\n\\n # return the frequency array\\n return np.linspace(-f_nyq, f_nyq, N, endpoint=False)\",\n \"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]\",\n \"def frequency(self):\\n index = self._ordered_input_names.index('frequency')\\n return self._inputs[index]\",\n \"def GetFrequency(self):\\n ...\",\n \"def frequency(self) -> NumType:\\n return self._freq\",\n \"def test_Frequency():\\r\\n tuc = ts.time_unit_conversion\\r\\n for unit in ['ns', 'ms', 's', None]:\\r\\n f = ts.Frequency(1, time_unit=unit)\\r\\n npt.assert_equal(f.to_period(), tuc[unit])\\r\\n\\r\\n f = ts.Frequency(1000, time_unit=unit)\\r\\n npt.assert_equal(f.to_period(), tuc[unit] / 1000)\\r\\n\\r\\n f = ts.Frequency(0.001, time_unit=unit)\\r\\n npt.assert_equal(f.to_period(), tuc[unit] * 1000)\",\n \"def prep_natural_frequency(self) -> np.ndarray:\\n\\n params = self.freq_params\\n\\n x = gauss_width(**params)\\n weights = gaussian(x, **params)\\n prob = weights/np.sum(weights) # pdf for weights\\n\\n rng = np.random.default_rng()\\n frequency = rng.choice(x, size=np.prod(self.ic.shape), p=prob, replace=True)\\n\\n print(f' natural frequency stats in hz:\\\\n'\\n f' mean: {np.round(np.mean(frequency),3)}\\\\n'\\n f' st dev: {np.round(np.std(frequency),3)}\\\\n'\\n f' converted to phase angle on output')\\n return frequency*np.pi*2\",\n \"def get_frequency(self):\\r\\n x = self.query('FREQ?')\\r\\n if x == None: return None\\r\\n return float(x)\",\n \"def get_frequency(self):\\r\\n _debug('simq03b_api.get_frequency')\\r\\n \\r\\n x = self.query('SOUR:FREQ:CW?')\\r\\n if x == None: return None\\r\\n return float(x)\",\n \"def _fftfreq(self, n):\\r\\n val = 1.0 / n\\r\\n N = floor((n - 1) / 2) + 1\\r\\n results = [i for i in range(0, int(N))]\\r\\n p1 = [i for i in range(0, int(n))]\\r\\n for k in range(0, int(N)):\\r\\n results[k] = k * val\\r\\n for j in range(0, int(n)):\\r\\n results[j] = -floor(n / 2) - (N - j) * val\\r\\n return results\",\n \"def spectral_axis(self):\\n\\n if self._wcs is None:\\n spec_axis = np.arange(self.size) * u.one\\n else:\\n spec_axis = self.wcs.wcs_pix2world(np.arange(self.size), 0)[0] * \\\\\\n u.Unit(self.wcs.wcs.cunit[0])\\n if self._spectral_unit is not None:\\n spec_axis = spec_axis.to(self._spectral_unit)\\n\\n return spec_axis\",\n \"def getFreq(self,):\\n\\t\\treturn self.freq;\",\n \"def getFreq(self, col = None, sym = None):\\n if (col == None):\\n return [y.getFreq() for y in self.counts]\\n else:\\n return self.counts[col].getFreq(sym)\",\n \"def get_freq(self, surface_option=None, a=[]):\\n\\n if (surface_option is None) or (len(a) == 0): return self.modes['freq']\\n return self.modes['freq'] + self.get_surface_correction(surface_option, a)\",\n \"def get_list_frequencies(self):\\r\\n _debug('simq03b_api.get_list_frequencies')\\r\\n \\r\\n s = self.query('SOUR:LIST:FREQ?')\\r\\n if s == None: return None\\r\\n a = []\\r\\n n = 0\\r\\n for x in s.split(','):\\r\\n try:\\r\\n a.append(float(x.strip()))\\r\\n except:\\r\\n print('ERROR get_list_frequencies(): non-float in list ', n, x)\\r\\n n += 1\\r\\n return a\",\n \"def get_ks(self, shape):\\n import numpy as np\\n N0, N1, N2 = shape[1:]\\n Ks = np.zeros(shape)\\n Ks[0] = np.fft.fftfreq(N0)[:,None,None]*2*N0*np.pi\\n Ks[1] = np.fft.fftfreq(N1)[None,:,None]*2*N1*np.pi\\n Ks[2] = np.fft.fftfreq(N2)[None,None,:]*2*N2*np.pi\\n return Ks\",\n \"def freqspace(dim):\\n f1 = [] \\n if dim % 2 == 0: \\n for i in range(-dim, dim-1, 2):\\n ft = float(i) / float(dim)\\n f1.append(ft) \\n else: \\n for i in range(-dim+1, dim, 2):\\n ft = float(i) / float(dim)\\n f1.append(ft) \\n return f1\",\n \"def fft_frequencies(sr=22050, n_fft=2048):\\n\\n return np.linspace(0, float(sr) / 2, int(1 + n_fft // 2), endpoint=True)\",\n \"def get_frequency(self):\\r\\n x = self.query('SOUR:FREQ:CW?')\\r\\n if x == None: return None\\r\\n return float(x)\",\n \"def get_frequency(self):\\r\\n x = self.query('SOUR:FREQ:CW?')\\r\\n if x == None: return None\\r\\n return float(x)\",\n \"def Q(self):\\n return np.array(list(self.center_frequencies)) \\\\\\n / np.array(list(self.bandwidths))\",\n \"def freqscale(self):\\n index = self._ordered_input_names.index('freqscale')\\n return self._inputs[index]\",\n \"def _uniform_freqs(Nd, xp=np):\\n if xp.isscalar(Nd):\\n Nd = (Nd,)\\n ndim = len(Nd)\\n fs = [2 * np.pi * xp.arange(Nd[d]) / Nd[d] for d in range(ndim)]\\n fs = xp.meshgrid(*fs, indexing=\\\"ij\\\")\\n fs = [f.reshape((-1, 1), order=\\\"F\\\") for f in fs]\\n return xp.hstack(fs)\",\n \"def getAxisUnits(self, dim=0): \\n return self.__axis_units__[dim]\",\n \"def get_frequency(self):\\r\\n return self.f\",\n \"def get_frequency(self, c, channel=-1):\\n if (channel == -1):\\n channel = self.guess_channel()\\n\\n try:\\n frequency = self.binding.get_frequency_num(channel)\\n return frequency * THz;\\n except Exception, e:\\n return self.handle_wavemeter_error(e)\",\n \"def get_length(self):\\r\\n check_mixer()\\r\\n frequency, format, channels = (ffi.new('int*'), ffi.new('uint16_t*'),\\r\\n ffi.new('int*'))\\r\\n sdl.Mix_QuerySpec(frequency, format, channels)\\r\\n if format == sdl.AUDIO_S8 or format == sdl.AUDIO_U8:\\r\\n mixerbytes = 1.0\\r\\n else:\\r\\n mixerbytes = 2.0\\r\\n numsamples = self.chunk.alen / mixerbytes / channels[0]\\r\\n return numsamples / frequency[0]\",\n \"def freq(self) -> int:\",\n \"def get_cw_freq(self):\\n return self.get_frequency(self.synth)\",\n \"def frequency(self):\\n return float(self.get_frequency())\",\n \"def get_freqs(filename):\\n full = io.read_file(filename)\\n full = full.strip('\\\\n')\\n full = full.split('[1/cm]')[1].split('Zero')[0]\\n full = full.split()\\n nfreqs = full[0]\\n freqs = full[1:]\\n # [freq=float(freq) for freq in freqs]\\n freqs = np.array(list(map(float, freqs)))\\n a = freqs.argsort()[::-1]\\n freqs = np.sort(freqs)[::-1]\\n return freqs.tolist(), a.tolist()\",\n \"def get_list_frequencies(self):\\r\\n return self.fs\",\n \"def get_list_frequencies(self):\\r\\n s = self.query('LIST:FREQ?')\\r\\n if s == None: return None\\r\\n a = []\\r\\n n = 0\\r\\n for x in s.split(','):\\r\\n try:\\r\\n a.append(float(x.strip()))\\r\\n except:\\r\\n print('ERROR get_list_frequencies(): non-float in list ', n, x)\\r\\n n += 1\\r\\n return a\",\n \"def width(self):\\n return np.array([f.width() for f in self])\",\n \"def frequency(self):\\n return self.reference_clock_speed / 4096 / self.prescale_reg\",\n \"def ps_freq_axis(dt, n):\\n\\n frequency = sp.arange(n//2, dtype=float)\\n df = 1.0/dt/n\\n frequency *= df\\n return frequency\",\n \"def convert_to_spectral_cube(self):\\n if self.data.ndim == 4:\\n raise cu.CubeError(4, \\\"Too many dimensions: Can only convert a \\\" +\\n \\\"3D cube. Slice the cube before converting\\\")\\n if 'WAVE' not in self.axes_wcs.wcs.ctype:\\n raise cu.CubeError(2, 'Spectral axis needed to create a spectrum')\\n axis = 0 if self.axes_wcs.wcs.ctype[-1] == 'WAVE' else 1\\n coordaxes = [1, 2] if axis == 0 else [0, 2] # Non-spectral axes\\n newwcs = wu.reindex_wcs(self.axes_wcs, np.arary(coordaxes))\\n time_or_x_size = self.data.shape[coordaxes[1]]\\n y_size = self.data.shape[coordaxes[0]]\\n spectra = np.empty((time_or_x_size, y_size), dtype=Spectrum)\\n for i in range(time_or_x_size):\\n for j in range(y_size):\\n spectra[i][j] = self.slice_to_spectrum(i, j)\\n return SpectralCube(spectra, newwcs, self.meta)\",\n \"def center_frequencies(self):\\n return (band.center_frequency for band in self)\",\n \"def get_ao_manual_control_freq( channel ):\\n freq = float64(0)\\n CALL('GetPhysicalChanAOManualControlFreq', channel, byref(freq))\\n return freq.value\",\n \"def samp_from_freq(n_samples):\\n datapath = os.path.normpath(os.getcwd()+os.sep+os.pardir+os.sep+\\\"Dataset\\\"+os.sep+\\\"All_channels_500hz.npy\\\")\\n data = np.load(datapath)\\n fourier = np.fft.rfft(data,axis=0)\\n fourier_mean = np.mean(fourier,axis=1)\\n print(fourier.shape)\\n print(fourier_mean.shape)\\n signal = np.fft.irfft(fourier_mean)[1:]\\n plt.plot(fourier_mean[1:])\\n plt.show()\\n plt.plot(signal)\\n plt.show()\\n #Generating frequency spectrum\\n \\\"\\\"\\\"\\n x = np.linspace(0,100,251)\\n x2 = np.linspace(0,5,251)\\n spectrum = 50*np.exp(-(x-30)**2/2)\\n spectrum += 60*np.sin(np.random.randn(251)*2*np.pi)*np.exp(-x2)\\n #spectrum += np.random.randn(251)\\n plt.plot(spectrum)\\n plt.show()\\n signal = np.fft.irfft(spectrum)\\n plt.plot(signal)\\n plt.show()\\n \\\"\\\"\\\"\\n signal = None\\n return signal\",\n \"def freqs(self, xs):\\n return [self.freq(x) for x in xs]\",\n \"def Hz(self,kx,ky):\\n return self.m-2.*self.t2*np.sin(self.phi)*(np.sin(3.*kx/2.+np.sqrt(3.)*ky/2.)+np.sin(-3.*kx/2.+np.sqrt(3.)*ky/2.)+np.sin(-np.sqrt(3.)*ky))\",\n \"def getFreq(self, sym = None):\\n if self.tot > 0:\\n if sym == None:\\n freq = tuple([ y / self.tot for y in self.cnt ])\\n return freq\\n else:\\n idx = self.alpha.getIndex( sym )\\n return self.cnt[idx] / self.tot\\n return None\",\n \"def all_modes(self):\\n\\n with open(f'gj_{self.molecule.name}.log', 'r') as gj_log_file:\\n\\n lines = gj_log_file.readlines()\\n freqs = []\\n\\n # Stores indices of rows which will be used\\n freq_positions = []\\n for count, line in enumerate(lines):\\n if line.startswith(' Frequencies'):\\n freq_positions.append(count)\\n\\n for pos in freq_positions:\\n freqs.extend(float(num) for num in lines[pos].split()[2:])\\n\\n return array(freqs)\",\n \"def get_frequency(self):\\r\\n return self._api.get_frequency()\",\n \"def freq_of_t(self, times):\\n y = np.zeros(len(times))\\n amplitudes, phases = self._ampl_phase(self.fourier_coeffs)\\n for n, (ampl, phase) in enumerate(zip(amplitudes, phases)):\\n omega_n = 2*np.pi*self.pzt_freq*(n+1)\\n y+=ampl*np.cos(omega_n*times + phase)\\n return y\",\n \"def get_frequency(time_series):\\n if len(time_series.index) == 0:\\n return 0\\n ft = np.fft.rfft(time_series)\\n return np.fft.fftfreq(len(time_series))[np.argmax(abs(ft))]\",\n \"def getMeasures():\",\n \"def get_spectrum(self) -> pd.Series:\\n short_time_spectrum = self.get_short_time_spectrum()\\n raw_spectrum = short_time_spectrum.sum(axis=1)\\n frequencies = librosa.fft_frequencies(\\n sr=self.sample_rate,\\n n_fft=self.n_fft\\n )\\n spectrum = pd.Series(raw_spectrum, frequencies)\\n return spectrum\",\n \"def raw_counts(self):\\n return np.array([1, 2, 3])\",\n \"def raw_counts(self):\\n return np.array([1, 2, 3])\",\n \"def getAllSpectrumMeasurements(self): \\n return self.spectrum\",\n \"def rfft2d_freqs(h, w):\\n fy = np.fft.fftfreq(h)[:, None]\\n fx = np.fft.fftfreq(w)\\n return np.sqrt(fx * fx + fy * fy)\",\n \"def get_list_frequencies(self):\\r\\n s = self.query('SOUR1:LIST:FREQ?')\\r\\n if s == None: return None\\r\\n a = []\\r\\n n = 0\\r\\n for x in s.split(','):\\r\\n try:\\r\\n a.append(float(x.strip()))\\r\\n except:\\r\\n print('ERROR get_list_frequencies(): non-float in list ', n, x)\\r\\n n += 1\\r\\n return a\",\n \"def get_list_frequencies(self):\\r\\n s = self.query('SOUR1:LIST:FREQ?')\\r\\n if s == None: return None\\r\\n a = []\\r\\n n = 0\\r\\n for x in s.split(','):\\r\\n try:\\r\\n a.append(float(x.strip()))\\r\\n except:\\r\\n print('ERROR get_list_frequencies(): non-float in list ', n, x)\\r\\n n += 1\\r\\n return a\",\n \"def frequency(self):\\n return self.reference_clock_speed / 4096 / self.prescale_reg\",\n \"def validate_freqs_array(data, axis=None):\\n if (data < 0).any():\\n raise ValueError(\\\"negative frequency not allowed\\\")\\n\\n # we explicitly ignore nan\\n result = data.sum(axis=axis)\\n if not numpy.allclose(result[numpy.isnan(result) == False], 1):\\n raise ValueError(\\\"invalid frequencies, sum(axis=1) is not equal to 1\\\")\",\n \"def freqspace2(dim):\\n (minval, maxval) = (-dim, dim-1) if (dim % 2 == 0) else (1-dim, dim)\\n return np.asarray(range(minval,maxval,2)) / dim\",\n \"def get_freqs(Fs, n):\\r\\n\\r\\n return np.linspace(0, float(Fs) / 2, float(n) / 2 + 1)\",\n \"def wave_samples(self):\\n return self._quantized_subsamples\",\n \"def measure_program(self, channels: Iterable[str]) -> Dict[str, numpy.ndarray]:\",\n \"def gen_freqs(ndata, dt):\\n dn = 2 # if you like the central frequency to be negative, change dn to 1\\n return 1/(ndata*dt) * np.hstack((np.arange(0, (ndata+dn)//2),\\n np.arange(-(ndata+dn)//2+dn, 0)))\",\n \"def get_freq(self):\\n return self.freq\",\n \"def raw_counts(self):\\n return np.array([[1, 2], [3, 4], [5, 6]])\",\n \"def get_fft(u: np.ndarray, n: int) -> np.ndarray:\\n\\n # We get the fft of each time slice.\\n num_slices = u.shape[0]\\n ut = np.empty(u.shape, dtype=complex) # shape (20, 262144)\\n for s in range(num_slices):\\n # We reshape each slice into a 3D cube.\\n u_slice = np.reshape(u[s,:], (n, n, n)) # shape (64, 64, 64)\\n # We then take the fft of the 3D cube and add it to ut.\\n ut_slice = np.fft.fftshift(np.fft.fftn(u_slice)) # shape (64, 64, 64)\\n ut[s, :] = ut_slice.flatten()\\n\\n return ut\",\n \"def get_scale_freq():\\n return sf / 2 / (num_freq-1)\",\n \"def get_center_freq(self, chan=0):\\n return _uhd_swig.usrp_sink_get_center_freq(self, chan)\",\n \"def _get_frequencies(data, col, col_vals, agg_col, agg_unit, agg_to_data):\\n interesting_data = None\\n frequencies = {}\\n for col_val in col_vals:\\n frequencies[col_val] = 0\\n # We can't just use collections.Counter() because frequencies.keys() is used to determine\\n # the range of possible values in other functions.\\n if _PANDAS_AVAILABLE and isinstance(data, pd.DataFrame):\\n interesting_data = agg_to_data[agg_unit][col]\\n for name in interesting_data:\\n if name in frequencies:\\n frequencies[name] = frequencies[name] + 1\\n else: # Assumes it is an np.ndarray\\n for row in itertools.ifilter(lambda row : row[agg_col] == agg_unit, data):\\n if row[col] in frequencies:\\n frequencies[row[col]] += 1\\n return frequencies, interesting_data\",\n \"def get_frequency(self):\\n\\n #TODO\\n\\n\\n self.__running_time = round(time.time() * 1000) - self.__running_time\\n\\n return self.__frequency_dict\",\n \"def in_freq(self):\\n if self._in_freq is None:\\n self._in_freq = np.fft.rfft(self._in_time)\\n return self._in_freq\",\n \"def spectral_variance(data, fft_data):\\n return np.var(np.abs(fft_data))\",\n \"def get_wavelengths(system, info=False):\\n\\n system_data = system.SystemData\\n wavelengths = system_data.Wavelengths\\n N_wavelengths = wavelengths.NumberOfWavelengths\\n\\n if info is True:\\n print(\\\"\\\\nReading Wavelengths\\\")\\n print(\\\"Total Number of Wavelengths: %d\\\" % N_wavelengths)\\n\\n wavelength_array = np.zeros(N_wavelengths)\\n\\n for k in np.arange(1, N_wavelengths + 1):\\n _wave = wavelengths.GetWavelength(k).Wavelength\\n wavelength_array[k - 1] = _wave\\n\\n if info is True:\\n print(\\\"%.5f microns\\\" % _wave)\\n\\n return wavelength_array\",\n \"def measure_freq_simple(self, freq, resolution, channel):\\n if 0 < channel <= 3:\\n self.write(\\\":MEASURE:FREQ? {0}Hz {1}, (@{2})\\\".format(freq, resolution, channel))\",\n \"def Get_Meas_Res_Wave_Count(self, mode, ch=1):\\n rdStr = self.query(f':MEAS{ch}:RES:WFMC? {mode}')\\n return rdStr\",\n \"def _ica_by_freq(S):\\n \\n n_samples, n_frames , n_frequencies= S.shape\\n T = np.zeros(S.shape, dtype=np.complex64)\\n WK = np.zeros([n_samples, n_samples, n_frequencies], dtype=np.complex64)\\n\\n for l in range(n_frequencies):\\n M = S[:,:,l].T\\n M = M.astype(np.complex64)\\n M /= M.std(axis = 0)\\n ica = ComplexFastICA(n_components=n_samples)\\n N = ica.fit_transform(M).T\\n T[:,:,l] = N\\n WK[:,:,l] = ica.components_\\n\\n return T, WK\",\n \"def get_fft(self, x, y, z):\\n avg = (np.array(x) + np.array(y) + np.array(z))/3\\n return np.abs(fft(avg)/len(avg))[1:len(avg)//2]\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6470279","0.6461034","0.64269227","0.6334639","0.6251372","0.61910397","0.59662837","0.5920204","0.5918302","0.59053004","0.5890902","0.5809529","0.57999116","0.57967234","0.5774496","0.57175756","0.57160854","0.5687078","0.5675256","0.5670857","0.5638822","0.56028795","0.5602823","0.559636","0.55812407","0.5572434","0.55699736","0.5553274","0.5552435","0.5551911","0.5527282","0.5508011","0.5494833","0.5488224","0.5482652","0.5476396","0.54735893","0.5471359","0.54656166","0.54232144","0.54080707","0.54041415","0.5396084","0.5396084","0.5389505","0.53757","0.53723407","0.5372033","0.53708243","0.53515613","0.5340061","0.5336139","0.5314595","0.53129536","0.5312847","0.53100294","0.529695","0.5296853","0.52966976","0.529478","0.5292325","0.5286445","0.5284208","0.52805847","0.5278513","0.5276356","0.5271519","0.52705693","0.52612686","0.5259076","0.52452207","0.5241333","0.52333397","0.5232692","0.5232692","0.52296996","0.52178603","0.5214042","0.5214042","0.52097166","0.52021646","0.5198957","0.51985407","0.5197027","0.5196559","0.51934195","0.5193242","0.5183928","0.51763654","0.51712644","0.5168705","0.51628274","0.5154397","0.51492095","0.51335293","0.5126834","0.5116772","0.510259","0.5100085","0.5084377"],"string":"[\n \"0.6470279\",\n \"0.6461034\",\n \"0.64269227\",\n \"0.6334639\",\n \"0.6251372\",\n \"0.61910397\",\n \"0.59662837\",\n \"0.5920204\",\n \"0.5918302\",\n \"0.59053004\",\n \"0.5890902\",\n \"0.5809529\",\n \"0.57999116\",\n \"0.57967234\",\n \"0.5774496\",\n \"0.57175756\",\n \"0.57160854\",\n \"0.5687078\",\n \"0.5675256\",\n \"0.5670857\",\n \"0.5638822\",\n \"0.56028795\",\n \"0.5602823\",\n \"0.559636\",\n \"0.55812407\",\n \"0.5572434\",\n \"0.55699736\",\n \"0.5553274\",\n \"0.5552435\",\n \"0.5551911\",\n \"0.5527282\",\n \"0.5508011\",\n \"0.5494833\",\n \"0.5488224\",\n \"0.5482652\",\n \"0.5476396\",\n \"0.54735893\",\n \"0.5471359\",\n \"0.54656166\",\n \"0.54232144\",\n \"0.54080707\",\n \"0.54041415\",\n \"0.5396084\",\n \"0.5396084\",\n \"0.5389505\",\n \"0.53757\",\n \"0.53723407\",\n \"0.5372033\",\n \"0.53708243\",\n \"0.53515613\",\n \"0.5340061\",\n \"0.5336139\",\n \"0.5314595\",\n \"0.53129536\",\n \"0.5312847\",\n \"0.53100294\",\n \"0.529695\",\n \"0.5296853\",\n \"0.52966976\",\n \"0.529478\",\n \"0.5292325\",\n \"0.5286445\",\n \"0.5284208\",\n \"0.52805847\",\n \"0.5278513\",\n \"0.5276356\",\n \"0.5271519\",\n \"0.52705693\",\n \"0.52612686\",\n \"0.5259076\",\n \"0.52452207\",\n \"0.5241333\",\n \"0.52333397\",\n \"0.5232692\",\n \"0.5232692\",\n \"0.52296996\",\n \"0.52178603\",\n \"0.5214042\",\n \"0.5214042\",\n \"0.52097166\",\n \"0.52021646\",\n \"0.5198957\",\n \"0.51985407\",\n \"0.5197027\",\n \"0.5196559\",\n \"0.51934195\",\n \"0.5193242\",\n \"0.5183928\",\n \"0.51763654\",\n \"0.51712644\",\n \"0.5168705\",\n \"0.51628274\",\n \"0.5154397\",\n \"0.51492095\",\n \"0.51335293\",\n \"0.5126834\",\n \"0.5116772\",\n \"0.510259\",\n \"0.5100085\",\n \"0.5084377\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.55794877"},"document_rank":{"kind":"string","value":"25"}}},{"rowIdx":24986,"cells":{"query":{"kind":"string","value":"Returns whether the wcs system and the array are wellaligned."},"document":{"kind":"string","value":"def _array_is_aligned(self):\n rot_matrix = self.axes_wcs.wcs.pc\n return np.allclose(rot_matrix, np.eye(self.axes_wcs.wcs.naxis))"},"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 isaligned(a: np.ndarray, alignment: int) -> bool:\n return (a.ctypes.data % alignment) == 0","def is_aligned(self):\n\n return self._bits == 0","def has_wcs(self):\n if self.header is None:\n return False\n\n required = 'CRPIX,CRVAL,CTYPE'.split(',')\n keywords = np.concatenate(\n [(lambda i: [r+str(i+1) for r in required])(i) \n for i in range(self.header['NAXIS'])])\n\n return all([k in self.header for k in keywords])","def _consistentWithWA_(self, span, lan):\n\t\tif lan == 'src':\n\t\t\twordAlign = self.waMatrix\n\t\telse:\n\t\t\twordAlign = [[self.waMatrix[i][j] for i in xrange(len(self.waMatrix))] for j in xrange(len(self.waMatrix[0]))] \n\n\t\tpos1 = [j for i in xrange(span[0], span[1]) for j in xrange(len(wordAlign[i])) if wordAlign[i][j] == 1]\n\t\tif pos1 == []: return True\n\n\t\tfor i in xrange(span[0], span[1]):\n\t\t\tfor j in xrange(min(pos1), max(pos1) + 1):\n\t\t\t\tif sum([wordAlign[row][j] for row in xrange(len(wordAlign[:span[0]]))]) == 0 and \\\n\t\t\t\t\t\tsum([wordAlign[row][j] for row in xrange(span[1], len(wordAlign))]) == 0:\n\t\t\t\t\tcontinue\n\t\t\t\telse:\n\t\t\t\t\treturn False\n\t\t#print >> debug_log, 'consistent:', span\n\t\treturn True","def isAligned(self):\n return (\n abs(self.desired_distance - self.vision.getDistance())\n <= self.DISTANCE_TOLERANCE\n ) and (abs(self.vision.getHeading()) <= self.HEADING_TOLERANCE)","def has_wcs(self):\n return self.wcs is not None","def _check_wcs_structure(self, wcs):\n if wcs is None:\n return False, \"WCS cannot be None.\"\n\n if not wcs.is_celestial:\n return False, \"WCS must be exclusively a celestial WCS.\"\n\n wcs = wcs.deepcopy()\n naxis1, naxis2 = wcs.pixel_shape\n\n # check mapping of corners and CRPIX:\n pts = np.array([[1.0, 1.0], [1.0, naxis2], [naxis1, 1.0],\n [naxis1, naxis2], wcs.wcs.crpix])\n\n sky_all = wcs.all_pix2world(pts, 1)\n foc_all = wcs.pix2foc(pts, 1)\n\n # strip all *known* distortions:\n wcs.cpdis1 = None\n wcs.cpdis2 = None\n wcs.det2im1 = None\n wcs.det2im2 = None\n wcs.sip = None\n\n # check that pix2foc includes no other distortions besides the ones\n # that we have turned off above:\n if not np.allclose(pts, wcs.pix2foc(pts, 1)):\n False, \"'pix2foc' contains unknown distortions\"\n\n wcs.wcs.set()\n\n # check that pix2foc contains all known distortions:\n if not np.allclose(wcs.all_world2pix(sky_all, 1), foc_all, atol=1e-3,\n rtol=0):\n return False, \"'WCS.pix2foc()' does not include all distortions.\"\n\n return True, ''","def is_aligned(self, A):\n return unique_element(imap(lambda v: v[1], A)) is not None","def regular(self):\n return all(numpy.allclose(w, w[0]) for w in self.binwidths)","def is_wcsaxes(axes):\n return isinstance(axes, wcsaxes.WCSAxes)","def is_wide(self) -> bool:\n return self.layout == \"planar\"","def is_array(space, w_obj):\n return space.wrap(w_obj.tp == space.tp_array)","def is_worthless(self):\n self.normalize()\n return self.all_details['normalized'] in WORTHLESS_UA_TYPES","def healthy_test(obj: np.ndarray) -> bool:\n nb_rows, nb_cols = obj.shape\n return nb_rows == nb_cols > 1 and np.array_equal(obj, colony(nb_rows))","def square(self):\n return self.regular and numpy.allclose(*(w[0] for w in self.binwidths))","def is_skew_symmetric(self):\n return self.all_equal(-self.transpose())","def maybe_rectal(self):\n return bool(set(self.locations) & set(StandardTerminology.RECTAL_LOCATIONS))","def _validate_axes(self):\n if not (\n np.abs(self.axis_u.dot(self.axis_v) < 1e-6)\n and np.abs(self.axis_v.dot(self.axis_w) < 1e-6)\n and np.abs(self.axis_w.dot(self.axis_u) < 1e-6)\n ):\n raise ValueError(\"axis_u, axis_v, and axis_w must be orthogonal\")\n return True","def maybe_distal(self):\n return bool(set(self.locations) & set(StandardTerminology.DISTAL_LOCATIONS))","def check_wf_2d(ψ: ndarray):\n pass","def is_pure(self) -> np.ndarray:\n return np.isclose(self.w, np.zeros_like(self.w.shape[0]))","def is_affine_st(A, tol=1e-10):\n (_, wx, _,\n wy, _, _,\n *_) = A\n\n return abs(wx) < tol and abs(wy) < tol","def isscalar(self):\n return not bool(self.shape)","def IsWholeWorld(self, resolution=None):\n if resolution is None:\n resolution = self.GetNativeResolution()\n\n spatial_ref = self.GetSpatialReference()\n world_extents = spatial_ref.GetWorldExtents()\n extents = self.GetExtents()\n ll_offset = world_extents.lower_left - extents.lower_left\n ur_offset = world_extents.upper_right - extents.upper_right\n\n pixel_sizes = spatial_ref.GetPixelDimensions(resolution=resolution)\n return (abs(ll_offset.x) <= pixel_sizes.x and\n abs(ll_offset.y) <= pixel_sizes.y and\n abs(ur_offset.x) <= pixel_sizes.x and\n abs(ur_offset.y) <= pixel_sizes.y)","def is_unitary(self):\n if self._coord_format != constants.MatrixCoordinateDefault:\n self._logger.error(\"invalid coordinate format\")\n raise NotImplementedError(\"invalid coordinate format\")\n\n round_precision = int(conf.get(\n self._sc, 'sparkquantum.math.roundPrecision'))\n\n return round(self.norm(), round_precision) == 1.0","def is_skew_component_fusion(self) -> bool:\n fcell = self.first_cell\n scell = self.second_cell\n if self._fuse_row:\n skew_ob = GriddedPerm((0, 1), (fcell, scell))\n else:\n skew_ob = GriddedPerm((0, 1), (fcell, scell))\n return skew_ob in self._tiling.obstructions","def is_symetric(self):\n for x, y in _triangle_range(self.size):\n\n if self.read(x, y) != self.read(y, x):\n return False\n\n return True","def isscalar(self):\n return not self.axes","def check(self):\n\n ok = True\n\n # check that each pair is ok on its own\n for winp in self.winps:\n if not winp.check():\n ok = False\n\n # check that no pairs overlap in the Y direction\n ystart0,xleft0,xright0,nx0,ny0 = self.winps[0].get()\n for winp in self.winps[1:]:\n ystart1,xleft1,xright1,nx1,ny1 = winp.get()\n if ystart0 is not None and ystart1 is not None and ny0 is not None and \\\n ystart1 < ystart0 + ny0:\n winp.ystart.config(bg=COL_WARN)\n ok = False\n ystart0,xleft0,xright0,nx0,ny0 = ystart1,xleft1,xright1,nx1,ny1\n\n return ok","def is_diagonal(self):\n return self.is_upper() and self.is_lower()","def is_at_intersection(self):\n directions = 0\n self.tile = (self.get_nearest_row(), self.get_nearest_col())\n if self.internal_map[self.tile[0] - 1][self.tile[1]] not in ('x', ):\n directions += 1\n if self.internal_map[self.tile[0] + 1][self.tile[1]] not in ('x', ):\n directions += 1\n if self.internal_map[self.tile[0]][self.tile[1] - 1] not in ('x', ):\n directions += 1\n if self.internal_map[self.tile[0]][self.tile[1] + 1] not in ('x', ):\n directions += 1\n return True if directions > 2 else False","def is_distal(self):\n return bool(set(self.locations) and set(self.locations) <= set(StandardTerminology.DISTAL_LOCATIONS)) \\\n or bool(self.depth and 16 < self.depth < 82)","def has_2D(self):\n\t\tif self.have_fastas is False:\n\t\t\tself._extract_fastas_from_fast5()\n\t\t\tself.have_fastas = True\n\n\t\tif self.fastas.get('twodirections') is not None:\n\t\t\treturn True\n\t\treturn False","def is_full_dimensional(self):\n\n return self.affine_dimension() == self.space_dimension()","def _infer_direction(self):\n data = self.get_data(None)\n if data is not None:\n # Infer the direction from the data\n if data._size > 1:\n data = data[0:2].array\n return bool(\n data.item(\n 0,\n )\n < data.item(\n 1,\n )\n )\n # --- End: if\n\n # Still here?\n data = self.get_bounds_data(None)\n if data is not None:\n # Infer the direction from the bounds\n b = data[(0,) * (data.ndim - 1)].array\n return bool(\n b.item(\n 0,\n )\n < b.item(\n 1,\n )\n )\n\n # Still here? Then infer the direction from the units.\n return not self.Units.ispressure","def has_compatible_ligands(self, identity):\n return ((len(self.bad_coords[identity]) == 0) and\n (not self.BAD_COORD_RESIDUE in self.inaccuracies[identity]))","def is_lower(self):\n M = self.rep\n for i in range(self.rows):\n for j in range(i + 1, self.cols):\n if M[i, j]:\n return False\n return True","def is_full(self):\n elements_in_sects = sum(\n map(opr.attrgetter(\"size\"), self.sects.values())\n )\n elements_in_total = fct.reduce(\n opr.mul, type(self).flatten_shape(self.shape), 1\n )\n res = elements_in_sects >= elements_in_total\n return res","def ispolycw(x, y):\n\n l = len(x)\n if l < 3:\n raise ValueError(\"ispolycw::X length is less than 3\")\n\n if len(y) < 3:\n raise ValueError(\"ispolycw::Y length is less than 3\")\n\n if l != len(y):\n raise ValueError(\"ispolycw::Non-equal sized arrays\")\n\n s = 0.0\n for k in range(0, l):\n kn = (k + 1) % l\n\n s += (x[kn] - x[k]) * (y[kn] + y[k])\n\n return (s > 0.0, 0.5*s) # CW flag, signed area of the polygon","def _validate_mesh(self):\n if not (np.abs(self.axis_u.dot(self.axis_v) < 1e-6) and #pylint: disable=no-member\n np.abs(self.axis_v.dot(self.axis_w) < 1e-6) and #pylint: disable=no-member\n np.abs(self.axis_w.dot(self.axis_u) < 1e-6)): #pylint: disable=no-member\n raise ValueError('axis_u, axis_v, and axis_w must be orthogonal')\n return True","def has_intermediate_table(self):\r\n if (self.intermediate_spherical_right is not None or self.intermediate_cylinder_right is not None\r\n or self.intermediate_axis_right is not None or self.intermediate_av_right is not None or\r\n self.intermediate_dnp_right is not None\r\n or self.intermediate_spherical_left is not None or self.intermediate_cylinder_left is not None\r\n or self.intermediate_axis_left is not None or self.intermediate_av_left is not None or\r\n self.intermediate_dnp_left is not None):\r\n return True\r\n return False","def __word_is_near_border(bbox, margin, window_w, window_h):\n # [0][1] [2][3]\n #\n # [4][5] [6][7]\n if bbox[2] > window_w - margin or bbox[6] > window_w - margin:\n return True\n if bbox[5] > window_h - margin or bbox[7] > window_h - margin:\n return True\n return False","def _check_real_symmetric(A: np.array) -> bool:\n return np.allclose(A, A.T, atol=1e-9)","def is_crossed(self):\n left_boundary_clusters = np.extract(self.cluster[0] > 0,\n self.cluster[0])\n right_boundary_clusters = np.extract(self.cluster[-1] > 0,\n self.cluster[-1])\n return np.in1d(left_boundary_clusters, right_boundary_clusters).any()","def verify_legal_rotation(self, direction):\n test_figure = None\n if direction == \"CW\":\n test_figure = self.get_block_positions(self.active_piece.get_cw_rotation())\n elif direction == \"CCW\":\n test_figure = self.get_block_positions(self.active_piece.get_ccw_rotation())\n\n for b_x, b_y in test_figure:\n if b_x < 0 or b_x >= self.WIDTH:\n return False\n\n if b_y < 0 or b_y >= self.HEIGHT:\n return False\n\n if self.board[b_y][b_x] != 0:\n return False\n return True","def isscalar(array):\n arr = ma.array(array)\n if not hasattr(arr, '__len__') or arr.shape == () or len(arr) == 1:\n return True\n return False","def is_skew_symmetric(self):\n return self._info['skew_symmetric']","def valid(self):\n return len(self.wvalues) != 0","def is_up_diagonal_win(self, checker):\r\n for row in range(self.height - self.win_condition + 1):\r\n for col in range(self.width - self.win_condition + 1):\r\n num_checkers = 0\r\n for i in range(self.win_condition):\r\n if self.grid[self.height - row - 1 - i][col+i] == checker:\r\n num_checkers += 1\r\n\r\n if num_checkers == self.win_condition:\r\n return True\r\n\r\n # if we get here, there's no horizontal win\r\n return False","def _check_dimensions(self, workspace_to_check):\n for i in range(self._raw_ws.getNumDims()):\n if self._raw_ws.getDimension(i).getNBins() != workspace_to_check._raw_ws.getDimension(i).getNBins():\n return False\n return True","def wid_in(self, wid):\n \n for row in self.tiles:\n if wid in row:\n return True\n return False","def is_tqumap_wt(obj):\n return (hasattr(obj, 'nx') and hasattr(obj, 'dx') and hasattr(obj, 'ny')\n and hasattr(obj, 'dy') and hasattr(obj, 'weight'))","def col_clashes(bs, c):\r\n for i in range(c): # Look at all columns to the left of c\r\n if share_diagonal(i, bs[i], c, bs[c]):\r\n return True\r\n\r\n return False # No clashes - col c has a safe placement.\r","def contains(self, x):\n # need more to assure its a real SSP - ie on right torus\n return (len(x) == self._shape[0])","def check_consistency(self):\n assert len(self.shape) == len(self.qhape) == len(self.dirs)\n # Qnums must be unique within a qim and correspond one-to-one with\n # dimensions in dim.\n assert all(\n (\n len(dim) == len(qim) == len(set(qim))\n for dim, qim in zip(self.shape, self.qhape)\n )\n )\n assert all(d == 1 or d == -1 for d in self.dirs)\n assert all(q == self._qod_func(q) for q in sum(self.qhape, []))\n # Check that every sect has a valid key and the correct shape and\n # dtype.\n for k, v in self.sects.items():\n assert v.dtype == self.dtype\n assert self.is_valid_key(k)\n block_shp_real = v.shape\n qnum_inds = tuple(\n self.qhape[i].index(qnum) for i, qnum in enumerate(k)\n )\n block_shp_claimed = tuple(\n [self.shape[i][j] for i, j in enumerate(qnum_inds)]\n )\n assert block_shp_claimed == block_shp_real\n if self.invar and (self.charge != 0 or not self.isscalar()):\n assert self.defval == 0\n return True","def winsFor(self, ox):\n for row in range(self.height):\n for col in range(self.width):\n if self.horizontal(ox, row, col) or self.vertical(ox, row, col) or self.diagnol(ox, row, col) or self.negDiagnol(ox, row, col) == ox:\n return True\n return False","def is_horizontal_win(self, checker):\n for row in range(self.height):\n for col in range(self.width - 3):\n # Check if the next four columns in this row\n # contain the specified checker.\n if self.slots[row][col] == checker and \\\n self.slots[row][col + 1] == checker and \\\n self.slots[row][col + 2] == checker and \\\n self.slots[row][col + 3] == checker:\n return True\n \n # if we make it here, there were no horizontal wins\n return False","def check(self):\n\n # get values\n ystart, xleft, xright, nx, ny = self.get()\n\n # are they all OK individually?\n ok = self.ystart.ok() and self.xleft.ok() and self.xright.ok() and \\\n self.nx.ok() and self.ny.ok()\n\n # now come cross-value checks:\n\n # is rightmost pixel of lefthand window within range\n if xleft is None or xleft + nx - 1 > 512:\n self.xleft.config(bg=COL_WARN)\n ok = False\n\n # is rightmost pixel of righthand window within range\n if xright is None or xright + nx - 1 > 1024:\n self.xright.config(bg=COL_WARN)\n ok = False\n\n # is top pixel within range\n if ystart is None or ystart + ny - 1 > 1024:\n self.ystart.config(bg=COL_WARN)\n ok = False\n\n if ok:\n # set all OK is everything checks\n self.ystart.config(bg=COL_TEXT_BG)\n self.xleft.config(bg=COL_TEXT_BG)\n self.xright.config(bg=COL_TEXT_BG)\n self.nx.config(bg=COL_TEXT_BG)\n self.ny.config(bg=COL_TEXT_BG)\n \n return ok","def _check_zero(self, h, i, j, u, v, w):\n return self._.p[u, h, i] != 0 and self._.p[v, h, j] != 0 and \\\n self._.p[w, i, j] != 0","def _is_mapping_correct(self):\n for i in range(self.mapping_size):\n target = self.mapping[i]\n if target < 0:\n continue\n if target == i // 2:\n continue\n return False\n return True","def is_vector(self):\n return True if self.width > 1 else False","def is_square(self):\n lines, columns = self.get_size()\n return lines == columns","def isLegal(self):\n # checks for same values in rows\n for n in range(9):\n rows = set()\n for m in range(9):\n if self.puzzle[n][m] != 0:\n size = len(rows)\n rows.add(self.puzzle[n][m])\n if size == len(rows):\n return False\n\n #checks for same values in columns\n for m in range(9):\n cols = set()\n for n in range(9):\n if self.puzzle[n][m] != 0:\n size = len(cols)\n cols.add(self.puzzle[n][m])\n if size == len(cols):\n return False\n\n #checks for same values in sections\n sections = [[0, 1, 2], [3, 4, 5], [6, 7, 8]]\n for r in sections:\n for c in sections:\n sects = set()\n for n in r:\n for m in c:\n if self.puzzle[n][m] != 0:\n size = len(sects)\n sects.add(self.puzzle[n][m])\n if size == len(sects):\n return False\n return True","def is_legal(self):\n if not self._is_valid():\n return False\n\n if not self._check_all(self.get_rows()):\n return False\n\n if not self._check_all(self.get_cols()):\n return False\n\n if not self._check_all(self.get_blocks()):\n return False\n\n return True","def _is_h_contrained(self, m):\n available_area = self._get_render_area_size()\n map_aspect = m.envelope().width() / m.envelope().height()\n page_aspect = available_area[0] / available_area[1]\n\n return map_aspect > page_aspect","def is_up_diagonal_win(self, checker):\n for row in range(3, self.height):\n for col in range(self.width-3):\n if self.slots[row][col] == checker and \\\n self.slots[row-1][col+1] == checker and \\\n self.slots[row-2][col+2] == checker and \\\n self.slots[row-3][col+3] == checker:\n return True\n return False","def test02(self):\n a = np.arange(1, 1e5) < 0\n b = bcolz.carray(a)\n wt = a.nonzero()[0].tolist()\n cwt = [i for i in b.wheretrue()]\n # print \"numpy ->\", a.nonzero()[0].tolist()\n # print \"where ->\", [i for i in b.wheretrue()]\n self.assertTrue(wt == cwt, \"wheretrue() does not work correctly\")","def is_east(longitudes):\n return np.asarray(longitudes, dtype=\"d\") <= 0.","def test01(self):\n a = np.arange(1, 11) < 0\n b = bcolz.carray(a)\n wt = a.nonzero()[0].tolist()\n cwt = [i for i in b.wheretrue()]\n # print \"numpy ->\", a.nonzero()[0].tolist()\n # print \"where ->\", [i for i in b.wheretrue()]\n self.assertTrue(wt == cwt, \"wheretrue() does not work correctly\")","def test_align_sanity(self):\n # QWERTY resemblance matrix:\n R = qwerty_distance()\n diff, u, r = min_difference_align(\"polynomial\", \"exponential\", R)\n # Warning: we may (read: 'will') use another matrix!\n self.assertEqual(diff, 15)\n # Warning: there may be other optimal matchings!\n self.assertEqual(u, '--polyn-om-ial')\n self.assertEqual(r, 'exp-o-ne-ntial')","def vectorized(self):\n return False","def _in_bounds(self, x, y):\r\n return 0 <= x < 8 and 0 <= y < 8","def check_intersection(t, s):\n # Allow wiggle room nearby 0.\n if not (np.allclose(t, 0) or 0 <= t):\n return False\n\n # Allow wiggle room nearby 0.\n if not (np.allclose(s, 0) or 0 <= s):\n return False\n\n # Allow wiggle room nearby 1.\n if not (np.allclose(s, 1) or s <= 1):\n return False\n\n return True","def hasSpaceAround(self,x,y):\n global gamemap\n c = 0\n for x2 in xrange(-2,2):\n for y2 in xrange(-2,2):\n if self.near(x, y,x + x2,y + y2):\n if not gamemap[x + x2][y + y2].type[0]:\n c += 1\n if c >= 8:\n return False\n else:\n return True","def is_rectal(self):\n return bool(self.locations and set(self.locations) <= set(StandardTerminology.RECTAL_LOCATIONS)) \\\n or bool(self.depth and 4 <= self.depth <= 16)","def aligned(self):\n return self.__aligned","def isSafe(coords, row, col):\n rows = []\n cols = []\n diag_r = []\n diag_l = []\n\n for square in coords:\n rows.append(square[0])\n cols.append(square[1])\n diag_r.append(square[0] + square[1])\n diag_l.append(square[1] - square[0])\n\n if row in rows or col in cols:\n return False\n if row + col in diag_r or col - row in diag_l:\n return False\n\n return True","def checkConsistencyWithStrictUnits(self):\n return _libsbml.SBMLDocument_checkConsistencyWithStrictUnits(self)","def isscalar(x):\n arrayed_x = asarray(x)\n return asarray(x).ndim == 0 and arrayed_x.dtype != 'object'","def is_aligned_2d(self, p_list1, p_list2, p_left_key, p_top_key, p_width_key, p_height_key):\n # check if terms align vertically\n IVA = self.is_align_1D(p_list1, p_list2, p_left_key, p_width_key)\n # check if terms align horizonally\n IHA = self.is_align_1D(p_list1, p_list2, p_top_key, p_height_key)\n if IVA == True:\n # if terms align vertically get direction and distance\n return self.get_vertical_align_direction(p_list1, p_list2, p_top_key, p_height_key)\n elif IHA == True:\n # if terms align vertically get direction and distance\n return self.get_horizontal_align_direction(p_list1, p_list2, p_left_key, p_width_key)\n else: return None","def verify_page_alignment(toc):\n if len({len(toc_entry[2]) for toc_entry in toc}) != 1:\n return False\n return True","def isComplete(self):\n assert len(self._x) > 0\n assert len(self._y) > 0\n assert 2 == len(self._data_array.shape)\n assert self.wkt is not None\n assert self.wkt != ''\n\n return True","def find(self) -> bool:\n alignments = []\n for sw_idx in range(len(self.sw)):\n for nu_idx in range(len(self.nu)):\n alignments.append(Alignment(self.nu, self.sw, nu_idx, sw_idx, self.orig_nu))\n alignment = max(alignments, key=lambda align: align.score)\n if alignment.score > 0:\n self.alignment = alignment\n return True\n return False","def is_compatible(*, structure, symmetry):\n analyzer = mg.symmetry.analyzer.SpacegroupAnalyzer(structure)\n valid_sym_ops = analyzer.get_symmetry_operations(cartesian=False)\n for sym_op in valid_sym_ops:\n if (\n np.\n allclose(sym_op.translation_vector, symmetry.translation_vector)\n and np.allclose(sym_op.rotation_matrix, symmetry.rotation_matrix)\n ):\n return True\n return False","def is_west(longitudes):\n return ~is_east(longitudes)","def isWin(self):\n\n return self.tiles == self.winCdt","def has_near_table(self):\r\n if (self.near_spherical_right is not None or self.near_cylinder_right is not None\r\n or self.near_axis_right is not None or self.near_av_right is not None or\r\n self.near_dnp_right is not None\r\n or self.near_spherical_left is not None or self.near_cylinder_left is not None\r\n or self.near_axis_left is not None or self.near_av_left is not None or\r\n self.near_dnp_left is not None):\r\n return True\r\n return False","def _has_undercoordinated_carbon(self, tolerance: int = 10):\n undercoordinated_carbon = False\n\n for site_index in self.c_indices:\n cn = self.get_cn(site_index) # pylint:disable=invalid-name\n if cn == 2:\n # ToDo: Check if it is bound to metal, then it might be a carbide\n neighbors = self.get_connected_sites(site_index)\n angle = _maximum_angle(\n self.structure.get_angle(\n site_index, neighbors[0].index, neighbors[1].index\n )\n )\n if np.abs(180 - angle) > tolerance:\n undercoordinated_carbon = True\n break\n self._undercoordinated_carbon = undercoordinated_carbon","def isstationary(self):\n if np.all(np.abs(self.arroots) > 1.0):\n return True\n else:\n return False","def col_clashes(bs, c):\n for i in range(c): # check at all columns to the left of c\n if share_diagonal(i, bs[i], c, bs[c]):\n return True\n return False # no clashes - col c has a safe placement","def square_check(self):\n return len(self.matrix) == len(self.matrix[0])","def test00(self):\n a = np.arange(1, 11) > 0\n b = bcolz.carray(a)\n wt = a.nonzero()[0].tolist()\n cwt = [i for i in b.wheretrue()]\n # print \"numpy ->\", a.nonzero()[0].tolist()\n # print \"where ->\", [i for i in b.wheretrue()]\n self.assertTrue(wt == cwt, \"wheretrue() does not work correctly\")","def col_clashes(bs, c):\n for i in range(c): # Look at all columns to the left of c\n if share_diagonal(i, bs[i], c, bs[c]):\n return True\n\n return False # No clashes - col c has a safe placement","def magic_check(magic_square, magic_value):\n row_sum = np.sum(magic_square, axis=0)\n col_sum = np.sum(magic_square, axis=1)\n diag_sum = np.sum(np.diag(magic_square))\n if : # part b\n return True\n else:\n return False","def is_square(self):\n return self.shape[0] == self.shape[1]","def is_square(self):\n return self.shape[0] == self.shape[1]","def valid(self, nt_header):\n try:\n return (self.OriginalFirstThunk != 0 and\n self.OriginalFirstThunk < nt_header.OptionalHeader.SizeOfImage and\n self.FirstThunk != 0 and\n self.FirstThunk < nt_header.OptionalHeader.SizeOfImage and\n self.Name < nt_header.OptionalHeader.SizeOfImage)\n except obj.InvalidOffsetError:\n return False","def check_branch(self):\n n_d, d_d, h_d, w_d, c_d = self.dst_shape\n all_ele = d_d * self.c_1 * h_d * w_d * self.n_o * self.n_i * self.c_0\n out_ele = n_d * d_d * h_d * w_d * c_d\n dhw_d = d_d * h_d * w_d\n c_align = self.c_1 * self.c_0\n\n if n_d % 16 == 0:\n if c_d % self.c_0 == 0 and all_ele <= self.ub_ele:\n return \"c_align_small\"\n elif c_d % self.c_0 == 0\\\n and 1 <= self.ub_ele // (dhw_d * c_align) < n_d:\n return \"c_align_split_n\"\n elif c_d % self.c_0 > 0 and self.dtype == \"float16\"\\\n and out_ele * self.cp_align_len <= self.ub_ele:\n return \"c_not_align_small_fp16\"\n elif c_d % self.c_0 > 0 and self.dtype == \"float32\"\\\n and 1 <= self.ub_ele // (dhw_d * c_d * 16) < n_d:\n return \"c_not_align_split_n_fp32\"\n else:\n return \"not_support\"\n else:\n return \"not_support\"","def _check_normalization(self):\n lastDistance = None\n distance = None\n for idx in xrange(len(self) - 1):\n distance = self[idx+1][0] - self[idx][0]\n\n # first run\n if lastDistance is None:\n lastDistance = distance\n continue\n\n if lastDistance != distance:\n return False\n\n lastDistance = distance\n\n return True","def fl_is_inside_lalign(align):\n _fl_is_inside_lalign = library.cfuncproto(\n library.load_so_libforms(), \"fl_is_inside_lalign\", \\\n cty.c_int, [cty.c_int],\n \"\"\"int fl_is_inside_lalign(int align) \"\"\")\n library.check_if_flinitialized()\n i_align = library.convert_to_intc(align)\n library.keep_elem_refs(align, i_align)\n retval = _fl_is_inside_lalign(i_align)\n return retval"],"string":"[\n \"def isaligned(a: np.ndarray, alignment: int) -> bool:\\n return (a.ctypes.data % alignment) == 0\",\n \"def is_aligned(self):\\n\\n return self._bits == 0\",\n \"def has_wcs(self):\\n if self.header is None:\\n return False\\n\\n required = 'CRPIX,CRVAL,CTYPE'.split(',')\\n keywords = np.concatenate(\\n [(lambda i: [r+str(i+1) for r in required])(i) \\n for i in range(self.header['NAXIS'])])\\n\\n return all([k in self.header for k in keywords])\",\n \"def _consistentWithWA_(self, span, lan):\\n\\t\\tif lan == 'src':\\n\\t\\t\\twordAlign = self.waMatrix\\n\\t\\telse:\\n\\t\\t\\twordAlign = [[self.waMatrix[i][j] for i in xrange(len(self.waMatrix))] for j in xrange(len(self.waMatrix[0]))] \\n\\n\\t\\tpos1 = [j for i in xrange(span[0], span[1]) for j in xrange(len(wordAlign[i])) if wordAlign[i][j] == 1]\\n\\t\\tif pos1 == []: return True\\n\\n\\t\\tfor i in xrange(span[0], span[1]):\\n\\t\\t\\tfor j in xrange(min(pos1), max(pos1) + 1):\\n\\t\\t\\t\\tif sum([wordAlign[row][j] for row in xrange(len(wordAlign[:span[0]]))]) == 0 and \\\\\\n\\t\\t\\t\\t\\t\\tsum([wordAlign[row][j] for row in xrange(span[1], len(wordAlign))]) == 0:\\n\\t\\t\\t\\t\\tcontinue\\n\\t\\t\\t\\telse:\\n\\t\\t\\t\\t\\treturn False\\n\\t\\t#print >> debug_log, 'consistent:', span\\n\\t\\treturn True\",\n \"def isAligned(self):\\n return (\\n abs(self.desired_distance - self.vision.getDistance())\\n <= self.DISTANCE_TOLERANCE\\n ) and (abs(self.vision.getHeading()) <= self.HEADING_TOLERANCE)\",\n \"def has_wcs(self):\\n return self.wcs is not None\",\n \"def _check_wcs_structure(self, wcs):\\n if wcs is None:\\n return False, \\\"WCS cannot be None.\\\"\\n\\n if not wcs.is_celestial:\\n return False, \\\"WCS must be exclusively a celestial WCS.\\\"\\n\\n wcs = wcs.deepcopy()\\n naxis1, naxis2 = wcs.pixel_shape\\n\\n # check mapping of corners and CRPIX:\\n pts = np.array([[1.0, 1.0], [1.0, naxis2], [naxis1, 1.0],\\n [naxis1, naxis2], wcs.wcs.crpix])\\n\\n sky_all = wcs.all_pix2world(pts, 1)\\n foc_all = wcs.pix2foc(pts, 1)\\n\\n # strip all *known* distortions:\\n wcs.cpdis1 = None\\n wcs.cpdis2 = None\\n wcs.det2im1 = None\\n wcs.det2im2 = None\\n wcs.sip = None\\n\\n # check that pix2foc includes no other distortions besides the ones\\n # that we have turned off above:\\n if not np.allclose(pts, wcs.pix2foc(pts, 1)):\\n False, \\\"'pix2foc' contains unknown distortions\\\"\\n\\n wcs.wcs.set()\\n\\n # check that pix2foc contains all known distortions:\\n if not np.allclose(wcs.all_world2pix(sky_all, 1), foc_all, atol=1e-3,\\n rtol=0):\\n return False, \\\"'WCS.pix2foc()' does not include all distortions.\\\"\\n\\n return True, ''\",\n \"def is_aligned(self, A):\\n return unique_element(imap(lambda v: v[1], A)) is not None\",\n \"def regular(self):\\n return all(numpy.allclose(w, w[0]) for w in self.binwidths)\",\n \"def is_wcsaxes(axes):\\n return isinstance(axes, wcsaxes.WCSAxes)\",\n \"def is_wide(self) -> bool:\\n return self.layout == \\\"planar\\\"\",\n \"def is_array(space, w_obj):\\n return space.wrap(w_obj.tp == space.tp_array)\",\n \"def is_worthless(self):\\n self.normalize()\\n return self.all_details['normalized'] in WORTHLESS_UA_TYPES\",\n \"def healthy_test(obj: np.ndarray) -> bool:\\n nb_rows, nb_cols = obj.shape\\n return nb_rows == nb_cols > 1 and np.array_equal(obj, colony(nb_rows))\",\n \"def square(self):\\n return self.regular and numpy.allclose(*(w[0] for w in self.binwidths))\",\n \"def is_skew_symmetric(self):\\n return self.all_equal(-self.transpose())\",\n \"def maybe_rectal(self):\\n return bool(set(self.locations) & set(StandardTerminology.RECTAL_LOCATIONS))\",\n \"def _validate_axes(self):\\n if not (\\n np.abs(self.axis_u.dot(self.axis_v) < 1e-6)\\n and np.abs(self.axis_v.dot(self.axis_w) < 1e-6)\\n and np.abs(self.axis_w.dot(self.axis_u) < 1e-6)\\n ):\\n raise ValueError(\\\"axis_u, axis_v, and axis_w must be orthogonal\\\")\\n return True\",\n \"def maybe_distal(self):\\n return bool(set(self.locations) & set(StandardTerminology.DISTAL_LOCATIONS))\",\n \"def check_wf_2d(ψ: ndarray):\\n pass\",\n \"def is_pure(self) -> np.ndarray:\\n return np.isclose(self.w, np.zeros_like(self.w.shape[0]))\",\n \"def is_affine_st(A, tol=1e-10):\\n (_, wx, _,\\n wy, _, _,\\n *_) = A\\n\\n return abs(wx) < tol and abs(wy) < tol\",\n \"def isscalar(self):\\n return not bool(self.shape)\",\n \"def IsWholeWorld(self, resolution=None):\\n if resolution is None:\\n resolution = self.GetNativeResolution()\\n\\n spatial_ref = self.GetSpatialReference()\\n world_extents = spatial_ref.GetWorldExtents()\\n extents = self.GetExtents()\\n ll_offset = world_extents.lower_left - extents.lower_left\\n ur_offset = world_extents.upper_right - extents.upper_right\\n\\n pixel_sizes = spatial_ref.GetPixelDimensions(resolution=resolution)\\n return (abs(ll_offset.x) <= pixel_sizes.x and\\n abs(ll_offset.y) <= pixel_sizes.y and\\n abs(ur_offset.x) <= pixel_sizes.x and\\n abs(ur_offset.y) <= pixel_sizes.y)\",\n \"def is_unitary(self):\\n if self._coord_format != constants.MatrixCoordinateDefault:\\n self._logger.error(\\\"invalid coordinate format\\\")\\n raise NotImplementedError(\\\"invalid coordinate format\\\")\\n\\n round_precision = int(conf.get(\\n self._sc, 'sparkquantum.math.roundPrecision'))\\n\\n return round(self.norm(), round_precision) == 1.0\",\n \"def is_skew_component_fusion(self) -> bool:\\n fcell = self.first_cell\\n scell = self.second_cell\\n if self._fuse_row:\\n skew_ob = GriddedPerm((0, 1), (fcell, scell))\\n else:\\n skew_ob = GriddedPerm((0, 1), (fcell, scell))\\n return skew_ob in self._tiling.obstructions\",\n \"def is_symetric(self):\\n for x, y in _triangle_range(self.size):\\n\\n if self.read(x, y) != self.read(y, x):\\n return False\\n\\n return True\",\n \"def isscalar(self):\\n return not self.axes\",\n \"def check(self):\\n\\n ok = True\\n\\n # check that each pair is ok on its own\\n for winp in self.winps:\\n if not winp.check():\\n ok = False\\n\\n # check that no pairs overlap in the Y direction\\n ystart0,xleft0,xright0,nx0,ny0 = self.winps[0].get()\\n for winp in self.winps[1:]:\\n ystart1,xleft1,xright1,nx1,ny1 = winp.get()\\n if ystart0 is not None and ystart1 is not None and ny0 is not None and \\\\\\n ystart1 < ystart0 + ny0:\\n winp.ystart.config(bg=COL_WARN)\\n ok = False\\n ystart0,xleft0,xright0,nx0,ny0 = ystart1,xleft1,xright1,nx1,ny1\\n\\n return ok\",\n \"def is_diagonal(self):\\n return self.is_upper() and self.is_lower()\",\n \"def is_at_intersection(self):\\n directions = 0\\n self.tile = (self.get_nearest_row(), self.get_nearest_col())\\n if self.internal_map[self.tile[0] - 1][self.tile[1]] not in ('x', ):\\n directions += 1\\n if self.internal_map[self.tile[0] + 1][self.tile[1]] not in ('x', ):\\n directions += 1\\n if self.internal_map[self.tile[0]][self.tile[1] - 1] not in ('x', ):\\n directions += 1\\n if self.internal_map[self.tile[0]][self.tile[1] + 1] not in ('x', ):\\n directions += 1\\n return True if directions > 2 else False\",\n \"def is_distal(self):\\n return bool(set(self.locations) and set(self.locations) <= set(StandardTerminology.DISTAL_LOCATIONS)) \\\\\\n or bool(self.depth and 16 < self.depth < 82)\",\n \"def has_2D(self):\\n\\t\\tif self.have_fastas is False:\\n\\t\\t\\tself._extract_fastas_from_fast5()\\n\\t\\t\\tself.have_fastas = True\\n\\n\\t\\tif self.fastas.get('twodirections') is not None:\\n\\t\\t\\treturn True\\n\\t\\treturn False\",\n \"def is_full_dimensional(self):\\n\\n return self.affine_dimension() == self.space_dimension()\",\n \"def _infer_direction(self):\\n data = self.get_data(None)\\n if data is not None:\\n # Infer the direction from the data\\n if data._size > 1:\\n data = data[0:2].array\\n return bool(\\n data.item(\\n 0,\\n )\\n < data.item(\\n 1,\\n )\\n )\\n # --- End: if\\n\\n # Still here?\\n data = self.get_bounds_data(None)\\n if data is not None:\\n # Infer the direction from the bounds\\n b = data[(0,) * (data.ndim - 1)].array\\n return bool(\\n b.item(\\n 0,\\n )\\n < b.item(\\n 1,\\n )\\n )\\n\\n # Still here? Then infer the direction from the units.\\n return not self.Units.ispressure\",\n \"def has_compatible_ligands(self, identity):\\n return ((len(self.bad_coords[identity]) == 0) and\\n (not self.BAD_COORD_RESIDUE in self.inaccuracies[identity]))\",\n \"def is_lower(self):\\n M = self.rep\\n for i in range(self.rows):\\n for j in range(i + 1, self.cols):\\n if M[i, j]:\\n return False\\n return True\",\n \"def is_full(self):\\n elements_in_sects = sum(\\n map(opr.attrgetter(\\\"size\\\"), self.sects.values())\\n )\\n elements_in_total = fct.reduce(\\n opr.mul, type(self).flatten_shape(self.shape), 1\\n )\\n res = elements_in_sects >= elements_in_total\\n return res\",\n \"def ispolycw(x, y):\\n\\n l = len(x)\\n if l < 3:\\n raise ValueError(\\\"ispolycw::X length is less than 3\\\")\\n\\n if len(y) < 3:\\n raise ValueError(\\\"ispolycw::Y length is less than 3\\\")\\n\\n if l != len(y):\\n raise ValueError(\\\"ispolycw::Non-equal sized arrays\\\")\\n\\n s = 0.0\\n for k in range(0, l):\\n kn = (k + 1) % l\\n\\n s += (x[kn] - x[k]) * (y[kn] + y[k])\\n\\n return (s > 0.0, 0.5*s) # CW flag, signed area of the polygon\",\n \"def _validate_mesh(self):\\n if not (np.abs(self.axis_u.dot(self.axis_v) < 1e-6) and #pylint: disable=no-member\\n np.abs(self.axis_v.dot(self.axis_w) < 1e-6) and #pylint: disable=no-member\\n np.abs(self.axis_w.dot(self.axis_u) < 1e-6)): #pylint: disable=no-member\\n raise ValueError('axis_u, axis_v, and axis_w must be orthogonal')\\n return True\",\n \"def has_intermediate_table(self):\\r\\n if (self.intermediate_spherical_right is not None or self.intermediate_cylinder_right is not None\\r\\n or self.intermediate_axis_right is not None or self.intermediate_av_right is not None or\\r\\n self.intermediate_dnp_right is not None\\r\\n or self.intermediate_spherical_left is not None or self.intermediate_cylinder_left is not None\\r\\n or self.intermediate_axis_left is not None or self.intermediate_av_left is not None or\\r\\n self.intermediate_dnp_left is not None):\\r\\n return True\\r\\n return False\",\n \"def __word_is_near_border(bbox, margin, window_w, window_h):\\n # [0][1] [2][3]\\n #\\n # [4][5] [6][7]\\n if bbox[2] > window_w - margin or bbox[6] > window_w - margin:\\n return True\\n if bbox[5] > window_h - margin or bbox[7] > window_h - margin:\\n return True\\n return False\",\n \"def _check_real_symmetric(A: np.array) -> bool:\\n return np.allclose(A, A.T, atol=1e-9)\",\n \"def is_crossed(self):\\n left_boundary_clusters = np.extract(self.cluster[0] > 0,\\n self.cluster[0])\\n right_boundary_clusters = np.extract(self.cluster[-1] > 0,\\n self.cluster[-1])\\n return np.in1d(left_boundary_clusters, right_boundary_clusters).any()\",\n \"def verify_legal_rotation(self, direction):\\n test_figure = None\\n if direction == \\\"CW\\\":\\n test_figure = self.get_block_positions(self.active_piece.get_cw_rotation())\\n elif direction == \\\"CCW\\\":\\n test_figure = self.get_block_positions(self.active_piece.get_ccw_rotation())\\n\\n for b_x, b_y in test_figure:\\n if b_x < 0 or b_x >= self.WIDTH:\\n return False\\n\\n if b_y < 0 or b_y >= self.HEIGHT:\\n return False\\n\\n if self.board[b_y][b_x] != 0:\\n return False\\n return True\",\n \"def isscalar(array):\\n arr = ma.array(array)\\n if not hasattr(arr, '__len__') or arr.shape == () or len(arr) == 1:\\n return True\\n return False\",\n \"def is_skew_symmetric(self):\\n return self._info['skew_symmetric']\",\n \"def valid(self):\\n return len(self.wvalues) != 0\",\n \"def is_up_diagonal_win(self, checker):\\r\\n for row in range(self.height - self.win_condition + 1):\\r\\n for col in range(self.width - self.win_condition + 1):\\r\\n num_checkers = 0\\r\\n for i in range(self.win_condition):\\r\\n if self.grid[self.height - row - 1 - i][col+i] == checker:\\r\\n num_checkers += 1\\r\\n\\r\\n if num_checkers == self.win_condition:\\r\\n return True\\r\\n\\r\\n # if we get here, there's no horizontal win\\r\\n return False\",\n \"def _check_dimensions(self, workspace_to_check):\\n for i in range(self._raw_ws.getNumDims()):\\n if self._raw_ws.getDimension(i).getNBins() != workspace_to_check._raw_ws.getDimension(i).getNBins():\\n return False\\n return True\",\n \"def wid_in(self, wid):\\n \\n for row in self.tiles:\\n if wid in row:\\n return True\\n return False\",\n \"def is_tqumap_wt(obj):\\n return (hasattr(obj, 'nx') and hasattr(obj, 'dx') and hasattr(obj, 'ny')\\n and hasattr(obj, 'dy') and hasattr(obj, 'weight'))\",\n \"def col_clashes(bs, c):\\r\\n for i in range(c): # Look at all columns to the left of c\\r\\n if share_diagonal(i, bs[i], c, bs[c]):\\r\\n return True\\r\\n\\r\\n return False # No clashes - col c has a safe placement.\\r\",\n \"def contains(self, x):\\n # need more to assure its a real SSP - ie on right torus\\n return (len(x) == self._shape[0])\",\n \"def check_consistency(self):\\n assert len(self.shape) == len(self.qhape) == len(self.dirs)\\n # Qnums must be unique within a qim and correspond one-to-one with\\n # dimensions in dim.\\n assert all(\\n (\\n len(dim) == len(qim) == len(set(qim))\\n for dim, qim in zip(self.shape, self.qhape)\\n )\\n )\\n assert all(d == 1 or d == -1 for d in self.dirs)\\n assert all(q == self._qod_func(q) for q in sum(self.qhape, []))\\n # Check that every sect has a valid key and the correct shape and\\n # dtype.\\n for k, v in self.sects.items():\\n assert v.dtype == self.dtype\\n assert self.is_valid_key(k)\\n block_shp_real = v.shape\\n qnum_inds = tuple(\\n self.qhape[i].index(qnum) for i, qnum in enumerate(k)\\n )\\n block_shp_claimed = tuple(\\n [self.shape[i][j] for i, j in enumerate(qnum_inds)]\\n )\\n assert block_shp_claimed == block_shp_real\\n if self.invar and (self.charge != 0 or not self.isscalar()):\\n assert self.defval == 0\\n return True\",\n \"def winsFor(self, ox):\\n for row in range(self.height):\\n for col in range(self.width):\\n if self.horizontal(ox, row, col) or self.vertical(ox, row, col) or self.diagnol(ox, row, col) or self.negDiagnol(ox, row, col) == ox:\\n return True\\n return False\",\n \"def is_horizontal_win(self, checker):\\n for row in range(self.height):\\n for col in range(self.width - 3):\\n # Check if the next four columns in this row\\n # contain the specified checker.\\n if self.slots[row][col] == checker and \\\\\\n self.slots[row][col + 1] == checker and \\\\\\n self.slots[row][col + 2] == checker and \\\\\\n self.slots[row][col + 3] == checker:\\n return True\\n \\n # if we make it here, there were no horizontal wins\\n return False\",\n \"def check(self):\\n\\n # get values\\n ystart, xleft, xright, nx, ny = self.get()\\n\\n # are they all OK individually?\\n ok = self.ystart.ok() and self.xleft.ok() and self.xright.ok() and \\\\\\n self.nx.ok() and self.ny.ok()\\n\\n # now come cross-value checks:\\n\\n # is rightmost pixel of lefthand window within range\\n if xleft is None or xleft + nx - 1 > 512:\\n self.xleft.config(bg=COL_WARN)\\n ok = False\\n\\n # is rightmost pixel of righthand window within range\\n if xright is None or xright + nx - 1 > 1024:\\n self.xright.config(bg=COL_WARN)\\n ok = False\\n\\n # is top pixel within range\\n if ystart is None or ystart + ny - 1 > 1024:\\n self.ystart.config(bg=COL_WARN)\\n ok = False\\n\\n if ok:\\n # set all OK is everything checks\\n self.ystart.config(bg=COL_TEXT_BG)\\n self.xleft.config(bg=COL_TEXT_BG)\\n self.xright.config(bg=COL_TEXT_BG)\\n self.nx.config(bg=COL_TEXT_BG)\\n self.ny.config(bg=COL_TEXT_BG)\\n \\n return ok\",\n \"def _check_zero(self, h, i, j, u, v, w):\\n return self._.p[u, h, i] != 0 and self._.p[v, h, j] != 0 and \\\\\\n self._.p[w, i, j] != 0\",\n \"def _is_mapping_correct(self):\\n for i in range(self.mapping_size):\\n target = self.mapping[i]\\n if target < 0:\\n continue\\n if target == i // 2:\\n continue\\n return False\\n return True\",\n \"def is_vector(self):\\n return True if self.width > 1 else False\",\n \"def is_square(self):\\n lines, columns = self.get_size()\\n return lines == columns\",\n \"def isLegal(self):\\n # checks for same values in rows\\n for n in range(9):\\n rows = set()\\n for m in range(9):\\n if self.puzzle[n][m] != 0:\\n size = len(rows)\\n rows.add(self.puzzle[n][m])\\n if size == len(rows):\\n return False\\n\\n #checks for same values in columns\\n for m in range(9):\\n cols = set()\\n for n in range(9):\\n if self.puzzle[n][m] != 0:\\n size = len(cols)\\n cols.add(self.puzzle[n][m])\\n if size == len(cols):\\n return False\\n\\n #checks for same values in sections\\n sections = [[0, 1, 2], [3, 4, 5], [6, 7, 8]]\\n for r in sections:\\n for c in sections:\\n sects = set()\\n for n in r:\\n for m in c:\\n if self.puzzle[n][m] != 0:\\n size = len(sects)\\n sects.add(self.puzzle[n][m])\\n if size == len(sects):\\n return False\\n return True\",\n \"def is_legal(self):\\n if not self._is_valid():\\n return False\\n\\n if not self._check_all(self.get_rows()):\\n return False\\n\\n if not self._check_all(self.get_cols()):\\n return False\\n\\n if not self._check_all(self.get_blocks()):\\n return False\\n\\n return True\",\n \"def _is_h_contrained(self, m):\\n available_area = self._get_render_area_size()\\n map_aspect = m.envelope().width() / m.envelope().height()\\n page_aspect = available_area[0] / available_area[1]\\n\\n return map_aspect > page_aspect\",\n \"def is_up_diagonal_win(self, checker):\\n for row in range(3, self.height):\\n for col in range(self.width-3):\\n if self.slots[row][col] == checker and \\\\\\n self.slots[row-1][col+1] == checker and \\\\\\n self.slots[row-2][col+2] == checker and \\\\\\n self.slots[row-3][col+3] == checker:\\n return True\\n return False\",\n \"def test02(self):\\n a = np.arange(1, 1e5) < 0\\n b = bcolz.carray(a)\\n wt = a.nonzero()[0].tolist()\\n cwt = [i for i in b.wheretrue()]\\n # print \\\"numpy ->\\\", a.nonzero()[0].tolist()\\n # print \\\"where ->\\\", [i for i in b.wheretrue()]\\n self.assertTrue(wt == cwt, \\\"wheretrue() does not work correctly\\\")\",\n \"def is_east(longitudes):\\n return np.asarray(longitudes, dtype=\\\"d\\\") <= 0.\",\n \"def test01(self):\\n a = np.arange(1, 11) < 0\\n b = bcolz.carray(a)\\n wt = a.nonzero()[0].tolist()\\n cwt = [i for i in b.wheretrue()]\\n # print \\\"numpy ->\\\", a.nonzero()[0].tolist()\\n # print \\\"where ->\\\", [i for i in b.wheretrue()]\\n self.assertTrue(wt == cwt, \\\"wheretrue() does not work correctly\\\")\",\n \"def test_align_sanity(self):\\n # QWERTY resemblance matrix:\\n R = qwerty_distance()\\n diff, u, r = min_difference_align(\\\"polynomial\\\", \\\"exponential\\\", R)\\n # Warning: we may (read: 'will') use another matrix!\\n self.assertEqual(diff, 15)\\n # Warning: there may be other optimal matchings!\\n self.assertEqual(u, '--polyn-om-ial')\\n self.assertEqual(r, 'exp-o-ne-ntial')\",\n \"def vectorized(self):\\n return False\",\n \"def _in_bounds(self, x, y):\\r\\n return 0 <= x < 8 and 0 <= y < 8\",\n \"def check_intersection(t, s):\\n # Allow wiggle room nearby 0.\\n if not (np.allclose(t, 0) or 0 <= t):\\n return False\\n\\n # Allow wiggle room nearby 0.\\n if not (np.allclose(s, 0) or 0 <= s):\\n return False\\n\\n # Allow wiggle room nearby 1.\\n if not (np.allclose(s, 1) or s <= 1):\\n return False\\n\\n return True\",\n \"def hasSpaceAround(self,x,y):\\n global gamemap\\n c = 0\\n for x2 in xrange(-2,2):\\n for y2 in xrange(-2,2):\\n if self.near(x, y,x + x2,y + y2):\\n if not gamemap[x + x2][y + y2].type[0]:\\n c += 1\\n if c >= 8:\\n return False\\n else:\\n return True\",\n \"def is_rectal(self):\\n return bool(self.locations and set(self.locations) <= set(StandardTerminology.RECTAL_LOCATIONS)) \\\\\\n or bool(self.depth and 4 <= self.depth <= 16)\",\n \"def aligned(self):\\n return self.__aligned\",\n \"def isSafe(coords, row, col):\\n rows = []\\n cols = []\\n diag_r = []\\n diag_l = []\\n\\n for square in coords:\\n rows.append(square[0])\\n cols.append(square[1])\\n diag_r.append(square[0] + square[1])\\n diag_l.append(square[1] - square[0])\\n\\n if row in rows or col in cols:\\n return False\\n if row + col in diag_r or col - row in diag_l:\\n return False\\n\\n return True\",\n \"def checkConsistencyWithStrictUnits(self):\\n return _libsbml.SBMLDocument_checkConsistencyWithStrictUnits(self)\",\n \"def isscalar(x):\\n arrayed_x = asarray(x)\\n return asarray(x).ndim == 0 and arrayed_x.dtype != 'object'\",\n \"def is_aligned_2d(self, p_list1, p_list2, p_left_key, p_top_key, p_width_key, p_height_key):\\n # check if terms align vertically\\n IVA = self.is_align_1D(p_list1, p_list2, p_left_key, p_width_key)\\n # check if terms align horizonally\\n IHA = self.is_align_1D(p_list1, p_list2, p_top_key, p_height_key)\\n if IVA == True:\\n # if terms align vertically get direction and distance\\n return self.get_vertical_align_direction(p_list1, p_list2, p_top_key, p_height_key)\\n elif IHA == True:\\n # if terms align vertically get direction and distance\\n return self.get_horizontal_align_direction(p_list1, p_list2, p_left_key, p_width_key)\\n else: return None\",\n \"def verify_page_alignment(toc):\\n if len({len(toc_entry[2]) for toc_entry in toc}) != 1:\\n return False\\n return True\",\n \"def isComplete(self):\\n assert len(self._x) > 0\\n assert len(self._y) > 0\\n assert 2 == len(self._data_array.shape)\\n assert self.wkt is not None\\n assert self.wkt != ''\\n\\n return True\",\n \"def find(self) -> bool:\\n alignments = []\\n for sw_idx in range(len(self.sw)):\\n for nu_idx in range(len(self.nu)):\\n alignments.append(Alignment(self.nu, self.sw, nu_idx, sw_idx, self.orig_nu))\\n alignment = max(alignments, key=lambda align: align.score)\\n if alignment.score > 0:\\n self.alignment = alignment\\n return True\\n return False\",\n \"def is_compatible(*, structure, symmetry):\\n analyzer = mg.symmetry.analyzer.SpacegroupAnalyzer(structure)\\n valid_sym_ops = analyzer.get_symmetry_operations(cartesian=False)\\n for sym_op in valid_sym_ops:\\n if (\\n np.\\n allclose(sym_op.translation_vector, symmetry.translation_vector)\\n and np.allclose(sym_op.rotation_matrix, symmetry.rotation_matrix)\\n ):\\n return True\\n return False\",\n \"def is_west(longitudes):\\n return ~is_east(longitudes)\",\n \"def isWin(self):\\n\\n return self.tiles == self.winCdt\",\n \"def has_near_table(self):\\r\\n if (self.near_spherical_right is not None or self.near_cylinder_right is not None\\r\\n or self.near_axis_right is not None or self.near_av_right is not None or\\r\\n self.near_dnp_right is not None\\r\\n or self.near_spherical_left is not None or self.near_cylinder_left is not None\\r\\n or self.near_axis_left is not None or self.near_av_left is not None or\\r\\n self.near_dnp_left is not None):\\r\\n return True\\r\\n return False\",\n \"def _has_undercoordinated_carbon(self, tolerance: int = 10):\\n undercoordinated_carbon = False\\n\\n for site_index in self.c_indices:\\n cn = self.get_cn(site_index) # pylint:disable=invalid-name\\n if cn == 2:\\n # ToDo: Check if it is bound to metal, then it might be a carbide\\n neighbors = self.get_connected_sites(site_index)\\n angle = _maximum_angle(\\n self.structure.get_angle(\\n site_index, neighbors[0].index, neighbors[1].index\\n )\\n )\\n if np.abs(180 - angle) > tolerance:\\n undercoordinated_carbon = True\\n break\\n self._undercoordinated_carbon = undercoordinated_carbon\",\n \"def isstationary(self):\\n if np.all(np.abs(self.arroots) > 1.0):\\n return True\\n else:\\n return False\",\n \"def col_clashes(bs, c):\\n for i in range(c): # check at all columns to the left of c\\n if share_diagonal(i, bs[i], c, bs[c]):\\n return True\\n return False # no clashes - col c has a safe placement\",\n \"def square_check(self):\\n return len(self.matrix) == len(self.matrix[0])\",\n \"def test00(self):\\n a = np.arange(1, 11) > 0\\n b = bcolz.carray(a)\\n wt = a.nonzero()[0].tolist()\\n cwt = [i for i in b.wheretrue()]\\n # print \\\"numpy ->\\\", a.nonzero()[0].tolist()\\n # print \\\"where ->\\\", [i for i in b.wheretrue()]\\n self.assertTrue(wt == cwt, \\\"wheretrue() does not work correctly\\\")\",\n \"def col_clashes(bs, c):\\n for i in range(c): # Look at all columns to the left of c\\n if share_diagonal(i, bs[i], c, bs[c]):\\n return True\\n\\n return False # No clashes - col c has a safe placement\",\n \"def magic_check(magic_square, magic_value):\\n row_sum = np.sum(magic_square, axis=0)\\n col_sum = np.sum(magic_square, axis=1)\\n diag_sum = np.sum(np.diag(magic_square))\\n if : # part b\\n return True\\n else:\\n return False\",\n \"def is_square(self):\\n return self.shape[0] == self.shape[1]\",\n \"def is_square(self):\\n return self.shape[0] == self.shape[1]\",\n \"def valid(self, nt_header):\\n try:\\n return (self.OriginalFirstThunk != 0 and\\n self.OriginalFirstThunk < nt_header.OptionalHeader.SizeOfImage and\\n self.FirstThunk != 0 and\\n self.FirstThunk < nt_header.OptionalHeader.SizeOfImage and\\n self.Name < nt_header.OptionalHeader.SizeOfImage)\\n except obj.InvalidOffsetError:\\n return False\",\n \"def check_branch(self):\\n n_d, d_d, h_d, w_d, c_d = self.dst_shape\\n all_ele = d_d * self.c_1 * h_d * w_d * self.n_o * self.n_i * self.c_0\\n out_ele = n_d * d_d * h_d * w_d * c_d\\n dhw_d = d_d * h_d * w_d\\n c_align = self.c_1 * self.c_0\\n\\n if n_d % 16 == 0:\\n if c_d % self.c_0 == 0 and all_ele <= self.ub_ele:\\n return \\\"c_align_small\\\"\\n elif c_d % self.c_0 == 0\\\\\\n and 1 <= self.ub_ele // (dhw_d * c_align) < n_d:\\n return \\\"c_align_split_n\\\"\\n elif c_d % self.c_0 > 0 and self.dtype == \\\"float16\\\"\\\\\\n and out_ele * self.cp_align_len <= self.ub_ele:\\n return \\\"c_not_align_small_fp16\\\"\\n elif c_d % self.c_0 > 0 and self.dtype == \\\"float32\\\"\\\\\\n and 1 <= self.ub_ele // (dhw_d * c_d * 16) < n_d:\\n return \\\"c_not_align_split_n_fp32\\\"\\n else:\\n return \\\"not_support\\\"\\n else:\\n return \\\"not_support\\\"\",\n \"def _check_normalization(self):\\n lastDistance = None\\n distance = None\\n for idx in xrange(len(self) - 1):\\n distance = self[idx+1][0] - self[idx][0]\\n\\n # first run\\n if lastDistance is None:\\n lastDistance = distance\\n continue\\n\\n if lastDistance != distance:\\n return False\\n\\n lastDistance = distance\\n\\n return True\",\n \"def fl_is_inside_lalign(align):\\n _fl_is_inside_lalign = library.cfuncproto(\\n library.load_so_libforms(), \\\"fl_is_inside_lalign\\\", \\\\\\n cty.c_int, [cty.c_int],\\n \\\"\\\"\\\"int fl_is_inside_lalign(int align) \\\"\\\"\\\")\\n library.check_if_flinitialized()\\n i_align = library.convert_to_intc(align)\\n library.keep_elem_refs(align, i_align)\\n retval = _fl_is_inside_lalign(i_align)\\n return retval\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6622194","0.66116005","0.64189285","0.629337","0.6231566","0.62093145","0.61557496","0.61207116","0.5808725","0.57705253","0.5653776","0.5611747","0.5607932","0.5607731","0.55909234","0.5550369","0.5533875","0.55202824","0.54235834","0.5402072","0.5395196","0.53438574","0.53215444","0.52825546","0.5260663","0.5254046","0.5246952","0.5214177","0.52027345","0.51926696","0.51806194","0.51741964","0.51460105","0.5141296","0.5132301","0.5131775","0.5120899","0.51166236","0.51039386","0.5103581","0.5100499","0.50971675","0.5092295","0.5074824","0.5071467","0.50684285","0.50668687","0.50579035","0.5056734","0.5052667","0.50438136","0.50404054","0.50336105","0.50315934","0.5029034","0.5027198","0.5026814","0.5011504","0.49971706","0.4993014","0.49877405","0.4982965","0.496962","0.49672264","0.49656883","0.49654868","0.495176","0.49502543","0.49394825","0.49370873","0.4933693","0.49297684","0.4925508","0.49232382","0.49175316","0.49133575","0.49126145","0.49103242","0.490986","0.49066734","0.49029398","0.49021813","0.48935735","0.48905817","0.48891047","0.48837882","0.48812482","0.4880394","0.48795363","0.48764256","0.4874007","0.48728946","0.48721483","0.4870099","0.48614055","0.48614055","0.48589402","0.48514375","0.4849518","0.4845898"],"string":"[\n \"0.6622194\",\n \"0.66116005\",\n \"0.64189285\",\n \"0.629337\",\n \"0.6231566\",\n \"0.62093145\",\n \"0.61557496\",\n \"0.61207116\",\n \"0.5808725\",\n \"0.57705253\",\n \"0.5653776\",\n \"0.5611747\",\n \"0.5607932\",\n \"0.5607731\",\n \"0.55909234\",\n \"0.5550369\",\n \"0.5533875\",\n \"0.55202824\",\n \"0.54235834\",\n \"0.5402072\",\n \"0.5395196\",\n \"0.53438574\",\n \"0.53215444\",\n \"0.52825546\",\n \"0.5260663\",\n \"0.5254046\",\n \"0.5246952\",\n \"0.5214177\",\n \"0.52027345\",\n \"0.51926696\",\n \"0.51806194\",\n \"0.51741964\",\n \"0.51460105\",\n \"0.5141296\",\n \"0.5132301\",\n \"0.5131775\",\n \"0.5120899\",\n \"0.51166236\",\n \"0.51039386\",\n \"0.5103581\",\n \"0.5100499\",\n \"0.50971675\",\n \"0.5092295\",\n \"0.5074824\",\n \"0.5071467\",\n \"0.50684285\",\n \"0.50668687\",\n \"0.50579035\",\n \"0.5056734\",\n \"0.5052667\",\n \"0.50438136\",\n \"0.50404054\",\n \"0.50336105\",\n \"0.50315934\",\n \"0.5029034\",\n \"0.5027198\",\n \"0.5026814\",\n \"0.5011504\",\n \"0.49971706\",\n \"0.4993014\",\n \"0.49877405\",\n \"0.4982965\",\n \"0.496962\",\n \"0.49672264\",\n \"0.49656883\",\n \"0.49654868\",\n \"0.495176\",\n \"0.49502543\",\n \"0.49394825\",\n \"0.49370873\",\n \"0.4933693\",\n \"0.49297684\",\n \"0.4925508\",\n \"0.49232382\",\n \"0.49175316\",\n \"0.49133575\",\n \"0.49126145\",\n \"0.49103242\",\n \"0.490986\",\n \"0.49066734\",\n \"0.49029398\",\n \"0.49021813\",\n \"0.48935735\",\n \"0.48905817\",\n \"0.48891047\",\n \"0.48837882\",\n \"0.48812482\",\n \"0.4880394\",\n \"0.48795363\",\n \"0.48764256\",\n \"0.4874007\",\n \"0.48728946\",\n \"0.48721483\",\n \"0.4870099\",\n \"0.48614055\",\n \"0.48614055\",\n \"0.48589402\",\n \"0.48514375\",\n \"0.4849518\",\n \"0.4845898\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.74039537"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":24987,"cells":{"query":{"kind":"string","value":"Instantiate a new instance of this class using given data."},"document":{"kind":"string","value":"def _new_instance(cls, data_list, meta=None, common_axis=None):\n return cls(data_list, meta=meta, common_axis=common_axis)"},"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 from_data(cls, data):\n return object.__new__(cls)","def from_data(cls,data):\n\n new_object = cls() # Only this line needs to be updated\n new_object.data = data\n\n return new_object","def create(self, cls, data=None):\n return cls(self, initial_data=data)","def from_data(cls, data):\n self = object.__new__(cls)\n self.id = parse_id(data)\n self._set_icon(data)\n self.bot = parse_bot(data)\n self.description = parse_description(data)\n self.name = parse_name(data)\n return self","def from_data(cls, data):\n self = object.__new__(cls)\n self.required = parse_required(data)\n self.title = parse_title(data)\n self.type = parse_type(data)\n self.values = parse_values(data)\n return self","def load(cls, data):\n return cls(**data)","def create(cls, data=None):\n # allow create() calls with no input\n if not data:\n data = {}\n\n return cls(**data)","def __init__(self, data):\n self.data = data\n return","def _instantiate(clz, **data):\n\n new_obj = clz()\n setattr(new_obj, \"data\", data)\n for key, val in deepcopy(data).items():\n setattr(new_obj, key, val)\n return new_obj","def from_data(cls, data):\n # Validation\n if data.get(\"_Serializable_classname\") != cls.__name__:\n return None\n del data[\"_Serializable_classname\"]\n if data.get(\"_Serializable_version\") is not None:\n del data[\"_Serializable_version\"]\n\n this = cls(None)\n this.__dict__.update(data)\n return this","def __init__(self, data=None):\n self.data = data","def from_dict(cls, data):\n instance = cls()\n instance._set_data(data)\n return instance","def from_data(cls, data):\n guild_id = parse_id(data)\n \n self = object.__new__(cls)\n self.approximate_online_count = parse_approximate_online_count(data)\n self.approximate_user_count = parse_approximate_user_count(data)\n self.description = parse_description(data)\n self._set_discovery_splash(data)\n self.emojis = parse_emojis(data, {}, guild_id)\n self.features = parse_features(data)\n self._set_icon(data)\n self.id = guild_id\n self._set_invite_splash(data)\n self.stickers = parse_stickers(data, {})\n self.name = parse_name(data)\n return self","def __init__(self, data):\n self.data = data","def __init__(self, data):\n self.data = data","def __init__(self, data):\n self.data = data","def __init__(self, data):\n self.data = data","def from_data(cls, data):\n self = object.__new__(cls)\n self.joined_at = parse_joined_at(data)\n self._update_attributes(data)\n return self","def _new_instance(cls, data, wcs, errors=None, **kwargs):\n return cls(data, wcs, errors=errors, **kwargs)","def _instantiate(cls, **kwargs):\n return cls(**kwargs)","def create(self, data):\n raise NotImplementedError","def create(self, data, **kwargs):\n\n return self._post(self.class_url(), data, **kwargs)","def from_dict(cls, data):\r\n instance = cls()\r\n for key, value in data.items():\r\n instance.__dict__[key] = value\r\n return instance","def make_instance(self, data, **kwargs):\n instance = self.instance or self.get_instance(data)\n if instance is not None:\n for key, value in iteritems(data):\n setattr(instance, key, value)\n return instance\n kwargs, association_attrs = self._split_model_kwargs_association(data)\n instance = self.opts.model(**kwargs)\n for attr, value in iteritems(association_attrs):\n setattr(instance, attr, value)\n return instance","def __init__(self,data):\n\n self.data = data","def from_dict(cls, data):\n return cls(**data)","def __init__(self, game, user, *, data=None, **kwargs):\r\n self.game = game\r\n self.user = user\r\n \r\n if data:\r\n self.from_data(data)\r\n else:\r\n self.initialize(**kwargs)","def __new__(cls, player, data):\n track = player.get_current()\n \n self = object.__new__(cls)\n self.player = player\n self.track = track\n return self","def __init__(self, data):\n self.data = data\n self.columns = Columns(data)\n self.rows = Rows(data)","def __init__(self, dat):\n self.data = dat","def __init__(self, data=None): # noqa: E501 # noqa: E501\n\n self._data = None\n self.discriminator = None\n\n if data is not None:\n self.data = data","def __init__(self, data, v1, v2):\n self.data = data\n self.v1 = v1\n self.v2 = v2","def __init__(self, data):\n self.jssp_instance_data = data","def __init__(self, data: dict):\n self.name = data['name'] # type: str\n self.type = data['type'] # type: str\n self.group = data['group'] # type: str\n self.pin = data['pin'] # type: int\n self.topic = (\n self.group + '/' +\n self.type + '/' +\n self.name) # type: str","def create_instance(data, logging_file_name):\n Utils.logging(data, logging_file_name)","def __new__(self, data = [], file = None):\n return super().__new__(self, data)","def from_dict(cls, data:{}):\n instance = cls(\n data['address'],\n None,\n data['frequency'],\n data['resolution'],\n data['servo_frequency']\n )\n if data['logging_level'] is not None:\n logger.setLevel(data['logging_level'])\n return instance","def new(cls, **kwargs):\n return cls(**kwargs)","def __init__(self, name: str, classifier_name: str, data: dict):\n super().__init__(data)\n self.data[\"name\"] = name\n self.data[\"classifier_name\"] = classifier_name\n self.data[\"date\"] = str(datetime.now())\n\n self.name = name\n self.classifier = classifier_name\n self.right = self.data.get(\"right\")\n self.wrong = self.data.get(\"wrong\")\n self.score = self.data.get(\"score\")\n self.date = self.data.get(\"date\")","def make_object(self, data, **kwargs):\n if not data:\n return None\n return Note(\n title=data['title'],\n content=data['content'],\n )","def __init__(self, data={}):\n self._update_(data)","def __init__(self, data, time_unit, metadata=None):\r\n # Check that sensible time units were given\r\n if time_unit not in time_unit_conversion:\r\n raise ValueError('Invalid time unit %s, must be one of %s' %\r\n (time_unit, time_unit_conversion.keys()))\r\n\r\n #: the data is an arbitrary numpy array\r\n self.data = np.asanyarray(data)\r\n self.time_unit = time_unit\r\n\r\n # Every instance carries an empty metadata dict, which we promise never\r\n # to touch. This reserves this name as a user area for extra\r\n # information without the danger of name clashes in the future.\r\n if metadata is None:\r\n self.metadata = {}\r\n else:\r\n self.metadata = metadata","def from_data(cls, data):\n errors = data.get('errors')\n if not errors or len(errors) == 0:\n return cls('Unknown error!')\n\n # For simplicity, we'll just include the first error.\n err = errors[0]\n return cls(\n message=err.get('message'),\n code=err.get('code'),\n detail=err.get('detail'),\n )","def from_data(cls, data: JSON):\n\n def build_thumbnail_url(url: str) -> str:\n return url.replace(\"{width}\", \"1600\").replace(\"{height}\", \"900\")\n\n return cls(\n id=int(data[\"id\"]),\n user_id=int(data[\"user_id\"]),\n thumbnail_url=build_thumbnail_url(data[\"thumbnail_url\"]),\n title=data[\"title\"],\n )","def __init__(self, data):\n self.__data = data\n self.__next = None","def __init__(self, data):\n self.json = data\n self.id = data.get(\"ID\", None)\n self.name = data.get(\"Name\", None)\n self.domain = data.get(\"Domain\", None)\n self.brand_id = data.get(\"BrandID\", None)\n self.account_id = data.get(\"AccountID\", None)\n self.brand_name = data.get(\"BrandName\", None)\n self.country_id = data.get(\"CountryID\", None)\n self.country_name = data.get(\"CountryName\", None)\n self.account_name = data.get(\"AccountName\", None)\n self.pre_order = data.get(\"PreOrder\", None)\n self.type_id = data.get(\"TypeID\", None)\n self.type_name = data.get(\"TypeName\", None)\n self.nominal_code_id = data.get(\"NominalCodeID\", None)\n self.external_shop_id = data.get(\"ExtShopID\", None)\n self.pseudo_stock_level_type = data.get(\"PseudoStockLevelType\", None)\n self.currency_symbol = data.get(\"CurrencySymbol\", None)\n self.loyalty_point_per_value = data.get(\"LoyaltyPointPerValue\", None)\n self.loyalty_value_per_point = data.get(\"LoyaltyValuePerPoint\", None)\n self.disabled = data.get(\"disabled\", None)\n self.deleted = data.get(\"deleted\", None)\n self.note = data.get(\"Note\", None)","def __init__(self, data):\n # loop through data\n for x in data:\n # set information as correct data type\n try:\n setattr(self, x, int(data[x]))\n except ValueError:\n try:\n setattr(self, x, float(data[x]))\n except ValueError:\n # string if not number\n setattr(self, x, str(data[x]))\n # calculate the winning team\n if self.home_team_runs > self.away_team_runs:\n self.w_team = self.home_team\n self.l_team = self.away_team\n elif self.away_team_runs > self.home_team_runs:\n self.w_team = self.away_team\n self.l_team = self.home_team\n # create a datetime object that represents the game start time\n # the object has no timezone info but should be interpreted as\n # being in the US/Eastern timezone\n year, month, day = self.game_id.split('_')[:3]\n game_start_date = \"/\".join([year, month, day])\n game_start_time = self.game_start_time.replace(' ', '')\n self.date = datetime.datetime.strptime(\n \" \".join([game_start_date, game_start_time]),\n \"%Y/%m/%d %I:%M%p\")","def __init__(self, data: dict = {}):\n pass","def fromObj(cls, data):\n pubkey = data[\"pubkey\"]\n privkey = data[\"privkey\"]\n\n return cls(pubkey, privkey)","def __init__(self):\n\n data_extract=DataExtracter()\n self.data = tuple()","def __init__(self, data):\n\t\tassert isinstance(data, str), \"Data location must be provided in type 'str'!\"\n\t\t\n\t\t# load the location provided\n\t\tdata = json.loads(open(data).read())\n\n\t\t# check for correct format\n\t\tassert isinstance(data, list), \"Data must be of type 'list'!\"\n\n\t\tfor element in data:\n\t\t\tassert isinstance(element, dict), \"Each element of data must be of type 'dict'!\"\n\n\t\tself.data = data","def from_data(cls, data):\n\n pp = cls(pt=Point.from_data(data['point']),\n layer_height=data['layer_height'],\n mesh_normal=Vector.from_data(data['mesh_normal']))\n\n pp.up_vector = Vector.from_data(data['up_vector'])\n pp.frame = Frame.from_data(data['frame'])\n\n pp.extruder_toggle = data['extruder_toggle']\n pp.velocity = data['velocity']\n pp.wait_time = data['wait_time']\n pp.blend_radius = data['blend_radius']\n\n pp.closest_support_pt = Point.from_data(data['closest_support_pt'])\n pp.distance_to_support = data['distance_to_support']\n\n pp.is_feasible = data['is_feasible']\n\n pp.attributes = data['attributes']\n return pp","def __init__(self, raw_data: Dict) -> None:\n self.raw_data = raw_data\n self.__extract_common_attrs(raw_data)\n\n # Fetch data with DATA_KEY or simply use the initial data.\n # In some cases the DATA_KEY is the same as the object attribute.\n # For example:\n # \"comments\": [{\n # \"comment_id\": 44444,\n # \"comment\": \"Hello, world!\"\n # }]\n # This object has a `comment` attribute but its DATA_KEY is also `comment`:\n # \"comment\": {\"comment_id\": 44444,\n # \"key_id\": 12345,\n # \"comment\": \"This is a test.\"}\n # This is an edge case happening only twice, so to overcome it\n # just check the value type under the given key.\n if self.DATA_KEY in raw_data and \\\n (isinstance(raw_data[self.DATA_KEY], dict)):\n data = raw_data[self.DATA_KEY]\n else:\n data = raw_data\n\n for attr in self.ATTRS:\n setattr(self, attr, data.get(attr, None))","def instantiate(cls, data_store, identifier):\n pass","def __init__(self, data, logger):\n self.data = data\n self.logger = logger","def __new__(cls, *args, **kwargs):\n if GraphData._instance is None:\n with GraphData._instance_lock:\n if GraphData._instance is None:\n GraphData._instance = object.__new__(cls)\n return GraphData._instance","def create(cls, _):\n return cls","def __init__(self, data, data_class, projection_dim=2):\n # data\n self.data = data\n self.data_class = data_class\n self.data_ninstances = data.shape[0]\n self.data_dim = data.shape[1]\n # projection\n self.projection = np.zeros((self.data_ninstances, projection_dim))\n self.projection_dim = projection_dim","def __init__(self, config: Dict[str, Any], data: Data, verbose: bool) -> None:\n self.__verbose = verbose\n self.__data = data\n self.__config = config","def __init__(self, data, node):\n self.data = data\n self.node = node","def __init__( self\n , _o_data\n ):\n self.o_data = _o_data","def __init__(self, data):\n self.bees = [Bee(b) for b in data[\"bees\"]]\n self.flowers = [Flower(f) for f in data[\"flowers\"]]\n self.hives = [Hive(h) for h in data[\"hives\"]]","def __init__(self, data, team_criteria):\n self.data = data\n self.athletes = dl.get_athletes(data)\n self.data_engine = dict()\n for squad in dl.get_squads(data):\n self.data_engine[squad[\"id\"]] = {\n \"team_criteria\": deepcopy(team_criteria),\n \"team_members\": list()}","def __init__(self, data):\n # loop through data\n for x in data:\n # create pitches list if attribute name is pitches\n if x == 'pitches':\n self.pitches = []\n for y in data[x]:\n self.pitches.append(Pitch(y))\n else:\n # set information as correct data type\n mlbgame.object.setobjattr(self, x, data[x])","def __init__(self, application, data):\n self.application = application\n self.data = data","def from_dict(cls, connection, data):\n\t\tif data.get('type') == \"gauge\":\n\t\t\tcls = Gauge\n\t\telif data.get('type') == \"counter\":\n\t\t\tcls = Counter\n\n\t\tobj = cls(connection, data['name'])\n\t\tobj.description = data['description']\n\t\tobj.period = data['period']\n\t\tobj.attributes = data['attributes']\n\t\tobj.description = data['description']\n\n\t\treturn obj","def __init__(self, data):\n\n self.data = data\n self.calculator = Calculator(descriptors, ignore_3D=True)\n self.described_molecules = self.featurize()","def from_data(cls: Type[SELF], data: Dict) -> SELF:\n self = cls.__new__(cls)\n\n self.type = PermissionTarget(data['type'])\n\n self.allow = Permissions(int(data['allow']))\n self.deny = Permissions(int(data['deny']))\n\n return self","def __init__(self, data):\n self.helper = Helper()\n self.CVE_DATA = {}\n self.DELETE_CVE_DATA = {}\n self.DELTA_FEED = {}\n self.utc_now = datetime.utcnow()\n self.today = self.utc_now.replace(hour=0, minute=0, second=0, microsecond=0)\n self.day = self.utc_now.weekday()\n\n # This is the offset days i.e how many days old data do we need to ingest.\n delta_feed_offset = int(os.environ.get('SNYK_DELTA_FEED_OFFSET', '1'))\n self.start_day = self.today - timedelta(days=delta_feed_offset)\n\n # If we want to selectively run the ingestion for an ecosystem.\n self.selective_eco_run = os.environ.get('SELECTIVE_ECOSYSTEM_SNYK_SYNC', '')\n if not data:\n self.snyk_data = self.helper.read_data_from_s3(self.utc_now.strftime('%d-%m-%Y'),\n \"snyk-feed/\")\n # For testing purpose we can use the sample feed\n \"\"\"with open('data/feed_sample.json', encoding='utf-8') as f:\n x = json.load(f)\n self.snyk_data = x\"\"\"\n else:\n self.snyk_data = data\n self.SNYK_REPORT = self._populate_default_report()","def from_dict(cls, data: Dict[str, any]):\n return cls(**data)","def __init__(self, data: bytes):\n super().__init__()\n self._expected_packet_type = MessageType.MAIN\n self._expected_data_size = 34\n self._data_raw = b''\n self._packet_type = MessageType.UNDEFINED\n self._packet_number = 0\n self.time_stamp_1MHz = 0\n self.accelerometer_x = 0\n self.accelerometer_y = 0\n self.accelerometer_z = 0\n self.magnetometer_x = 0\n self.magnetometer_y = 0\n self.magnetometer_z = 0\n self.gyroscope_x = 0\n self.gyroscope_y = 0\n self.gyroscope_z = 0\n self.quaternion_q0 = 0\n self.quaternion_q1 = 0\n self.quaternion_q2 = 0\n self.quaternion_q3 = 0\n self.flags = 0\n self.shield_and_kinetis_byte = 0\n self._is_valid = False\n self._parse_data(data)","def __init__(\n self,\n values: Mapping[str, ATTRIBUTE_TYPES],\n data_model: Optional[DataModel] = None,\n data_model_name: str = \"\",\n ):\n _values = deepcopy(values)\n self._values = _values\n if data_model is not None:\n self.data_model = data_model\n else:\n self.data_model = generate_data_model(data_model_name, values)\n self._check_consistency()","def __init__(self, data=None, *, task_history=None):\n self._data = data if data is not None else {}\n self._task_history = task_history if task_history is not None else []","def __init__(self, param, data):\n self.param = param\n self.data = data","def make_object(self, data, **kwargs):\n if data is None:\n raise ValidationError(\"No data was provided\")\n return Artist(**data)","def __init__(self, data):\n self._data = data\n self._parent = None\n self._rkid = None\n self._lkid = None","def __init__(self, make_response=None, code=200, data=''):\n if isinstance(data, tuple):\n self.data = data[0]\n headers = data[1]\n else:\n self.data = data\n headers = {}\n\n self.headers = headers\n self.code = code\n self.make_response = make_response","def __init__(self, data):\n self.data = data\n self.model_func = DecisionTree._deserialize_decision_tree_from_json(data[\"model\"])","def from_data(cls, data: JSON):\n\n return cls(\n id=int(data[\"id\"]),\n name=data[\"login\"],\n profile_image_url=data[\"profile_image_url\"],\n offline_image_url=data[\"offline_image_url\"],\n )","def from_data(cls, app, configuration):","def __init__(self, shape, data):\n self.shape = shape\n self.data = data","def from_dict(self, data):\n for field in ['_id', 'title', 'description', 'params']:\n if field in data:\n setattr(self, field, data[field])\n return self","def __new__(cls, player, data):\n try:\n reason_object = data[LAVALINK_KEY_EXCEPTION_REASON_OBJECT]\n except KeyError:\n reason = data[LAVALINK_KEY_EXCEPTION_REASON_DEPRECATED]\n severity = ''\n else:\n reason = reason_object[LAVALINK_KEY_EXCEPTION_REASON_OBJECT_MESSAGE]\n severity = reason_object[LAVALINK_KEY_EXCEPTION_REASON_OBJECT_SEVERITY]\n \n track = player.get_current()\n \n self = object.__new__(cls)\n self.player = player\n self.track = track\n self.reason = reason\n self.severity = severity\n return self","def __init__(self, data=None, code=0, msg='Success', status=None,\n template_name=None, headers=None,\n exception=False, content_type=None):\n super().__init__(None, status=status)\n\n if isinstance(data, Serializer):\n msg = (\n 'You passed a Serializer instance as data, but '\n 'probably meant to pass serialized `.data` or '\n '`.error`. representation.'\n )\n raise AssertionError(msg)\n\n self.data = {\"code\": code, \"msg\": msg, \"data\": data}\n self.template_name = template_name\n self.exception = exception\n self.content_type = content_type\n\n if headers:\n for name, value in headers.items():\n self[name] = value","def load(cls,data:{}, X=None):\n return cls._load(data=data, X=X)","def __init__(self, data):\n self.__authenticate(data)\n self.user_id = self.__parse_user_id(data)\n self.channel_id = self.__parse_channel_id(data)\n self.data = data\n if 'text' in data:\n self.text = data['text'].split(\", \")","def build(self, data: dict):","def get_instance_from_words(data):\n inst = Dataset.get_instance_template()\n inst[\"words\"] = data\n return inst","def __init__(self, data: list):\n self.__data = copy.deepcopy(data)","def __init__(self, data, node):\n self.data = data\n self.node = node # This is the data structure which holds the data for this node, e.g. lat, lon, etc.","def __init__(self, m, n, data):\n self.m = m\n self.n = n\n self.data = data","def _load(cls,data:{}, X=None):\n estimator = cls()\n estimator.load_data(data=data)\n estimator.load_X(X=X)\n return estimator","def __init__(self, data):\n self.data = data\n self.next = None","def __init__(self, data):\n self.data = data\n self.next = None","def __init__(self, data, labels, emotions):\n self.data = data\n self.labels = labels\n self.emotions = emotions","def __init__(self, data=None, codec=None):\n self.data = data\n self.codec = codec","def __init__(self, data, ts):\n self.data = data\n self.ts = ts","def __init__(self, msg_id=0, xtd=0, rtr=0, ndata=0, data=() ):\r\n self.msg_id = msg_id\r\n self.rtr = rtr\r\n self.xtd = xtd\r\n self.ndata = ndata\r\n self.data = data # tuple with length 0..8\r\n self.timestamp = time.time() # Timestamp of object creation\r","def __init__(self, id, data={}):\n\t\tself.__id = id\n\t\tself.__dStore = data","def create(self, validated_data):\n # Create data\n instance = Data(\n template=validated_data['template'],\n title=validated_data['title'],\n user_id=str(validated_data['user'].id),\n )\n # Set xml content\n instance.xml_content = validated_data['xml_content']\n # Save the data\n data_api.upsert(instance, validated_data['user'])\n # Encode the response body\n instance.xml_content = validated_data['xml_content'].encode('utf-8')\n\n return instance"],"string":"[\n \"def from_data(cls, data):\\n return object.__new__(cls)\",\n \"def from_data(cls,data):\\n\\n new_object = cls() # Only this line needs to be updated\\n new_object.data = data\\n\\n return new_object\",\n \"def create(self, cls, data=None):\\n return cls(self, initial_data=data)\",\n \"def from_data(cls, data):\\n self = object.__new__(cls)\\n self.id = parse_id(data)\\n self._set_icon(data)\\n self.bot = parse_bot(data)\\n self.description = parse_description(data)\\n self.name = parse_name(data)\\n return self\",\n \"def from_data(cls, data):\\n self = object.__new__(cls)\\n self.required = parse_required(data)\\n self.title = parse_title(data)\\n self.type = parse_type(data)\\n self.values = parse_values(data)\\n return self\",\n \"def load(cls, data):\\n return cls(**data)\",\n \"def create(cls, data=None):\\n # allow create() calls with no input\\n if not data:\\n data = {}\\n\\n return cls(**data)\",\n \"def __init__(self, data):\\n self.data = data\\n return\",\n \"def _instantiate(clz, **data):\\n\\n new_obj = clz()\\n setattr(new_obj, \\\"data\\\", data)\\n for key, val in deepcopy(data).items():\\n setattr(new_obj, key, val)\\n return new_obj\",\n \"def from_data(cls, data):\\n # Validation\\n if data.get(\\\"_Serializable_classname\\\") != cls.__name__:\\n return None\\n del data[\\\"_Serializable_classname\\\"]\\n if data.get(\\\"_Serializable_version\\\") is not None:\\n del data[\\\"_Serializable_version\\\"]\\n\\n this = cls(None)\\n this.__dict__.update(data)\\n return this\",\n \"def __init__(self, data=None):\\n self.data = data\",\n \"def from_dict(cls, data):\\n instance = cls()\\n instance._set_data(data)\\n return instance\",\n \"def from_data(cls, data):\\n guild_id = parse_id(data)\\n \\n self = object.__new__(cls)\\n self.approximate_online_count = parse_approximate_online_count(data)\\n self.approximate_user_count = parse_approximate_user_count(data)\\n self.description = parse_description(data)\\n self._set_discovery_splash(data)\\n self.emojis = parse_emojis(data, {}, guild_id)\\n self.features = parse_features(data)\\n self._set_icon(data)\\n self.id = guild_id\\n self._set_invite_splash(data)\\n self.stickers = parse_stickers(data, {})\\n self.name = parse_name(data)\\n return self\",\n \"def __init__(self, data):\\n self.data = data\",\n \"def __init__(self, data):\\n self.data = data\",\n \"def __init__(self, data):\\n self.data = data\",\n \"def __init__(self, data):\\n self.data = data\",\n \"def from_data(cls, data):\\n self = object.__new__(cls)\\n self.joined_at = parse_joined_at(data)\\n self._update_attributes(data)\\n return self\",\n \"def _new_instance(cls, data, wcs, errors=None, **kwargs):\\n return cls(data, wcs, errors=errors, **kwargs)\",\n \"def _instantiate(cls, **kwargs):\\n return cls(**kwargs)\",\n \"def create(self, data):\\n raise NotImplementedError\",\n \"def create(self, data, **kwargs):\\n\\n return self._post(self.class_url(), data, **kwargs)\",\n \"def from_dict(cls, data):\\r\\n instance = cls()\\r\\n for key, value in data.items():\\r\\n instance.__dict__[key] = value\\r\\n return instance\",\n \"def make_instance(self, data, **kwargs):\\n instance = self.instance or self.get_instance(data)\\n if instance is not None:\\n for key, value in iteritems(data):\\n setattr(instance, key, value)\\n return instance\\n kwargs, association_attrs = self._split_model_kwargs_association(data)\\n instance = self.opts.model(**kwargs)\\n for attr, value in iteritems(association_attrs):\\n setattr(instance, attr, value)\\n return instance\",\n \"def __init__(self,data):\\n\\n self.data = data\",\n \"def from_dict(cls, data):\\n return cls(**data)\",\n \"def __init__(self, game, user, *, data=None, **kwargs):\\r\\n self.game = game\\r\\n self.user = user\\r\\n \\r\\n if data:\\r\\n self.from_data(data)\\r\\n else:\\r\\n self.initialize(**kwargs)\",\n \"def __new__(cls, player, data):\\n track = player.get_current()\\n \\n self = object.__new__(cls)\\n self.player = player\\n self.track = track\\n return self\",\n \"def __init__(self, data):\\n self.data = data\\n self.columns = Columns(data)\\n self.rows = Rows(data)\",\n \"def __init__(self, dat):\\n self.data = dat\",\n \"def __init__(self, data=None): # noqa: E501 # noqa: E501\\n\\n self._data = None\\n self.discriminator = None\\n\\n if data is not None:\\n self.data = data\",\n \"def __init__(self, data, v1, v2):\\n self.data = data\\n self.v1 = v1\\n self.v2 = v2\",\n \"def __init__(self, data):\\n self.jssp_instance_data = data\",\n \"def __init__(self, data: dict):\\n self.name = data['name'] # type: str\\n self.type = data['type'] # type: str\\n self.group = data['group'] # type: str\\n self.pin = data['pin'] # type: int\\n self.topic = (\\n self.group + '/' +\\n self.type + '/' +\\n self.name) # type: str\",\n \"def create_instance(data, logging_file_name):\\n Utils.logging(data, logging_file_name)\",\n \"def __new__(self, data = [], file = None):\\n return super().__new__(self, data)\",\n \"def from_dict(cls, data:{}):\\n instance = cls(\\n data['address'],\\n None,\\n data['frequency'],\\n data['resolution'],\\n data['servo_frequency']\\n )\\n if data['logging_level'] is not None:\\n logger.setLevel(data['logging_level'])\\n return instance\",\n \"def new(cls, **kwargs):\\n return cls(**kwargs)\",\n \"def __init__(self, name: str, classifier_name: str, data: dict):\\n super().__init__(data)\\n self.data[\\\"name\\\"] = name\\n self.data[\\\"classifier_name\\\"] = classifier_name\\n self.data[\\\"date\\\"] = str(datetime.now())\\n\\n self.name = name\\n self.classifier = classifier_name\\n self.right = self.data.get(\\\"right\\\")\\n self.wrong = self.data.get(\\\"wrong\\\")\\n self.score = self.data.get(\\\"score\\\")\\n self.date = self.data.get(\\\"date\\\")\",\n \"def make_object(self, data, **kwargs):\\n if not data:\\n return None\\n return Note(\\n title=data['title'],\\n content=data['content'],\\n )\",\n \"def __init__(self, data={}):\\n self._update_(data)\",\n \"def __init__(self, data, time_unit, metadata=None):\\r\\n # Check that sensible time units were given\\r\\n if time_unit not in time_unit_conversion:\\r\\n raise ValueError('Invalid time unit %s, must be one of %s' %\\r\\n (time_unit, time_unit_conversion.keys()))\\r\\n\\r\\n #: the data is an arbitrary numpy array\\r\\n self.data = np.asanyarray(data)\\r\\n self.time_unit = time_unit\\r\\n\\r\\n # Every instance carries an empty metadata dict, which we promise never\\r\\n # to touch. This reserves this name as a user area for extra\\r\\n # information without the danger of name clashes in the future.\\r\\n if metadata is None:\\r\\n self.metadata = {}\\r\\n else:\\r\\n self.metadata = metadata\",\n \"def from_data(cls, data):\\n errors = data.get('errors')\\n if not errors or len(errors) == 0:\\n return cls('Unknown error!')\\n\\n # For simplicity, we'll just include the first error.\\n err = errors[0]\\n return cls(\\n message=err.get('message'),\\n code=err.get('code'),\\n detail=err.get('detail'),\\n )\",\n \"def from_data(cls, data: JSON):\\n\\n def build_thumbnail_url(url: str) -> str:\\n return url.replace(\\\"{width}\\\", \\\"1600\\\").replace(\\\"{height}\\\", \\\"900\\\")\\n\\n return cls(\\n id=int(data[\\\"id\\\"]),\\n user_id=int(data[\\\"user_id\\\"]),\\n thumbnail_url=build_thumbnail_url(data[\\\"thumbnail_url\\\"]),\\n title=data[\\\"title\\\"],\\n )\",\n \"def __init__(self, data):\\n self.__data = data\\n self.__next = None\",\n \"def __init__(self, data):\\n self.json = data\\n self.id = data.get(\\\"ID\\\", None)\\n self.name = data.get(\\\"Name\\\", None)\\n self.domain = data.get(\\\"Domain\\\", None)\\n self.brand_id = data.get(\\\"BrandID\\\", None)\\n self.account_id = data.get(\\\"AccountID\\\", None)\\n self.brand_name = data.get(\\\"BrandName\\\", None)\\n self.country_id = data.get(\\\"CountryID\\\", None)\\n self.country_name = data.get(\\\"CountryName\\\", None)\\n self.account_name = data.get(\\\"AccountName\\\", None)\\n self.pre_order = data.get(\\\"PreOrder\\\", None)\\n self.type_id = data.get(\\\"TypeID\\\", None)\\n self.type_name = data.get(\\\"TypeName\\\", None)\\n self.nominal_code_id = data.get(\\\"NominalCodeID\\\", None)\\n self.external_shop_id = data.get(\\\"ExtShopID\\\", None)\\n self.pseudo_stock_level_type = data.get(\\\"PseudoStockLevelType\\\", None)\\n self.currency_symbol = data.get(\\\"CurrencySymbol\\\", None)\\n self.loyalty_point_per_value = data.get(\\\"LoyaltyPointPerValue\\\", None)\\n self.loyalty_value_per_point = data.get(\\\"LoyaltyValuePerPoint\\\", None)\\n self.disabled = data.get(\\\"disabled\\\", None)\\n self.deleted = data.get(\\\"deleted\\\", None)\\n self.note = data.get(\\\"Note\\\", None)\",\n \"def __init__(self, data):\\n # loop through data\\n for x in data:\\n # set information as correct data type\\n try:\\n setattr(self, x, int(data[x]))\\n except ValueError:\\n try:\\n setattr(self, x, float(data[x]))\\n except ValueError:\\n # string if not number\\n setattr(self, x, str(data[x]))\\n # calculate the winning team\\n if self.home_team_runs > self.away_team_runs:\\n self.w_team = self.home_team\\n self.l_team = self.away_team\\n elif self.away_team_runs > self.home_team_runs:\\n self.w_team = self.away_team\\n self.l_team = self.home_team\\n # create a datetime object that represents the game start time\\n # the object has no timezone info but should be interpreted as\\n # being in the US/Eastern timezone\\n year, month, day = self.game_id.split('_')[:3]\\n game_start_date = \\\"/\\\".join([year, month, day])\\n game_start_time = self.game_start_time.replace(' ', '')\\n self.date = datetime.datetime.strptime(\\n \\\" \\\".join([game_start_date, game_start_time]),\\n \\\"%Y/%m/%d %I:%M%p\\\")\",\n \"def __init__(self, data: dict = {}):\\n pass\",\n \"def fromObj(cls, data):\\n pubkey = data[\\\"pubkey\\\"]\\n privkey = data[\\\"privkey\\\"]\\n\\n return cls(pubkey, privkey)\",\n \"def __init__(self):\\n\\n data_extract=DataExtracter()\\n self.data = tuple()\",\n \"def __init__(self, data):\\n\\t\\tassert isinstance(data, str), \\\"Data location must be provided in type 'str'!\\\"\\n\\t\\t\\n\\t\\t# load the location provided\\n\\t\\tdata = json.loads(open(data).read())\\n\\n\\t\\t# check for correct format\\n\\t\\tassert isinstance(data, list), \\\"Data must be of type 'list'!\\\"\\n\\n\\t\\tfor element in data:\\n\\t\\t\\tassert isinstance(element, dict), \\\"Each element of data must be of type 'dict'!\\\"\\n\\n\\t\\tself.data = data\",\n \"def from_data(cls, data):\\n\\n pp = cls(pt=Point.from_data(data['point']),\\n layer_height=data['layer_height'],\\n mesh_normal=Vector.from_data(data['mesh_normal']))\\n\\n pp.up_vector = Vector.from_data(data['up_vector'])\\n pp.frame = Frame.from_data(data['frame'])\\n\\n pp.extruder_toggle = data['extruder_toggle']\\n pp.velocity = data['velocity']\\n pp.wait_time = data['wait_time']\\n pp.blend_radius = data['blend_radius']\\n\\n pp.closest_support_pt = Point.from_data(data['closest_support_pt'])\\n pp.distance_to_support = data['distance_to_support']\\n\\n pp.is_feasible = data['is_feasible']\\n\\n pp.attributes = data['attributes']\\n return pp\",\n \"def __init__(self, raw_data: Dict) -> None:\\n self.raw_data = raw_data\\n self.__extract_common_attrs(raw_data)\\n\\n # Fetch data with DATA_KEY or simply use the initial data.\\n # In some cases the DATA_KEY is the same as the object attribute.\\n # For example:\\n # \\\"comments\\\": [{\\n # \\\"comment_id\\\": 44444,\\n # \\\"comment\\\": \\\"Hello, world!\\\"\\n # }]\\n # This object has a `comment` attribute but its DATA_KEY is also `comment`:\\n # \\\"comment\\\": {\\\"comment_id\\\": 44444,\\n # \\\"key_id\\\": 12345,\\n # \\\"comment\\\": \\\"This is a test.\\\"}\\n # This is an edge case happening only twice, so to overcome it\\n # just check the value type under the given key.\\n if self.DATA_KEY in raw_data and \\\\\\n (isinstance(raw_data[self.DATA_KEY], dict)):\\n data = raw_data[self.DATA_KEY]\\n else:\\n data = raw_data\\n\\n for attr in self.ATTRS:\\n setattr(self, attr, data.get(attr, None))\",\n \"def instantiate(cls, data_store, identifier):\\n pass\",\n \"def __init__(self, data, logger):\\n self.data = data\\n self.logger = logger\",\n \"def __new__(cls, *args, **kwargs):\\n if GraphData._instance is None:\\n with GraphData._instance_lock:\\n if GraphData._instance is None:\\n GraphData._instance = object.__new__(cls)\\n return GraphData._instance\",\n \"def create(cls, _):\\n return cls\",\n \"def __init__(self, data, data_class, projection_dim=2):\\n # data\\n self.data = data\\n self.data_class = data_class\\n self.data_ninstances = data.shape[0]\\n self.data_dim = data.shape[1]\\n # projection\\n self.projection = np.zeros((self.data_ninstances, projection_dim))\\n self.projection_dim = projection_dim\",\n \"def __init__(self, config: Dict[str, Any], data: Data, verbose: bool) -> None:\\n self.__verbose = verbose\\n self.__data = data\\n self.__config = config\",\n \"def __init__(self, data, node):\\n self.data = data\\n self.node = node\",\n \"def __init__( self\\n , _o_data\\n ):\\n self.o_data = _o_data\",\n \"def __init__(self, data):\\n self.bees = [Bee(b) for b in data[\\\"bees\\\"]]\\n self.flowers = [Flower(f) for f in data[\\\"flowers\\\"]]\\n self.hives = [Hive(h) for h in data[\\\"hives\\\"]]\",\n \"def __init__(self, data, team_criteria):\\n self.data = data\\n self.athletes = dl.get_athletes(data)\\n self.data_engine = dict()\\n for squad in dl.get_squads(data):\\n self.data_engine[squad[\\\"id\\\"]] = {\\n \\\"team_criteria\\\": deepcopy(team_criteria),\\n \\\"team_members\\\": list()}\",\n \"def __init__(self, data):\\n # loop through data\\n for x in data:\\n # create pitches list if attribute name is pitches\\n if x == 'pitches':\\n self.pitches = []\\n for y in data[x]:\\n self.pitches.append(Pitch(y))\\n else:\\n # set information as correct data type\\n mlbgame.object.setobjattr(self, x, data[x])\",\n \"def __init__(self, application, data):\\n self.application = application\\n self.data = data\",\n \"def from_dict(cls, connection, data):\\n\\t\\tif data.get('type') == \\\"gauge\\\":\\n\\t\\t\\tcls = Gauge\\n\\t\\telif data.get('type') == \\\"counter\\\":\\n\\t\\t\\tcls = Counter\\n\\n\\t\\tobj = cls(connection, data['name'])\\n\\t\\tobj.description = data['description']\\n\\t\\tobj.period = data['period']\\n\\t\\tobj.attributes = data['attributes']\\n\\t\\tobj.description = data['description']\\n\\n\\t\\treturn obj\",\n \"def __init__(self, data):\\n\\n self.data = data\\n self.calculator = Calculator(descriptors, ignore_3D=True)\\n self.described_molecules = self.featurize()\",\n \"def from_data(cls: Type[SELF], data: Dict) -> SELF:\\n self = cls.__new__(cls)\\n\\n self.type = PermissionTarget(data['type'])\\n\\n self.allow = Permissions(int(data['allow']))\\n self.deny = Permissions(int(data['deny']))\\n\\n return self\",\n \"def __init__(self, data):\\n self.helper = Helper()\\n self.CVE_DATA = {}\\n self.DELETE_CVE_DATA = {}\\n self.DELTA_FEED = {}\\n self.utc_now = datetime.utcnow()\\n self.today = self.utc_now.replace(hour=0, minute=0, second=0, microsecond=0)\\n self.day = self.utc_now.weekday()\\n\\n # This is the offset days i.e how many days old data do we need to ingest.\\n delta_feed_offset = int(os.environ.get('SNYK_DELTA_FEED_OFFSET', '1'))\\n self.start_day = self.today - timedelta(days=delta_feed_offset)\\n\\n # If we want to selectively run the ingestion for an ecosystem.\\n self.selective_eco_run = os.environ.get('SELECTIVE_ECOSYSTEM_SNYK_SYNC', '')\\n if not data:\\n self.snyk_data = self.helper.read_data_from_s3(self.utc_now.strftime('%d-%m-%Y'),\\n \\\"snyk-feed/\\\")\\n # For testing purpose we can use the sample feed\\n \\\"\\\"\\\"with open('data/feed_sample.json', encoding='utf-8') as f:\\n x = json.load(f)\\n self.snyk_data = x\\\"\\\"\\\"\\n else:\\n self.snyk_data = data\\n self.SNYK_REPORT = self._populate_default_report()\",\n \"def from_dict(cls, data: Dict[str, any]):\\n return cls(**data)\",\n \"def __init__(self, data: bytes):\\n super().__init__()\\n self._expected_packet_type = MessageType.MAIN\\n self._expected_data_size = 34\\n self._data_raw = b''\\n self._packet_type = MessageType.UNDEFINED\\n self._packet_number = 0\\n self.time_stamp_1MHz = 0\\n self.accelerometer_x = 0\\n self.accelerometer_y = 0\\n self.accelerometer_z = 0\\n self.magnetometer_x = 0\\n self.magnetometer_y = 0\\n self.magnetometer_z = 0\\n self.gyroscope_x = 0\\n self.gyroscope_y = 0\\n self.gyroscope_z = 0\\n self.quaternion_q0 = 0\\n self.quaternion_q1 = 0\\n self.quaternion_q2 = 0\\n self.quaternion_q3 = 0\\n self.flags = 0\\n self.shield_and_kinetis_byte = 0\\n self._is_valid = False\\n self._parse_data(data)\",\n \"def __init__(\\n self,\\n values: Mapping[str, ATTRIBUTE_TYPES],\\n data_model: Optional[DataModel] = None,\\n data_model_name: str = \\\"\\\",\\n ):\\n _values = deepcopy(values)\\n self._values = _values\\n if data_model is not None:\\n self.data_model = data_model\\n else:\\n self.data_model = generate_data_model(data_model_name, values)\\n self._check_consistency()\",\n \"def __init__(self, data=None, *, task_history=None):\\n self._data = data if data is not None else {}\\n self._task_history = task_history if task_history is not None else []\",\n \"def __init__(self, param, data):\\n self.param = param\\n self.data = data\",\n \"def make_object(self, data, **kwargs):\\n if data is None:\\n raise ValidationError(\\\"No data was provided\\\")\\n return Artist(**data)\",\n \"def __init__(self, data):\\n self._data = data\\n self._parent = None\\n self._rkid = None\\n self._lkid = None\",\n \"def __init__(self, make_response=None, code=200, data=''):\\n if isinstance(data, tuple):\\n self.data = data[0]\\n headers = data[1]\\n else:\\n self.data = data\\n headers = {}\\n\\n self.headers = headers\\n self.code = code\\n self.make_response = make_response\",\n \"def __init__(self, data):\\n self.data = data\\n self.model_func = DecisionTree._deserialize_decision_tree_from_json(data[\\\"model\\\"])\",\n \"def from_data(cls, data: JSON):\\n\\n return cls(\\n id=int(data[\\\"id\\\"]),\\n name=data[\\\"login\\\"],\\n profile_image_url=data[\\\"profile_image_url\\\"],\\n offline_image_url=data[\\\"offline_image_url\\\"],\\n )\",\n \"def from_data(cls, app, configuration):\",\n \"def __init__(self, shape, data):\\n self.shape = shape\\n self.data = data\",\n \"def from_dict(self, data):\\n for field in ['_id', 'title', 'description', 'params']:\\n if field in data:\\n setattr(self, field, data[field])\\n return self\",\n \"def __new__(cls, player, data):\\n try:\\n reason_object = data[LAVALINK_KEY_EXCEPTION_REASON_OBJECT]\\n except KeyError:\\n reason = data[LAVALINK_KEY_EXCEPTION_REASON_DEPRECATED]\\n severity = ''\\n else:\\n reason = reason_object[LAVALINK_KEY_EXCEPTION_REASON_OBJECT_MESSAGE]\\n severity = reason_object[LAVALINK_KEY_EXCEPTION_REASON_OBJECT_SEVERITY]\\n \\n track = player.get_current()\\n \\n self = object.__new__(cls)\\n self.player = player\\n self.track = track\\n self.reason = reason\\n self.severity = severity\\n return self\",\n \"def __init__(self, data=None, code=0, msg='Success', status=None,\\n template_name=None, headers=None,\\n exception=False, content_type=None):\\n super().__init__(None, status=status)\\n\\n if isinstance(data, Serializer):\\n msg = (\\n 'You passed a Serializer instance as data, but '\\n 'probably meant to pass serialized `.data` or '\\n '`.error`. representation.'\\n )\\n raise AssertionError(msg)\\n\\n self.data = {\\\"code\\\": code, \\\"msg\\\": msg, \\\"data\\\": data}\\n self.template_name = template_name\\n self.exception = exception\\n self.content_type = content_type\\n\\n if headers:\\n for name, value in headers.items():\\n self[name] = value\",\n \"def load(cls,data:{}, X=None):\\n return cls._load(data=data, X=X)\",\n \"def __init__(self, data):\\n self.__authenticate(data)\\n self.user_id = self.__parse_user_id(data)\\n self.channel_id = self.__parse_channel_id(data)\\n self.data = data\\n if 'text' in data:\\n self.text = data['text'].split(\\\", \\\")\",\n \"def build(self, data: dict):\",\n \"def get_instance_from_words(data):\\n inst = Dataset.get_instance_template()\\n inst[\\\"words\\\"] = data\\n return inst\",\n \"def __init__(self, data: list):\\n self.__data = copy.deepcopy(data)\",\n \"def __init__(self, data, node):\\n self.data = data\\n self.node = node # This is the data structure which holds the data for this node, e.g. lat, lon, etc.\",\n \"def __init__(self, m, n, data):\\n self.m = m\\n self.n = n\\n self.data = data\",\n \"def _load(cls,data:{}, X=None):\\n estimator = cls()\\n estimator.load_data(data=data)\\n estimator.load_X(X=X)\\n return estimator\",\n \"def __init__(self, data):\\n self.data = data\\n self.next = None\",\n \"def __init__(self, data):\\n self.data = data\\n self.next = None\",\n \"def __init__(self, data, labels, emotions):\\n self.data = data\\n self.labels = labels\\n self.emotions = emotions\",\n \"def __init__(self, data=None, codec=None):\\n self.data = data\\n self.codec = codec\",\n \"def __init__(self, data, ts):\\n self.data = data\\n self.ts = ts\",\n \"def __init__(self, msg_id=0, xtd=0, rtr=0, ndata=0, data=() ):\\r\\n self.msg_id = msg_id\\r\\n self.rtr = rtr\\r\\n self.xtd = xtd\\r\\n self.ndata = ndata\\r\\n self.data = data # tuple with length 0..8\\r\\n self.timestamp = time.time() # Timestamp of object creation\\r\",\n \"def __init__(self, id, data={}):\\n\\t\\tself.__id = id\\n\\t\\tself.__dStore = data\",\n \"def create(self, validated_data):\\n # Create data\\n instance = Data(\\n template=validated_data['template'],\\n title=validated_data['title'],\\n user_id=str(validated_data['user'].id),\\n )\\n # Set xml content\\n instance.xml_content = validated_data['xml_content']\\n # Save the data\\n data_api.upsert(instance, validated_data['user'])\\n # Encode the response body\\n instance.xml_content = validated_data['xml_content'].encode('utf-8')\\n\\n return instance\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.8487179","0.8234369","0.8037686","0.80359334","0.78548235","0.7683154","0.7678993","0.7598695","0.7346941","0.73307866","0.7325395","0.7300296","0.725587","0.72462845","0.72462845","0.72462845","0.72462845","0.72362065","0.7133408","0.71174616","0.7112208","0.7046518","0.70357305","0.70237225","0.7012211","0.69381416","0.6852998","0.6821026","0.68063056","0.67651194","0.67454565","0.6714917","0.67131466","0.6711169","0.6710327","0.6653399","0.66523147","0.6623473","0.6609805","0.66052544","0.6593192","0.65793544","0.65778285","0.6558175","0.65561116","0.6540704","0.6539555","0.65319306","0.6514934","0.6495672","0.64766496","0.6473729","0.64610595","0.6447604","0.6439366","0.6437593","0.643382","0.6431024","0.64280415","0.64083785","0.64035064","0.6383641","0.6379776","0.6375064","0.6359724","0.6355283","0.63546526","0.63513815","0.6349352","0.6316566","0.63088495","0.6308058","0.63077253","0.63044256","0.62939066","0.62894505","0.6278958","0.626489","0.62630856","0.6260835","0.62566763","0.62478083","0.62360054","0.6228049","0.62173265","0.6209698","0.6207494","0.6199827","0.6199448","0.6197533","0.6196712","0.61917156","0.6186357","0.6186357","0.61806005","0.61745524","0.6157753","0.61573446","0.61565584","0.614573"],"string":"[\n \"0.8487179\",\n \"0.8234369\",\n \"0.8037686\",\n \"0.80359334\",\n \"0.78548235\",\n \"0.7683154\",\n \"0.7678993\",\n \"0.7598695\",\n \"0.7346941\",\n \"0.73307866\",\n \"0.7325395\",\n \"0.7300296\",\n \"0.725587\",\n \"0.72462845\",\n \"0.72462845\",\n \"0.72462845\",\n \"0.72462845\",\n \"0.72362065\",\n \"0.7133408\",\n \"0.71174616\",\n \"0.7112208\",\n \"0.7046518\",\n \"0.70357305\",\n \"0.70237225\",\n \"0.7012211\",\n \"0.69381416\",\n \"0.6852998\",\n \"0.6821026\",\n \"0.68063056\",\n \"0.67651194\",\n \"0.67454565\",\n \"0.6714917\",\n \"0.67131466\",\n \"0.6711169\",\n \"0.6710327\",\n \"0.6653399\",\n \"0.66523147\",\n \"0.6623473\",\n \"0.6609805\",\n \"0.66052544\",\n \"0.6593192\",\n \"0.65793544\",\n \"0.65778285\",\n \"0.6558175\",\n \"0.65561116\",\n \"0.6540704\",\n \"0.6539555\",\n \"0.65319306\",\n \"0.6514934\",\n \"0.6495672\",\n \"0.64766496\",\n \"0.6473729\",\n \"0.64610595\",\n \"0.6447604\",\n \"0.6439366\",\n \"0.6437593\",\n \"0.643382\",\n \"0.6431024\",\n \"0.64280415\",\n \"0.64083785\",\n \"0.64035064\",\n \"0.6383641\",\n \"0.6379776\",\n \"0.6375064\",\n \"0.6359724\",\n \"0.6355283\",\n \"0.63546526\",\n \"0.63513815\",\n \"0.6349352\",\n \"0.6316566\",\n \"0.63088495\",\n \"0.6308058\",\n \"0.63077253\",\n \"0.63044256\",\n \"0.62939066\",\n \"0.62894505\",\n \"0.6278958\",\n \"0.626489\",\n \"0.62630856\",\n \"0.6260835\",\n \"0.62566763\",\n \"0.62478083\",\n \"0.62360054\",\n \"0.6228049\",\n \"0.62173265\",\n \"0.6209698\",\n \"0.6207494\",\n \"0.6199827\",\n \"0.6199448\",\n \"0.6197533\",\n \"0.6196712\",\n \"0.61917156\",\n \"0.6186357\",\n \"0.6186357\",\n \"0.61806005\",\n \"0.61745524\",\n \"0.6157753\",\n \"0.61573446\",\n \"0.61565584\",\n \"0.614573\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.6748535"},"document_rank":{"kind":"string","value":"30"}}},{"rowIdx":24988,"cells":{"query":{"kind":"string","value":"Method to slice the cubesequence instance as a single cube Example >>> Say we have three Cubes each cube has common_axis=0 is time and shape=(3,3,3) >>> data_list = [cubeA, cubeB, cubeC] >>> cs = CubeSequence(data_list, meta=None, common_axis=0) >>> return zeroth time slice of cubeB in via normal CubeSequence indexing."},"document":{"kind":"string","value":"def index_as_cube(self):\n return _IndexAsCubeSlicer(self)"},"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 cube_like_tuple_item_to_sequence_items(item, common_axis, common_axis_lengths, n_cube_dims):\n if not hasattr(item, \"__len__\"):\n raise TypeError(\"item must be an iterable of slices and/or ints.\")\n if len(item) <= common_axis:\n raise ValueError(\"item must be include an entry for the common axis, \"\n \"i.e. length of item must be > common_axis.\")\n if not isinstance(item[common_axis], slice):\n raise TypeError(\"This function should only be used when the common axis entry \"\n \"of item is a slice object.\")\n # Define default item for slicing the cubes\n default_cube_item = list(item)\n default_cube_item[common_axis] = slice(None)\n\n # Convert start and stop cube-like indices to sequence and cube indices.\n if item[common_axis].start is None:\n common_axis_start = 0\n else:\n common_axis_start = item[common_axis].start\n if item[common_axis].stop is None:\n common_axis_stop = sum(common_axis_lengths)\n else:\n common_axis_stop = item[common_axis].stop\n item[common_axis] = slice(common_axis_start, common_axis_stop)\n start_sequence_index, start_common_axis_index = \\\n cube_like_index_to_sequence_and_common_axis_indices(\n item[common_axis].start, common_axis, common_axis_lengths)\n stop_sequence_index, stop_common_axis_index = \\\n cube_like_index_to_sequence_and_common_axis_indices(\n item[common_axis].stop - 1, common_axis, common_axis_lengths)\n stop_common_axis_index += 1\n # In the two lines above, the stop index was decremented by one in the\n # calculation of the stop sequence axis to avoid ticking over to new NDCube if not needed.\n # Once the correct sequence index was found,\n # 1 was added back onto the corresponding common axis index.\n\n # Create iterable of SequenceItems to tell us how to slice each cube.\n n_cubes_after_first = stop_sequence_index - start_sequence_index\n # If only one cube included in slicing item, return iterable of single SequenceItem\n if n_cubes_after_first == 0:\n cube_item = deepcopy(default_cube_item)\n cube_item[common_axis] = slice(start_common_axis_index, stop_common_axis_index)\n sequence_items = [SequenceItem(start_sequence_index, tuple(cube_item))]\n else:\n if n_cubes_after_first > 1: # Condition > 1 to exclude final cube. We'll add it later.\n sequence_items = [SequenceItem(i, tuple(default_cube_item))\n for i in range(start_sequence_index + 1, stop_sequence_index)]\n else:\n sequence_items = []\n # Insert final cube if there is one after the first.\n if n_cubes_after_first > 0:\n final_cube_item = deepcopy(default_cube_item)\n final_cube_item[common_axis] = slice(0, stop_common_axis_index)\n sequence_items.append(SequenceItem(stop_sequence_index, final_cube_item))\n # Finally, add Sequence index for first cube.\n first_cube_item = deepcopy(default_cube_item)\n first_cube_item[common_axis] = slice(start_common_axis_index, None)\n sequence_items.insert(0, SequenceItem(start_sequence_index, first_cube_item))\n return sequence_items","def slice_to_cube(self, axis, chunk, **kwargs):\n if self.data.ndim == 3:\n raise cu.CubeError(4, 'Can only slice a hypercube into a cube')\n\n item = [slice(None, None, None) for _ in range(4)]\n if isinstance(chunk, tuple):\n if cu.iter_isinstance(chunk, (u.Quantity, u.Quantity)):\n pixel0 = cu.convert_point(chunk[0].value, chunk[0].unit,\n self.axes_wcs, axis)\n pixel1 = cu.convert_point(chunk[1].value, chunk[1].unit,\n self.axes_wcs, axis)\n item[axis] = slice(pixel0, pixel1, None)\n elif cu.iter_isinstance((chunk, int, int)):\n item[axis] = slice(chunk[0], chunk[1], None)\n else:\n raise cu.CubeError(5, \"Parameters must be of the same type\")\n newdata = self.data[item].sum(axis)\n else:\n unit = chunk.unit if isinstance(chunk, u.Quantity) else None\n pixel = cu.convert_point(chunk, unit, self.axes_wcs, axis)\n item[axis] = pixel\n newdata = self.data[item]\n wcs_indices = [0, 1, 2, 3]\n wcs_indices.remove(3 - axis)\n newwcs = wu.reindex_wcs(self.axes_wcs, np.array(wcs_indices))\n if axis == 2 or axis == 3:\n newwcs = wu.add_celestial_axis(newwcs)\n newwcs.was_augmented = True\n cube = Cube(newdata, newwcs, meta=self.meta, **kwargs)\n return cube","def explode_along_axis(self, axis):\n # If axis is -ve then calculate the axis from the length of the dimensions of one cube\n if axis < 0:\n axis = len(self.dimensions) + axis\n # To store the resultant cube\n result_cubes = []\n # All slices are initially initialised as slice(None, None, None)\n cube_slices = [slice(None, None, None)] * self.data.ndim\n # Slicing the cube inside result_cube\n for i in range(self.data.shape[axis]):\n # Setting the slice value to the index so that the slices are done correctly.\n cube_slices[axis] = i\n # Set to None the metadata of sliced cubes.\n item = tuple(cube_slices)\n sliced_cube = self[item]\n sliced_cube.meta = None\n # Appending the sliced cubes in the result_cube list\n result_cubes.append(sliced_cube)\n # Creating a new NDCubeSequence with the result_cubes and common axis as axis\n return NDCubeSequence(result_cubes, meta=self.meta)","def test_get_first_cube(self):\n self.assertIs(self.cube_1,\n self.fix.get_cube_from_list(self.cubes, \"cube1\"))","def slice_during(self, e):\r\n\r\n if not isinstance(e, Epochs):\r\n raise ValueError('e has to be of Epochs type')\r\n\r\n if e.data.ndim > 0:\r\n raise NotImplementedError('e has to be a scalar Epoch')\r\n\r\n if self.ndim != 1:\r\n e_s = 'slicing only implemented for 1-d TimeArrays'\r\n return NotImplementedError(e_s)\r\n i_start = self.index_at(e.start)\r\n i_stop = self.index_at(e.stop)\r\n if e.start > self[i_start]: # make sure self[i_start] is in epoch e\r\n i_start += 1\r\n if e.stop > self[i_stop]: # make sure to include self[i_stop]\r\n i_stop += 1\r\n\r\n return slice(i_start, i_stop)","def test_slicing_containers(self):\n\n pattern = midi.Pattern()\n pattern.extend([midi.Track()] * 5)\n result1 = pattern[1]\n result2 = pattern[1:5]\n result3 = pattern[::2]\n\n track = midi.Track()\n track.extend([midi.Event()] * 5)\n result1 = track[1]\n result2 = track[1:5]\n result3 = track[::2]","def slice_during(self, e):\r\n\r\n if not isinstance(e, Epochs):\r\n raise ValueError('e has to be of Epochs type')\r\n\r\n if e.data.ndim > 0:\r\n raise NotImplementedError('e has to be a scalar Epoch')\r\n\r\n if self.ndim != 1:\r\n e_s = 'slicing only implemented for 1-d TimeArrays'\r\n return NotImplementedError(e_s)\r\n\r\n # These two should be called with modes, such that they catch the right\r\n # slice\r\n start = self.index_at(e.start, mode='after')\r\n stop = self.index_at(e.stop, mode='before')\r\n\r\n # If *either* the start or stop index object comes back as the empty\r\n # array, then it means the condition is not satisfied, we return the\r\n # slice that does [:0], i.e., always slices to nothing.\r\n if start.shape == (0,) or stop.shape == (0,):\r\n return slice(0)\r\n\r\n # Now, we know the start/stop are not empty arrays, but they can be\r\n # either scalars or arrays.\r\n i_start = start if np.isscalar(start) else start.max()\r\n i_stop = stop if np.isscalar(stop) else stop.min()\r\n\r\n if e.start > self[i_start]: # make sure self[i_start] is in epoch e\r\n i_start += 1\r\n if e.stop > self[i_stop]: # make sure to include self[i_stop]\r\n i_stop += 1\r\n\r\n return slice(i_start, i_stop)","def test_getslice1(self):\n class C(list):\n def __getitem__(self, index):\n return (index.start, index.stop)\n\n a = C()\n self.assertEqual(a[32:197], (32,197))","def _get_cube(datasets, short_name):\n datasets = select_metadata(datasets, short_name=short_name)\n if len(datasets) != 1:\n raise ValueError(\n f\"Expected exactly one dataset with short_name '{short_name}', \"\n f\"got {len(datasets):d}:\\n{datasets}\")\n return iris.load_cube(datasets[0]['filename'],\n NameConstraint(var_name=short_name))","def cqt_slices(record, t_len, shuffle=True, auto_restart=True,\n add_noise=True, random_seed=None,\n slice_logger=None):\n def cqt_slicer(cqt, idx, counter, t_len):\n obs = utils.slice_ndarray(cqt, idx[counter], length=t_len, axis=1)\n return obs[np.newaxis, ...]\n\n for cqt_slice in base_slicer(\n record, t_len, cqt_slicer,\n shuffle=shuffle, auto_restart=auto_restart,\n add_noise=add_noise, random_seed=random_seed,\n npz_data_key='cqt',\n slice_logger=slice_logger):\n yield cqt_slice","def test_get_second_cube(self):\n self.assertIs(self.cube_2,\n self.fix.get_cube_from_list(self.cubes, \"cube2\"))","def slicer(seq, start=None, stop=None, step=None):\n return seq[start:stop:step]","def simple_slice():\n examples = [\n benchmark.Example(\n inputs=[\n [[12, 34, 56, 78], [-1, -2, -3, -4]],\n -1,\n ],\n output=[[34, 56], [-2, -3]],\n ),\n ]\n constants = []\n description = 'Slice a tensor'\n target_program = 'in1[:, 1:in2]'\n source = 'handwritten task'\n return benchmark.Benchmark(examples=examples,\n constants=constants,\n description=description,\n target_program=target_program,\n source=source,\n name='simple_slice')","def getCube(unique_name):","def split_cube(cube):\n # Split first axis\n ax0 = cube[0]\n ax0 -= 0.5\n ax0[ax0 < 0] = ax0[ax0 < 0] * 2 - 1\n ax0[ax0 > 0] = ax0[ax0 > 0] * 2\n if cube.shape[0] > 1:\n # Scale other axes to be in a useful range for floor divide\n cube[1:] = cube[1:] * 4\n # Define the shifts\n displace = cube[1:].floor() % 2\n shift = displace[0]\n # We need an algebra that satisies: 1 * 0 = 0, 1 * 1 = 1, 0 * 1 = 0, 0 * 0 = 1\n # This is achieved with * = (==)\n for ax in displace[1:]:\n shift = shift == ax\n ax0 += shift\n cube[1:] -= 2\n cube *= 2\n return cube.t()","def convert_to_spectral_cube(self):\n if self.data.ndim == 4:\n raise cu.CubeError(4, \"Too many dimensions: Can only convert a \" +\n \"3D cube. Slice the cube before converting\")\n if 'WAVE' not in self.axes_wcs.wcs.ctype:\n raise cu.CubeError(2, 'Spectral axis needed to create a spectrum')\n axis = 0 if self.axes_wcs.wcs.ctype[-1] == 'WAVE' else 1\n coordaxes = [1, 2] if axis == 0 else [0, 2] # Non-spectral axes\n newwcs = wu.reindex_wcs(self.axes_wcs, np.arary(coordaxes))\n time_or_x_size = self.data.shape[coordaxes[1]]\n y_size = self.data.shape[coordaxes[0]]\n spectra = np.empty((time_or_x_size, y_size), dtype=Spectrum)\n for i in range(time_or_x_size):\n for j in range(y_size):\n spectra[i][j] = self.slice_to_spectrum(i, j)\n return SpectralCube(spectra, newwcs, self.meta)","def getcslice(self,first_,last_,c): # 3\n _copyback_c = False\n if c is None:\n c_ = None\n else:\n try:\n c_ = memoryview(c)\n except TypeError:\n try:\n _tmparr_c = array.array(\"d\",c)\n except TypeError:\n raise TypeError(\"Argument c has wrong type\")\n else:\n c_ = memoryview(_tmparr_c)\n _copyback_c = True\n else:\n if c_.format != \"d\":\n c_ = memoryview(array.array(\"d\",c))\n _copyback_c = True\n if c_ is not None and len(c_) != ((last_) - (first_)):\n raise ValueError(\"Array argument c has wrong length\")\n res = self.__obj.getcslice(first_,last_,c_)\n if res != 0:\n result,msg = self.__getlasterror(res)\n raise Error(rescode(res),msg)\n if _copyback_c:\n c[:] = _tmparr_c","def get_slice(self, limit, offset):\r\n if limit == 0:\r\n return self.objects[offset:]\r\n\r\n return self.objects[offset:offset + limit]","def get_slice(self, n):\n if n == 0:\n return slice(self._lo_atom, self._lo_atom + self._n_atoms)\n raise IndexError(f\"{n} is invalid for a 1 dimension Slice \")","def __getitem__( self, index ):\n \n # check dimensions - this rules out the ellisis (...) for the moment\n if len( index ) != 3:\n raise ValueError(\"This is a three-dimensional object, please index accordingly.\")\n\n # get involved file numbers and steps\n # if index[0] is a single number (not iterable, not a slice), make a list of it\n if not hasattr( index[0], '__iter__') and not isinstance( index[0], slice ):\n valid_steps = self._valid_steps[ [index[0]], :2 ]\n else:\n valid_steps = self._valid_steps[ index[0], :2 ]\n \n # if image should be cropped make sure that slices stay slices (is about 30% faster)\n if self._cropped: \n if isinstance( index[1], slice ):\n a = self._ymin if index[1].start is None else index[1].start+self._ymin\n b = self._ymax if index[1].stop is None else index[1].stop+self._ymin \n internal_index1 = slice( a, b, index[1].step )\n \n else:\n internal_index1 = np.arange( self._ymin, self._ymax )[ index[1] ]\n \n if isinstance( index[2], slice ):\n a = self._xmin if index[2].start is None else index[2].start+self._xmin\n b = self._xmax if index[2].stop is None else index[2].stop+self._xmin \n internal_index2 = slice( a, b, index[2].step )\n \n else:\n internal_index2 = np.arange( self._xmin, self._xmax )[ index[2] ]\n\n else:\n internal_index1 = index[1]\n internal_index2 = index[2]\n\n # get all data slices and concatenate them (always use data interface here, regardless of whether memory mapping is used or not)\n slices = []\n for file_no in np.unique( valid_steps[:,0] ):\n file = ir.file_hub.open( self._files[file_no] )\n slices.append( file[ self._selected_ext ].data[ valid_steps[ valid_steps[:,0] == file_no, 1 ], internal_index1, internal_index2 ] )\n slices = np.vstack( slices )\n\n # remove first dimension if there is only one slice\n if slices.shape[0] == 1 and slices.ndim == 3:\n slices = slices[0,:,:]\n \n return slices","def __getitem__(self, index):\n return (index, self.data_cube[0, index, :])","def SliceView(sequence, start=None, stop=None, step=1):\n start, stop, step = slice(start, stop, step).indices(len(sequence))\n for i in range(start, stop, step):\n yield sequence[i]","def cube_like_index_to_sequence_and_common_axis_indices(cube_like_index, common_axis,\n common_axis_lengths):\n cumul_lengths = np.cumsum(common_axis_lengths)\n sequence_index = np.arange(len(cumul_lengths))[cumul_lengths > cube_like_index][0]\n if sequence_index == 0:\n common_axis_index = cube_like_index\n else:\n common_axis_index = cube_like_index - cumul_lengths[sequence_index - 1]\n return sequence_index, common_axis_index","def _collapse_scalar_dimensions(cube: Cube) -> Cube:\n coords_to_collapse = []\n for coord in cube.coords(dim_coords=True):\n if len(coord.points) == 1 and \"realization\" not in coord.name():\n coords_to_collapse.append(coord)\n for coord in coords_to_collapse:\n cube = next(cube.slices_over(coord))\n return cube","def __getslice__(self, start, stop):\n return self.__getitem__(slice(start, stop, None))","def collapse_time(cube, ntimes, timestep):\n\n if timestep == None:\n print('Averaging over the %s time points' %(str(ntimes)))\n new_cube = cube.collapsed('time', iris.analysis.MEAN)\n else:\n assert new_cube.coords()[0] == 'time'\n new_cube = cube[timestep, :, :]\n\n return new_cube","def _simslice(simulation, clump=None):\n if clump is None:\n # No slicing required\n s = simulation\n \n else:\n # Slice according to clump\n s = simulation[clump]\n \n if not isinstance(s, sim):\n # Cast s as a sim object\n dummy = sim(1)\n dummy[0] = s\n s = dummy\n \n return s","def select_time(new_cube, lower, upper):\n\n sliced_cube = new_cube.extract(iris.Constraint(year=lambda y: lower<=y<=upper))\n\n return sliced_cube","def slice(self,x=None,y=None,z=None,c=None):\n\n if x is None:\n x = slice(0,self._metaData[\"size_x\"])\n if y is None:\n y = slice(0,self._metaData[\"size_y\"])\n if z is None:\n z = slice(0,self._metaData[\"size_z\"])\n if c is None:\n c = slice(0,self._metaData[\"size_c\"])\n\n img_crop=MicImage()\n img_crop._metaData={**self._metaData}\n img_crop.xml=self.xml\n\n\n img_crop.pixels= copy.deepcopy(self.pixels[z,x,y,c])\n \n if img_crop.pixels.shape[0]==1:\n img_crop.pixels=np.squeeze(img_crop.pixels)\n img_crop.sumprj=np.squeeze(img_crop.pixels)\n img_crop.maxprj=np.squeeze(img_crop.pixels)\n else:\n img_crop.sumprj=(np.sum(img_crop.pixels,axis=0))\n img_crop.maxprj=(np.amax(img_crop.pixels,axis=0))\n img_crop.meanprj=(np.mean(img_crop.pixels,axis=0))\n\n img_crop._metaData.update({\"size_z\": img_crop.pixels.shape[0]})\n img_crop._metaData.update({\"size_x\": img_crop.pixels.shape[1]})\n img_crop._metaData.update({\"size_y\": img_crop.pixels.shape[2]})\n img_crop._metaData.update({\"size_c\": img_crop.pixels.shape[3]})\n\n return img_crop","def __init__(self, cube_size, time_range):\n\n # cubesize is in z,y,x for interactions with tile/image data\n self.zdim, self.ydim, self.xdim = self.cubesize = [cube_size[2], cube_size[1], cube_size[0]]\n self.time_range = time_range\n self._newcube = False","def test05(self):\n a = np.arange(1e3)\n b = bcolz.carray(a, chunklen=10, rootdir=self.rootdir)\n sl = slice(None, None, -3)\n # print \"b[sl]->\", `b[sl]`\n self.assertRaises(NotImplementedError, b.__getitem__, sl)","def subcubes_from_ds9(cube, region_file='../nro_maps/AllShells.reg', pad_factor=1., shape='exact'):\n from spectral_cube import SpectralCube\n import pyregion\n\n try:\n #If cube is a str filename, read a SpectralCube.\n cube = SpectralCube.read(cube)\n except ValueError:\n pass\n\n if shape == 'square':\n import astropy.units as u\n subcube_list = []\n region_list = pyregion.open(region_file)\n for region in region_list:\n half_width = region.coord_list[2] * pad_factor * u.deg\n ra_center = region.coord_list[0] * u.deg\n dec_center = region.coord_list[1] * u.deg\n ra_range = [ra_center - half_width, ra_center + half_width]\n dec_range = [dec_center - half_width, dec_center + half_width]\n #print(ra_range, dec_range)\n subcube_list.append(cube.subcube(ra_range[1], ra_range[0], dec_range[0], dec_range[1]))\n if shape == 'exact':\n region_list = pyregion.open(region_file)\n subcube_list = []\n for region in region_list:\n \n if pad_factor != 1.:\n new_string = '{};{}({},{},{}\")'.format(region.coord_format, region.name,\n region.coord_list[0], region.coord_list[1],\n region.coord_list[2]*3600.*pad_factor)\n region = pyregion.parse(new_string)[0]\n \n subcube_list.append(cube.subcube_from_ds9region(pyregion.ShapeList([region])))\n if len(subcube_list) == 1:\n return subcube_list[0]\n else:\n return subcube_list","def _slice(self, start, stop, step=None):\n\n slices = [slice(None)] * self.data.ndim\n slices[self.axis] = slice(start, stop, step)\n return tuple(slices)","def getcslice(self,first_,last_,c_):\n _c_minlength = ((last_) - (first_))\n if ((last_) - (first_)) > 0 and c_ is not None and len(c_) != ((last_) - (first_)):\n raise ValueError(\"Array argument c is not long enough: Is %d, expected %d\" % (len(c_),((last_) - (first_))))\n if isinstance(c_,numpy.ndarray) and not c_.flags.writeable:\n raise ValueError(\"Argument c must be writable\")\n if isinstance(c_, numpy.ndarray) and c_.dtype is numpy.dtype(numpy.float64) and c_.flags.contiguous:\n _c_copyarray = False\n _c_tmp = ctypes.cast(c_.ctypes._as_parameter_,ctypes.POINTER(ctypes.c_double))\n elif c_ is not None:\n _c_copyarray = True\n _c_np_tmp = numpy.zeros(len(c_),numpy.dtype(numpy.float64))\n _c_np_tmp[:] = c_\n assert _c_np_tmp.flags.contiguous\n _c_tmp = ctypes.cast(_c_np_tmp.ctypes._as_parameter_,ctypes.POINTER(ctypes.c_double))\n else:\n _c_copyarray = False\n _c_tmp = None\n \n res = __library__.MSK_XX_getcslice(self.__nativep,first_,last_,_c_tmp)\n if res != 0:\n _,msg = self.__getlasterror(res)\n raise Error(rescode(res),msg)\n if _c_copyarray:\n c_[:] = _c_np_tmp","def slice(tensor):\n out = tensor[:, 444:524, :]\n return out","def __getitem__(self, idx):\n sliced_timeseries = [None] * self.ch_amount\n return_instant = False\n if not self.trigger_idx:\n self.trigger_idx = 0\n\n trigger_length = len(self.timeseries[self.trigger_idx])\n\n # If idx is an integer, return an \"instantaneous slice\" and initialise slice\n if isinstance(idx, int):\n return_instant = True\n\n # If idx is a negative integer, take the idx element from the end.\n if idx < 0:\n idx = trigger_length + idx\n\n idx = slice(idx, idx + 1)\n\n # If idx.start or stop are None, make them 0 or trigger length.\n if idx.start is None:\n idx = slice(0, idx.stop)\n if idx.stop is None:\n idx = slice(idx.start, trigger_length)\n\n # Check that the indexes are not out of bounds\n if idx.start >= trigger_length or idx.stop > trigger_length:\n raise IndexError(\n f\"Slice ({idx.start}, {idx.stop}) is out of \"\n f\"bounds for channel {self.trigger_idx} \"\n f\"with size {trigger_length}\"\n )\n\n # Operate on each channel on its own\n for n, channel in enumerate(self.timeseries):\n idx_dict = {\"start\": idx.start, \"stop\": idx.stop, \"step\": idx.step}\n # Adapt the slicing indexes to the right frequency\n for i in [\"start\", \"stop\", \"step\"]:\n if idx_dict[i]:\n idx_dict[i] = int(\n np.floor(self.freq[n] / self.freq[self.trigger_idx] * idx_dict[i])\n )\n\n # Correct the slicing stop if necessary\n if idx_dict[\"start\"] == idx_dict[\"stop\"] or return_instant:\n idx_dict[\"stop\"] = idx_dict[\"start\"] + 1\n elif trigger_length == idx.stop:\n idx_dict[\"stop\"] = len(channel)\n\n new_idx = slice(idx_dict[\"start\"], idx_dict[\"stop\"], idx_dict[\"step\"])\n sliced_timeseries[n] = channel[new_idx]\n\n sliced_bp = BlueprintInput(\n sliced_timeseries,\n self.freq,\n self.ch_name,\n self.units,\n self.trigger_idx,\n self.num_timepoints_found,\n self.thr,\n self.time_offset,\n )\n\n sliced_bp._time_resampled_to_trigger = self._time_resampled_to_trigger\n return sliced_bp","def test_timeseries_indexing():\n s = channel.Slice(channel.TimeSeries([14, 15, 16, 17], [4, 5, 6, 7]))\n\n np.testing.assert_equal(s[0:5].data, [14])\n np.testing.assert_equal(s[0:5].timestamps, [4])\n np.testing.assert_equal(s[4:5].data, [14])\n np.testing.assert_equal(s[4:5].timestamps, [4])\n np.testing.assert_equal(s[4:6].data, [14, 15])\n np.testing.assert_equal(s[4:6].timestamps, [4, 5])\n np.testing.assert_equal(s[4:10].data, [14, 15, 16, 17])\n np.testing.assert_equal(s[4:10].timestamps, [4, 5, 6, 7])\n\n with pytest.raises(IndexError) as exc:\n assert s[1]\n assert str(exc.value) == \"Scalar indexing is not supported, only slicing\"\n with pytest.raises(IndexError) as exc:\n assert s[1:2:3]\n assert str(exc.value) == \"Slice steps are not supported\"\n\n s = channel.Slice(channel.TimeSeries([], []))\n assert len(s[1:2].data) == 0\n assert len(s[1:2].timestamps) == 0","def wcqt_slices(record, t_len, shuffle=True, auto_restart=True, add_noise=True,\n p_len=54, p_stride=36, random_seed=None, slice_logger=None):\n def wcqt_slicer(cqt, idx, counter, t_len):\n # Grab the obs\n obs = utils.slice_ndarray(cqt, idx[counter], length=t_len, axis=1)\n # Convert it to WCQT\n wcqt = utils.fold_array(obs[0], length=p_len, stride=p_stride)\n # Fix the shape.s\n return wcqt[np.newaxis, ...]\n\n for wcqt_slice in base_slicer(\n record, t_len, wcqt_slicer,\n shuffle=shuffle, auto_restart=auto_restart,\n add_noise=add_noise, random_seed=random_seed,\n npz_data_key='cqt',\n slice_logger=slice_logger):\n yield wcqt_slice","def plot_x_slice(self, offset, **kwargs):\n cumul_cube_lengths = np.cumsum(np.array([c.shape[self.common_axis]\n for c in self.data]))\n sequence_index, cube_index = cu._convert_cube_like_index_to_sequence_indices(\n offset, cumul_cube_lengths)\n plot = self[sequence_index].plot_x_slice(cube_index, **kwargs)\n return plot","def stack_cuboids(c_list, axis, domain=None, axis_pos='first'):\n assert isinstance(axis, str)\n size = len(c_list)\n cub0 = c_list[0]\n axes = cub0.axes_names\n # print 'axes:', axes\n sh = (size,) + cub0.data.shape\n stackedData = np.zeros(sh, cub0.data.dtype)\n newDomains = cub0.axes_domains.copy()\n if domain is not None:\n newDomains[axis] = domain\n targetCub = xndarray(stackedData,\n axes_names=[axis] + cub0.axes_names,\n axes_domains=newDomains, value_label=cub0.value_label)\n # print 'c_list', c_list, c_list[0], c_list[1]\n for i, cuboid in enumerate(c_list):\n if debug:\n print 'targetCub.data[i] :', targetCub.data[i].shape\n if debug:\n print 'cuboid', cuboid.descrip()\n # print 'number:', i\n # print 'cuboid.axes:', cuboid.axes_names\n if axes != cuboid.axes_names:\n raise Exception('%dth cuboid in list does not match other cuboids'\n 'found axes: %s, should be: %s'\n % (i, str(cuboid.axes_names), str(axes)))\n\n # TODO: better use numpy stacking functions (faster)\n targetCub.data[i] = cuboid.data\n\n if axis_pos == 'last':\n targetCub.roll(axis)\n\n return targetCub","def relay_array_getitem(c, a, start, stop, strides):\n assert start.is_constant(tuple)\n assert stop.is_constant(tuple)\n assert strides.is_constant(tuple)\n return relay.op.transform.strided_slice(c.ref(a), start.value, stop.value,\n strides.value)","def testSliceMiddleWithMixedIndex(self):\n inst = WireData(b'0123456789')\n self.assertEqual(inst[-8:3], WireData(b'2'))\n self.assertEqual(inst[5:-3], WireData(b'56'))","def _slice_at_axis(sl, axis):\n return (slice(None),) * axis + (sl,) + (...,)","def __getitem__(self, item):\n return self.cube[item]","def __getitem__(self, idx):\n if idx >= len(self):\n raise StopIteration\n\n _, timesteps, height, width = self.data.shape\n\n # If time=True, return an entire time slice,\n # otherwise return a single time step\n t = slice(None)\n if not self.time:\n t = idx % timesteps\n idx = idx // timesteps\n\n if self.subset == 'train':\n # Right quadrants\n # Return a random subset\n xl = width // 2\n xr = width - self.size\n x = random.randint(xl, xr)\n\n yu = 0\n yl = height - self.size\n y = random.randint(yu, yl)\n elif self.subset == 'val':\n # Bottom left quadrant\n # Convert the index to a (row, col) location\n row = idx // (width // 2 // self.size)\n col = idx % (width // 2 // self.size)\n\n # Find the exact coordinates in the array\n y = row * self.size + (height // 2)\n x = col * self.size\n elif self.subset == 'test':\n # Top left quadrant\n # Convert the index to a (row, col) location\n row = idx // (width // 2 // self.size)\n col = idx % (width // 2 // self.size)\n\n # Find the exact coordinates in the array\n y = row * self.size\n x = col * self.size\n else:\n # All quadrants\n # Convert the index to a (row, col) location\n row = idx // (width // self.size)\n col = idx % (width // self.size)\n\n # Find the exact coordinates in the array\n y = row * self.size\n x = col * self.size\n\n data = self.data[:, t, y:y + self.size, x:x + self.size]\n target = self.segmentation[y:y + self.size, x:x + self.size]\n\n # Apply any requested transforms\n if self.transform:\n data = self.transform(data)\n\n if self.target_transform:\n target = self.target_transform(target)\n\n if isinstance(t, slice):\n t = np.zeros_like(y) - 1\n\n return data, target, t, y, x","def cube_subsample(array, n, mode=\"mean\", parallactic=None, verbose=False):\n if not array.ndim == 3:\n raise TypeError('The input array is not a cube or 3d array.')\n m = int(array.shape[0]/n) \n y = array.shape[1]\n x = array.shape[2]\n arr = np.empty([m, y, x]) \n if mode == 'median':\n for i in xrange(m): \n arr[i, :, :] = np.median(array[:n, :, :], axis=0) # first new frame, mean of first n frames\n if i >= 1:\n arr[i, :, :] = np.median(array[n*i:n*i+n, :, :], axis=0) \n if mode=='mean':\n for i in xrange(m): \n arr[i, :, :] = np.mean(array[:n, :, :], axis=0) \n if i >= 1:\n arr[i, :, :] = np.mean(array[n*i:n*i+n, :, :], axis=0)\n else: \n raise ValueError('Mode should be either Mean or Median.')\n if parallactic is not None:\n angles = parallactic.byteswap().newbyteorder()\n angles = pn.rolling_mean(angles, n, center=True)\n angles = pn.DataFrame(angles)\n angles = pn.DataFrame.fillna(angles, method='pad')\n angles = pn.DataFrame.fillna(angles, method='bfill')\n angles = np.array(angles)\n angles = angles[0:m*n:n]\n if array.shape[0]/n % 1 != 0:\n print '\\nInitial # of frames and window are not multiples. A few frames were dropped.' \n if verbose:\n print \"Done {:} over FITS-Cube with window n = {:}\".format(mode ,n) \n if parallactic is not None:\n return arr, angles\n else:\n return arr","def getSlice(properties=None, **kw):","def __setslice__(self, *args):\n return _itkSurfaceSpatialObjectPointPython.vectoritkSurfaceSpatialObjectPoint3___setslice__(self, *args)","def chunked_collapse_by_time(cube, collapse_dims, agg_method, weights=None):\n\n assert agg_method in [iris.analysis.SUM, iris.analysis.MEAN]\n\n chunk_list = iris.cube.CubeList([])\n coord_names = [coord.name() for coord in cube.dim_coords]\n start_indexes, step = get_chunks(cube.shape, coord_names, chunk=True)\n for index in start_indexes:\n if type(weights) in [numpy.ndarray, numpy.ma.core.MaskedArray]:\n chunk = cube[index:index+step, ...].collapsed(collapse_dims, agg_method, weights=weights[index:index+step, ...])\n else:\n chunk = cube[index:index+step, ...].collapsed(collapse_dims, agg_method)\n chunk_list.append(chunk)\n\n collapsed_cube = chunk_list.concatenate()[0]\n\n return collapsed_cube","def get1DSlice( self, slices: list ):\n assert(len(slices)==self._nDims-1)\n slices.append(slice(self._nGlobalCoords[self._layout.dims_order[-1]]))\n return self._f[tuple(slices)]","def zeros(self):\n super(TimeCube, self).zeros()\n self.data = np.zeros([self.time_range[1]-self.time_range[0]]+self.cubesize, np.uint8)","def slice_timeseries(n_slices,dataset):\n\n n,l=np.shape(dataset)\n\n X = np.reshape(dataset,(n*n_slices,l//n_slices))\n\n print('sliced data shape (nr. of slices, slice length):',np.shape(X))\n print('#####################################')\n \n return X","def Cube(center=(0.0, 0.0, 0.0), x_length=1.0, y_length=1.0, z_length=1.0, bounds=None, clean=True):\n src = _vtk.vtkCubeSource()\n if bounds is not None:\n if np.array(bounds).size != 6:\n raise TypeError(\n 'Bounds must be given as length 6 tuple: (xMin, xMax, yMin, yMax, zMin, zMax)'\n )\n src.SetBounds(bounds)\n else:\n src.SetCenter(center)\n src.SetXLength(x_length)\n src.SetYLength(y_length)\n src.SetZLength(z_length)\n src.Update()\n cube = wrap(src.GetOutput())\n\n # add face index data for compatibility with PlatonicSolid\n # but make it inactive for backwards compatibility\n cube.cell_data.set_array([1, 4, 0, 3, 5, 2], 'FaceIndex')\n\n # clean duplicate points\n if clean:\n cube.clean(inplace=True)\n\n return cube","def __getslice__( self, *args):\n return array.array.__getslice__(self, *args).tostring()","def init_reshape(cube, nside):\n half_nside = 2**nside / 2\n \n dim1 = cube.shape[1]/2 - half_nside\n dim2 = cube.shape[1]/2 + half_nside\n dim3 = cube.shape[2]/2 - half_nside\n dim4 = cube.shape[2]/2 + half_nside\n\n return cube[:, dim1:dim2, dim3:dim4]","def __delslice__(self, *args):\n return _itkSurfaceSpatialObjectPointPython.vectoritkSurfaceSpatialObjectPoint3___delslice__(self, *args)","def test_slice_other_dimension(self):\n for i, shape in enumerate([(3, 0), (1, 2, 0), (2, 0, 1)]):\n dset = self.f.create_dataset('x%d'%i, shape, dtype=int, maxshape=(None,)*len(shape))\n self.assertEqual(dset.shape, shape)\n out = dset[:1]\n self.assertIsInstance(out, np.ndarray)\n self.assertEqual(out.shape, (1,)+shape[1:])","def test_slice_zero_length_dimension(self):\n for i, shape in enumerate([(0,), (0, 3), (0, 2, 1)]):\n dset = self.f.create_dataset('x%d'%i, shape, dtype=int, maxshape=(None,)*len(shape))\n self.assertEqual(dset.shape, shape)\n out = dset[...]\n self.assertIsInstance(out, np.ndarray)\n self.assertEqual(out.shape, shape)\n out = dset[:]\n self.assertIsInstance(out, np.ndarray)\n self.assertEqual(out.shape, shape)\n if len(shape) > 1:\n out = dset[:, :1]\n self.assertIsInstance(out, np.ndarray)\n self.assertEqual(out.shape[:2], (0, 1))","def __getslice__(self, *args):\n return _itkSurfaceSpatialObjectPointPython.vectoritkSurfaceSpatialObjectPoint3___getslice__(self, *args)","def get_slice_from_list(self,list_,start=0,end=None):\r\n start = self._index_to_int(start,True)\r\n if end is not None:\r\n end= self._index_to_int(end)\r\n\r\n return list_[start:end]","def cube_data(self):\n cube_data = copy.deepcopy(self.data)\n cube_data.shape = [self.nints * self.ngroups, self.rows, self.columns]\n return cube_data","def _adimsdi_singlepca(cube, angle_list, scale_list, ncomp, scaling,\n mask_center_px, debug, svd_mode, imlib, interpolation,\n collapse, verbose, start_time, full_output):\n z, n, y_in, x_in = cube.shape\n\n if ncomp is None:\n raise ValueError('`Ncomp` must be provided (positive integer value)')\n\n if not angle_list.shape[0] == n:\n msg = \"Angle list vector has wrong length. It must equal the number\"\n msg += \" frames in the cube\"\n raise ValueError(msg)\n\n if scale_list is None:\n raise ValueError('Scaling factors vector must be provided')\n else:\n if np.array(scale_list).ndim > 1:\n raise ValueError('Scaling factors vector is not 1d')\n if not scale_list.shape[0] == cube.shape[0]:\n raise ValueError('Scaling factors vector has wrong length')\n\n scale_list = check_scal_vector(scale_list)\n big_cube = []\n\n if verbose:\n tit = 'Rescaling the spectral channels to align the speckles'\n bar = pyprind.ProgBar(n, stream=1, title=tit)\n for i in range(n):\n cube_resc, _, _, _, _, _ = scpca(cube[:, i, :, :], scale_list)\n cube_resc = cube_crop_frames(cube_resc, size=y_in, verbose=False)\n big_cube.append(cube_resc)\n if verbose:\n bar.update()\n\n big_cube = np.array(big_cube)\n big_cube = big_cube.reshape(z * n, y_in, x_in)\n\n if verbose:\n timing(start_time)\n print('{} total frames'.format(n * z))\n print('Performing single PCA')\n res_cube = _subtr_proj_fullfr(big_cube, None, ncomp, scaling,\n mask_center_px, debug, svd_mode, False, False)\n\n if verbose:\n timing(start_time)\n\n resadi_cube = np.zeros((n, y_in, x_in))\n if verbose:\n tit = 'Descaling the spectral channels'\n bar = pyprind.ProgBar(n, stream=1, title=tit)\n for i in range(n):\n frame_i = scpca(res_cube[i * z:(i+1) * z, :, :], scale_list,\n full_output=full_output, inverse=True, y_in=y_in,\n x_in=x_in)\n resadi_cube[i] = frame_i\n if verbose:\n bar.update()\n\n if verbose:\n print('De-rotating and combining residuals')\n timing(start_time)\n der_res = cube_derotate(resadi_cube, angle_list, imlib=imlib,\n interpolation=interpolation)\n frame = cube_collapse(der_res, mode=collapse)\n\n cube_allfr_residuals = res_cube\n cube_adi_residuals = resadi_cube\n return cube_allfr_residuals, cube_adi_residuals, frame","def slice(self, begin, end):\n sliced = self._collection.slice(begin, end)\n return self.set_collection(sliced)","def __getitem__(self, n):\n if isinstance(n, slice):\n start, stop, step = n.start, n.stop, n.step\n if not start:\n start = 0\n if not stop:\n stop = len(self)\n if stop < 0:\n stop = len(self) + stop\n if start < 0:\n start = len(self) + start\n return self._fa.get_seq(self.name, start + 1, stop)[::step]\n\n elif isinstance(n, int):\n if n < 0:\n n = len(self) + n\n return self._fa.get_seq(self.name, n + 1, n + 1)","def getxcslice(self,whichsol_,first_,last_,xc_):\n _xc_minlength = ((last_) - (first_))\n if ((last_) - (first_)) > 0 and xc_ is not None and len(xc_) != ((last_) - (first_)):\n raise ValueError(\"Array argument xc is not long enough: Is %d, expected %d\" % (len(xc_),((last_) - (first_))))\n if isinstance(xc_,numpy.ndarray) and not xc_.flags.writeable:\n raise ValueError(\"Argument xc must be writable\")\n if isinstance(xc_, numpy.ndarray) and xc_.dtype is numpy.dtype(numpy.float64) and xc_.flags.contiguous:\n _xc_copyarray = False\n _xc_tmp = ctypes.cast(xc_.ctypes._as_parameter_,ctypes.POINTER(ctypes.c_double))\n elif xc_ is not None:\n _xc_copyarray = True\n _xc_np_tmp = numpy.zeros(len(xc_),numpy.dtype(numpy.float64))\n _xc_np_tmp[:] = xc_\n assert _xc_np_tmp.flags.contiguous\n _xc_tmp = ctypes.cast(_xc_np_tmp.ctypes._as_parameter_,ctypes.POINTER(ctypes.c_double))\n else:\n _xc_copyarray = False\n _xc_tmp = None\n \n res = __library__.MSK_XX_getxcslice(self.__nativep,whichsol_,first_,last_,_xc_tmp)\n if res != 0:\n _,msg = self.__getlasterror(res)\n raise Error(rescode(res),msg)\n if _xc_copyarray:\n xc_[:] = _xc_np_tmp","def shuffle_cube(cube):\n shuffled = []\n column_group_order = [n for n in range(int(math.sqrt(len(cube))))]\n random.shuffle(column_group_order)\n for i in column_group_order:\n # shuffle columns within each of the 3 column groups\n column_order = [n for n in range(int(math.sqrt(len(cube))))]\n random.shuffle([n for n in range(int(math.sqrt(len(cube))))])\n for j in column_order:\n shuffled.append(cube[int(math.sqrt(len(cube))) * i + j])\n\n return shuffled","def batch_slices(batch, sizes=False, include_ends=True):\n size = scatter_add(torch.ones_like(batch), batch)\n cumsum = torch.cumsum(size, dim=0)\n starts = cumsum - size\n ends = cumsum - 1\n\n slices = starts\n if include_ends:\n slices = torch.stack([starts, ends], dim=1).view(-1)\n\n if sizes:\n return slices, size\n return slices","def get_cube_from_list(\n self,\n cubes: CubeList,\n short_name: Optional[str] = None,\n ) -> Cube:\n if short_name is None:\n short_name = self.vardef.short_name\n for cube in cubes:\n if cube.var_name == short_name:\n return cube\n raise Exception(f'Cube for variable \"{short_name}\" not found')","def _get_slice(index, axis, num_axes):\n idx = [slice(None)] * num_axes\n idx[axis] = index\n return tuple(idx)","def slice(self) -> Tuple[slice, ...]:\n\n total_slice = tuple(slice(None) for _ in self.collection_shape)\n for obj in self.objects.flat:\n for i, current_slice in enumerate(obj.slices):\n if total_slice[i].start is None:\n total_slice = total_slice[:i] + (current_slice,) + total_slice[i + 1:]\n else:\n if current_slice.start < total_slice[i].start:\n total_slice = total_slice[:i] + (\n slice(current_slice.start, total_slice[i].stop, total_slice[i].step),) + total_slice[i + 1:]\n if current_slice.stop > total_slice[i].stop:\n total_slice = total_slice[:i] + (\n slice(total_slice[i].start, current_slice.stop, total_slice[i].step),) + total_slice[i + 1:]\n return total_slice","def __getitem__(self, item):\n # type (Any) -> Any\n # Workaround for Arrow bug that segfaults on empty slice.\n # This is fixed in Arrow master, will be released in 0.10\n if isinstance(item, slice):\n start = item.start or 0\n stop = item.stop if item.stop is not None else len(self.data)\n stop = min(stop, len(self.data))\n step = item.step if item.step is not None else 1\n # Arrow can't handle slices with steps other than 1\n # https://issues.apache.org/jira/browse/ARROW-2714\n if step != 1:\n arr = np.asarray(self)[item]\n # ARROW-2806: Inconsistent handling of np.nan requires adding a mask\n if pa.types.is_integer(self.dtype.arrow_dtype) or pa.types.is_floating(\n self.dtype.arrow_dtype\n ):\n mask = pd.isna(arr)\n else:\n mask = None\n return type(self)(pa.array(arr, type=self.dtype.arrow_dtype, mask=mask))\n if stop - start == 0:\n return type(self)(pa.array([], type=self.data.type))\n elif isinstance(item, Iterable):\n if not is_array_like(item):\n item = np.array(item)\n if is_integer_dtype(item):\n return self.take(item)\n elif is_bool_dtype(item):\n indices = np.array(item)\n indices = np.argwhere(indices).flatten()\n return self.take(indices)\n else:\n raise IndexError(\n \"Only integers, slices and integer or boolean arrays are valid indices.\"\n )\n elif is_integer(item):\n if item < 0:\n item += len(self)\n if item >= len(self):\n return None\n value = self.data[item]\n if isinstance(value, pa.ChunkedArray):\n return type(self)(value)\n else:\n return value.as_py()","def hcqt_slices(record, t_len, shuffle=True, auto_restart=True, add_noise=True,\n random_seed=None, slice_logger=None):\n def hcqt_slicer(cqt, idx, counter, t_len):\n # hcqt = np.swapaxes(cqt, 1, 2)\n # Grab the obs\n obs = utils.slice_ndarray(cqt, idx[counter], length=t_len, axis=-2)\n # Fix the shape.\n return obs[np.newaxis, ...] if np.ndim(obs) == 3 else obs\n\n for hcqt_slice in base_slicer(\n record, t_len, hcqt_slicer,\n shuffle=shuffle, auto_restart=auto_restart,\n add_noise=add_noise, random_seed=random_seed,\n npz_data_key='harmonic_cqt',\n slice_logger=slice_logger):\n yield hcqt_slice","def transform_cube(self,\n cube: xr.Dataset,\n gm: GridMapping,\n cube_config: CubeConfig) -> TransformedCube:\n return cube, gm, cube_config","def __getitem__(self, item):\n c_ex = self.examples[item]\n # randomly select ref mic\n mics = [x for x in c_ex.keys()]\n if self.train:\n np.random.shuffle(mics) # randomly permute during training to change ref mics\n\n mixtures = []\n sources = []\n for i in range(len(mics)):\n c_mic = c_ex[mics[i]]\n\n if self.segment:\n offset = 0\n if c_mic[\"length\"] > int(self.segment * self.sample_rate):\n offset = np.random.randint(\n 0, c_mic[\"length\"] - int(self.segment * self.sample_rate)\n )\n\n # we load mixture\n mixture, fs = sf.read(\n c_mic[\"mixture\"],\n start=offset,\n stop=offset + int(self.segment * self.sample_rate),\n dtype=\"float32\",\n )\n spk1, fs = sf.read(\n c_mic[\"spk1\"],\n start=offset,\n stop=offset + int(self.segment * self.sample_rate),\n dtype=\"float32\",\n )\n spk2, fs = sf.read(\n c_mic[\"spk2\"],\n start=offset,\n stop=offset + int(self.segment * self.sample_rate),\n dtype=\"float32\",\n )\n else:\n mixture, fs = sf.read(c_mic[\"mixture\"], dtype=\"float32\") # load all\n spk1, fs = sf.read(c_mic[\"spk1\"], dtype=\"float32\")\n spk2, fs = sf.read(c_mic[\"spk2\"], dtype=\"float32\")\n\n mixture = torch.from_numpy(mixture).unsqueeze(0)\n spk1 = torch.from_numpy(spk1).unsqueeze(0)\n spk2 = torch.from_numpy(spk2).unsqueeze(0)\n\n assert fs == self.sample_rate\n mixtures.append(mixture)\n sources.append(torch.cat((spk1, spk2), 0))\n\n mixtures = torch.cat(mixtures, 0)\n sources = torch.stack(sources)\n # we pad till max_mic\n valid_mics = mixtures.shape[0]\n if mixtures.shape[0] < self.max_mics:\n dummy = torch.zeros((self.max_mics - mixtures.shape[0], mixtures.shape[-1]))\n mixtures = torch.cat((mixtures, dummy), 0)\n sources = torch.cat((sources, dummy.unsqueeze(1).repeat(1, sources.shape[1], 1)), 0)\n return mixtures, sources, valid_mics","def test02c(self):\n a = np.arange(1e3)\n b = bcolz.carray(a, chunklen=10, rootdir=self.rootdir)\n sl = slice(1, -3)\n # print \"b[sl]->\", `b[sl]`\n assert_array_equal(a[sl], b[sl], \"Arrays are not equal\")","def __getitem__(self, item):\n if isinstance(item, slice):\n start = item.start or 0\n stop = item.stop if item.stop is not None else len(self.data)\n stop = min(stop, len(self.data))\n if stop - start == 0:\n return type(self)(xnd.xnd([], type=self.data.type))\n\n elif isinstance(item, Iterable):\n if not is_array_like(item):\n item = np.array(item)\n if is_integer_dtype(item):\n return self.take(item)\n elif is_bool_dtype(item):\n indices = np.array(item)\n indices = np.argwhere(indices).flatten()\n return self.take(indices)\n else:\n raise IndexError(\n \"Only integers, slices and integer or boolean \\\n arrays are valid indices.\"\n )\n\n elif is_integer(item):\n if item < 0:\n item += len(self)\n if item >= len(self):\n return None\n else:\n\n return self.data[item]\n\n value = self.data[item]\n return type(self)(value)","def query_datacube(product,latitude,longitude,time,measurements):\r\n\r\n dc = datacube.Datacube(app=\"Query\")\r\n\r\n xarr = dc.load(\r\n product=product, \r\n longitude=longitude, \r\n latitude=latitude,\r\n # Time format YYYY-MM-DD\r\n time=time, \r\n measurements=measurements\r\n )\r\n\r\n return xarr","def slice(data, size):\n\treturn dice(data, size).T","def getxcslice(self,whichsol_,first_,last_,xc): # 3\n if not isinstance(whichsol_,soltype): raise TypeError(\"Argument whichsol has wrong type\")\n _copyback_xc = False\n if xc is None:\n xc_ = None\n else:\n try:\n xc_ = memoryview(xc)\n except TypeError:\n try:\n _tmparr_xc = array.array(\"d\",xc)\n except TypeError:\n raise TypeError(\"Argument xc has wrong type\")\n else:\n xc_ = memoryview(_tmparr_xc)\n _copyback_xc = True\n else:\n if xc_.format != \"d\":\n xc_ = memoryview(array.array(\"d\",xc))\n _copyback_xc = True\n if xc_ is not None and len(xc_) != ((last_) - (first_)):\n raise ValueError(\"Array argument xc has wrong length\")\n res = self.__obj.getxcslice(whichsol_,first_,last_,xc_)\n if res != 0:\n result,msg = self.__getlasterror(res)\n raise Error(rescode(res),msg)\n if _copyback_xc:\n xc[:] = _tmparr_xc","def transform_cube(self,\n cube: xr.Dataset,\n gm: GridMapping,\n cube_config: CubeConfig) -> TransformedCube:","def convert_slice(g, op, block):\n\n data = g.get_node(op.input(\"Input\")[0])\n dims = len(infer_shape(data))\n\n axes = op.attr(\"axes\")\n indices = _expr.const(axes, dtype=\"int64\")\n\n decrease_axis = op.attr(\"decrease_axis\")\n if isinstance(decrease_axis, int):\n decrease_axis = [decrease_axis]\n\n if op.input(\"StartsTensor\"):\n starts = g.get_node(op.input(\"StartsTensor\")[0])\n starts, infered = try_infer_value(starts, g.get_params())\n if infered:\n starts = starts.tolist()\n elif op.input(\"StartsTensorList\"):\n starts = []\n for start_index in op.input(\"StartsTensorList\"):\n start_index = g.get_node(start_index).astype(\"int64\")\n starts.append(start_index)\n starts = _op.concatenate(starts, axis=0)\n starts, infered = try_infer_value(starts, g.get_params())\n if infered:\n starts = starts.tolist()\n else:\n starts = op.attr(\"starts\")\n\n if len(axes) < dims:\n if isinstance(starts, _expr.Expr):\n starts = _op.scatter_elements(\n _op.const([0] * dims, dtype=infer_type(starts).checked_type.dtype),\n indices,\n starts,\n axis=0,\n )\n else:\n base = [0] * dims\n for i, axis in enumerate(axes):\n base[axis] = starts[i]\n starts = base\n\n if op.input(\"EndsTensor\"):\n ends = g.get_node(op.input(\"EndsTensor\")[0])\n ends, infered = try_infer_value(ends, g.get_params())\n if infered:\n ends = ends.tolist()\n elif op.input(\"EndsTensorList\"):\n ends = []\n for end_index in op.input(\"EndsTensorList\"):\n end_index = g.get_node(end_index).astype(\"int64\")\n ends.append(end_index)\n ends = _op.concatenate(ends, axis=0)\n ends, infered = try_infer_value(ends, g.get_params())\n if infered:\n ends = ends.tolist()\n else:\n ends = op.attr(\"ends\")\n\n if len(axes) < dims:\n if isinstance(ends, _expr.Expr):\n ends = _op.scatter_elements(\n _expr.const(\n np.array([np.iinfo(np.int32).max] * dims),\n dtype=infer_type(ends).checked_type.dtype,\n ),\n indices,\n ends,\n axis=0,\n )\n else:\n base = [np.iinfo(np.int32).max] * dims\n for i, axis in enumerate(axes):\n base[axis] = ends[i]\n ends = base\n\n strides = None\n if \"StridesTensor\" in op.input_names and op.input(\"StridesTensor\"):\n strides = g.get_node(op.input(\"StridesTensor\")[0])\n strides, infered = try_infer_value(strides, g.get_params())\n if infered:\n strides = strides.tolist()\n elif \"StridesTensorList\" in op.input_names and op.input(\"StridesTensorList\"):\n strides = []\n for strides_index in op.input(\"StridesTensorList\"):\n strides_index = g.get_node(strides_index).astype(\"int64\")\n strides.append(strides_index)\n strides = _op.concatenate(strides, axis=0)\n strides, infered = try_infer_value(strides, g.get_params())\n if infered:\n strides = strides.tolist()\n elif op.has_attr(\"strides\"):\n strides = op.attr(\"strides\")\n\n if len(axes) < dims:\n if isinstance(strides, _expr.Expr):\n strides = _op.scatter_elements(\n _expr.const(np.array([1] * dims), dtype=infer_type(strides).checked_type.dtype),\n indices,\n strides,\n axis=0,\n )\n elif strides:\n base = [1] * dims\n for i, axis in enumerate(axes):\n base[axis] = strides[i]\n strides = base\n if not strides:\n strides = _op.const([1] * dims, dtype=\"int64\")\n\n out = _op.strided_slice(data, begin=starts, end=ends, strides=strides)\n out_shape = infer_shape(out)\n if decrease_axis and len(out_shape) > 1:\n out = _op.squeeze(out, axis=decrease_axis)\n g.add_node(op.output(\"Out\")[0], out)","def generated_cube(self) -> Optional[xr.Dataset]:\n return self._generated_cube","def during(self, e):\r\n\r\n if not isinstance(e, Epochs):\r\n raise ValueError('e has to be of Epochs type')\r\n\r\n if e.data.ndim > 0:\r\n ## TODO: Implement slicing with 1-d Epochs array,\r\n ## resulting in (ragged/jagged) 2-d TimeArray\r\n raise NotImplementedError('e has to be a scalar Epoch')\r\n\r\n return self[self.slice_during(e)]","def take_slice(img_3D, view):\n input_type = isinstance(img_3D, np.ndarray)\n if input_type:\n img_3D = [img_3D]\n img_shape = img_3D[0].shape\n if view == \"sag\":\n slice_pos = np.random.randint(int(0.2 * img_shape[0]), int(0.8 * img_shape[0]))\n imgs_2D = [imgg_3D[slice_pos, :, :] for imgg_3D in img_3D]\n elif view == \"cor\":\n slice_pos = np.random.randint(int(0.2 * img_shape[1]), int(0.8 * img_shape[1]))\n imgs_2D = [imgg_3D[:, slice_pos, :] for imgg_3D in img_3D]\n else:\n slice_pos = np.random.randint(int(0.2 * img_shape[2]), int(0.8 * img_shape[2]))\n imgs_2D = [imgg_3D[:, :, slice_pos] for imgg_3D in img_3D]\n # img_2D = np.expand_dims(img_2D, 2)\n if input_type:\n return imgs_2D[0]\n return imgs_2D","def copy(self):\n new_cubies = [cubie.copy() for cubie in self.cubies]\n new_cube = Cube(new_cubies)\n return new_cube","def array_slice(items, a1, a2 = None):\n if (a2 is None):\n return items[a1:]\n else:\n return items[a1:a2]","def _get_slice(series, start, length):\n return [ int(s) for s in series[start:start+length] ]","def make_fwd_slice(shape, slices, reverse=None, cull_second=True):\n if reverse is None:\n reverse = []\n if not isinstance(shape, (list, tuple, np.ndarray)):\n shape = [shape]\n if not isinstance(slices, (list, tuple)):\n slices = [slices]\n if not isinstance(reverse, (list, tuple)):\n reverse = [reverse]\n\n newax_inds = [i for i, x in enumerate(slices) if x == np.newaxis]\n shape = list(shape)\n for i in newax_inds:\n shape.insert(i, 1)\n\n # ya know, lets just go through all the dimensions in shape\n # just to be safe and default to an empty slice / no reverse\n slices = slices + [slice(None)] * (len(shape) - len(slices))\n reverse = reverse + [False] * (len(slices) - len(reverse))\n\n first_slc = [slice(None)] * len(slices)\n second_slc = [slice(None, None, 1)] * len(first_slc)\n\n for i, slc, L, rev in izip(count(), slices, shape, reverse):\n if isinstance(slc, slice):\n step = slc.step if slc.step is not None else 1\n start = slc.start if slc.start is not None else 0\n stop = slc.stop if slc.stop is not None else L\n if start < 0:\n start += L\n if stop < 0:\n stop += L\n\n # sanity check the start/stop since we're gunna be playing\n # fast and loose with them\n if start < 0 or stop < 0:\n raise IndexError(\"((start = {0}) or (stop = {1})) < 0\"\n \"\".format(start, stop))\n if start > L or stop > L:\n raise IndexError(\"((start={0}) or (stop={1})) > (L={2})\"\n \"\".format(start, stop, L))\n\n # now do the math of flipping the slice if needed, these branches\n # change start, stop, and step so they can be used to create a new\n # slice below\n if rev:\n if step < 0:\n step = -step\n if slc.start is None:\n start = L - 1\n if slc.stop is None:\n start = L - 1 - start\n stop = None\n else:\n start, stop = L - 1 - start, L - 1 - stop\n else:\n start, stop = L - stop, L - start\n start += ((stop - 1 - start) % step)\n second_slc[i] = slice(None, None, -1)\n elif step < 0:\n step = -step\n if slc.start is None:\n start = L - 1\n\n if slc.stop is None:\n start, stop = 0, start + 1\n start = ((stop - 1 - start) % step)\n else:\n start, stop = stop + 1, start + 1\n start += ((stop - 1 - start) % step)\n\n second_slc[i] = slice(None, None, -1)\n\n # check that our slice is valid\n assert start is None or (0 <= start and start <= L), \\\n \"start (={0}) is outside range\".format(start)\n assert start is None or (0 <= start and start <= L), \\\n \"start (={0}) is outside range\".format(start)\n assert start is None or stop is None or start < stop, \\\n \"bad slice ordering: {0} !< {1}\".format(start, stop)\n assert step > 0\n slc = slice(start, stop, step)\n\n elif isinstance(slc, (int, np.integer)):\n second_slc[i] = None\n if rev:\n slc = (L - 1) - slc\n\n elif slc == np.newaxis:\n second_slc[i] = \"NEWAXIS\"\n\n first_slc[i] = slc\n\n first_slc = [s for s in first_slc if s is not np.newaxis]\n if cull_second:\n second_slc = [s for s in second_slc if s is not None]\n second_slc = [np.newaxis if s == \"NEWAXIS\" else s for s in second_slc]\n return first_slc, second_slc","def subsegment(self, start_time=None, end_time=None):\n start_time = 0.0 if start_time is None else start_time\n end_time = self.duration if end_time is None else end_time\n if start_time < 0.0:\n start_time = self.duration + start_time\n if end_time < 0.0:\n end_time = self.duration + end_time\n if start_time < 0.0:\n raise ValueError(\"The slice start position (%f s) is out of bounds.\" % start_time)\n if end_time < 0.0:\n raise ValueError(\"The slice end position (%f s) is out of bounds.\" % end_time)\n if start_time > end_time:\n raise ValueError(\n \"The slice start position (%f s) is later than the end position (%f s).\" % (start_time, end_time)\n )\n if end_time > self.duration:\n raise ValueError(\"The slice end position (%f s) is out of bounds (> %f s)\" % (end_time, self.duration))\n start_sample = int(round(start_time * self._sample_rate))\n end_sample = int(round(end_time * self._sample_rate))\n self._samples = self._samples[start_sample:end_sample]","def testSliceMiddleWithNegativeIndex(self):\n inst = WireData(b'0123456789')\n self.assertEqual(inst[-6:-3], WireData(b'456'))","def __setslice__(self, *args):\n return _itkLineSpatialObjectPointPython.vectoritkLineSpatialObjectPoint3___setslice__(self, *args)","def _slice(tensor, size, i):\n return tensor[:, i * size : (i + 1) * size]","def rotate_cube_left_list(liste):\n \n rotate_cube_right_list(liste)\n rotate_cube_right_list(liste)\n rotate_cube_right_list(liste)\n \n return liste","def test_getslice_setslice3(self):\n class C(object):\n def __init__(self):\n self.calls = []\n def __getitem__(self, index):\n self.calls.append('get')\n return 'Ok'\n def __setitem__(self, index, value):\n self.calls.append('set')\n def __delitem__(self, index):\n self.calls.append('delete')\n def __len__(self):\n self.calls.append('len')\n return 5\n\n a = C()\n self.assertEqual(a[3:5], 'Ok')\n self.assertEqual(a.calls, ['get'])\n\n a = C()\n a[3:5] = 'abc'\n self.assertEqual(a.calls, ['set'])\n\n a = C()\n del(a[3:5])\n self.assertEqual(a.calls, ['delete'])\n\n # but call length if it's negative (and we should only call length once)\n a = C()\n self.assertEqual(a[-1:5], 'Ok')\n self.assertEqual(a.calls, ['get'])\n\n a = C()\n self.assertEqual(a[1:-5], 'Ok')\n self.assertEqual(a.calls, ['get'])\n\n a = C()\n self.assertEqual(a[-1:-5], 'Ok')\n self.assertEqual(a.calls, ['get'])\n\n a = C()\n a[-1:5] = 'abc'\n self.assertEqual(a.calls, ['set'])\n\n a = C()\n a[1:-5] = 'abc'\n self.assertEqual(a.calls, ['set'])\n\n a = C()\n a[-1:-5] = 'abc'\n self.assertEqual(a.calls, ['set'])\n\n a = C()\n del(a[-1:5])\n self.assertEqual(a.calls, ['delete'])\n\n a = C()\n del(a[1:-5])\n self.assertEqual(a.calls, ['delete'])\n\n a = C()\n del(a[-1:-5])\n self.assertEqual(a.calls, ['delete'])","def test_3d_time():\n dic,data = ng.pipe.read(\"common_data/3d_pipe/data/test%03d.fid\")\n sdic,sdata = ng.pipe.read(\"common_data/3d_pipe/data/test001.fid\")\n assert data.shape == (128, 88, 1250)\n assert data.dtype == 'complex64'\n assert round(data[0,1,2].real,2) == -7.98\n assert round(data[0,1,2].imag,2) == 33.82\n assert round(data[10,22,5].real,2) == 15.71\n assert round(data[10,22,5].imag,2) == 15.1\n\n # and the first slice\n assert sdata.shape == (88, 1250)\n assert sdata.dtype == 'complex64'\n assert round(sdata[1,2].real,2) == -7.98\n assert round(sdata[1,2].imag,2) == 33.82\n assert round(sdata[22,5].real,2) == 22.65\n assert round(sdata[22,5].imag,2) == 13.65\n\n # slice/data matching\n assert_array_equal(data[0],sdata)\n\n write_readback_3D(dic,data)","def _read_index_slice(self, *args, **kwargs): # real signature unknown\n pass","def truth_dataframe_to_cube(df: DataFrame, training_dates: DatetimeIndex,) -> Cube:\n\n cubelist = CubeList()\n for adate in training_dates:\n time_df = df.loc[(df[\"time\"] == adate)]\n\n time_df = _preprocess_temporal_columns(time_df)\n\n if time_df.empty:\n continue\n\n # The following columns are expected to contain one unique value\n # per column.\n _unique_check(time_df, \"diagnostic\")\n\n if time_df[\"period\"].isna().all():\n time_bounds = None\n else:\n period = time_df[\"period\"].values[0]\n time_bounds = [adate - period, adate]\n\n time_coord = _define_time_coord(adate, time_bounds)\n height_coord = _define_height_coord(time_df[\"height\"].values[0])\n\n if \"station_id\" in time_df.columns:\n unique_site_id = time_df[\"station_id\"].values.astype(\"<U8\")\n unique_site_id_key = \"station_id\"\n else:\n unique_site_id = None\n unique_site_id_key = None\n\n cube = build_spotdata_cube(\n time_df[\"ob_value\"].astype(np.float32),\n time_df[\"cf_name\"].values[0],\n time_df[\"units\"].values[0],\n time_df[\"altitude\"].astype(np.float32),\n time_df[\"latitude\"].astype(np.float32),\n time_df[\"longitude\"].astype(np.float32),\n time_df[\"wmo_id\"].values.astype(\"U5\"),\n unique_site_id,\n unique_site_id_key,\n scalar_coords=[time_coord, height_coord],\n )\n cubelist.append(cube)\n\n if not cubelist:\n return\n\n return cubelist.merge_cube()","def __getitem__(self, item):\n if isinstance(item, slice):\n return list(itertools.islice(self._queue, item.start, item.stop, item.step))\n else:\n return self._queue[item]","def __getslice__(self, *args):\n return _itkLineSpatialObjectPointPython.vectoritkLineSpatialObjectPoint3___getslice__(self, *args)","def __delslice__(self, *args):\n return _itkLineSpatialObjectPointPython.vectoritkLineSpatialObjectPoint3___delslice__(self, *args)"],"string":"[\n \"def cube_like_tuple_item_to_sequence_items(item, common_axis, common_axis_lengths, n_cube_dims):\\n if not hasattr(item, \\\"__len__\\\"):\\n raise TypeError(\\\"item must be an iterable of slices and/or ints.\\\")\\n if len(item) <= common_axis:\\n raise ValueError(\\\"item must be include an entry for the common axis, \\\"\\n \\\"i.e. length of item must be > common_axis.\\\")\\n if not isinstance(item[common_axis], slice):\\n raise TypeError(\\\"This function should only be used when the common axis entry \\\"\\n \\\"of item is a slice object.\\\")\\n # Define default item for slicing the cubes\\n default_cube_item = list(item)\\n default_cube_item[common_axis] = slice(None)\\n\\n # Convert start and stop cube-like indices to sequence and cube indices.\\n if item[common_axis].start is None:\\n common_axis_start = 0\\n else:\\n common_axis_start = item[common_axis].start\\n if item[common_axis].stop is None:\\n common_axis_stop = sum(common_axis_lengths)\\n else:\\n common_axis_stop = item[common_axis].stop\\n item[common_axis] = slice(common_axis_start, common_axis_stop)\\n start_sequence_index, start_common_axis_index = \\\\\\n cube_like_index_to_sequence_and_common_axis_indices(\\n item[common_axis].start, common_axis, common_axis_lengths)\\n stop_sequence_index, stop_common_axis_index = \\\\\\n cube_like_index_to_sequence_and_common_axis_indices(\\n item[common_axis].stop - 1, common_axis, common_axis_lengths)\\n stop_common_axis_index += 1\\n # In the two lines above, the stop index was decremented by one in the\\n # calculation of the stop sequence axis to avoid ticking over to new NDCube if not needed.\\n # Once the correct sequence index was found,\\n # 1 was added back onto the corresponding common axis index.\\n\\n # Create iterable of SequenceItems to tell us how to slice each cube.\\n n_cubes_after_first = stop_sequence_index - start_sequence_index\\n # If only one cube included in slicing item, return iterable of single SequenceItem\\n if n_cubes_after_first == 0:\\n cube_item = deepcopy(default_cube_item)\\n cube_item[common_axis] = slice(start_common_axis_index, stop_common_axis_index)\\n sequence_items = [SequenceItem(start_sequence_index, tuple(cube_item))]\\n else:\\n if n_cubes_after_first > 1: # Condition > 1 to exclude final cube. We'll add it later.\\n sequence_items = [SequenceItem(i, tuple(default_cube_item))\\n for i in range(start_sequence_index + 1, stop_sequence_index)]\\n else:\\n sequence_items = []\\n # Insert final cube if there is one after the first.\\n if n_cubes_after_first > 0:\\n final_cube_item = deepcopy(default_cube_item)\\n final_cube_item[common_axis] = slice(0, stop_common_axis_index)\\n sequence_items.append(SequenceItem(stop_sequence_index, final_cube_item))\\n # Finally, add Sequence index for first cube.\\n first_cube_item = deepcopy(default_cube_item)\\n first_cube_item[common_axis] = slice(start_common_axis_index, None)\\n sequence_items.insert(0, SequenceItem(start_sequence_index, first_cube_item))\\n return sequence_items\",\n \"def slice_to_cube(self, axis, chunk, **kwargs):\\n if self.data.ndim == 3:\\n raise cu.CubeError(4, 'Can only slice a hypercube into a cube')\\n\\n item = [slice(None, None, None) for _ in range(4)]\\n if isinstance(chunk, tuple):\\n if cu.iter_isinstance(chunk, (u.Quantity, u.Quantity)):\\n pixel0 = cu.convert_point(chunk[0].value, chunk[0].unit,\\n self.axes_wcs, axis)\\n pixel1 = cu.convert_point(chunk[1].value, chunk[1].unit,\\n self.axes_wcs, axis)\\n item[axis] = slice(pixel0, pixel1, None)\\n elif cu.iter_isinstance((chunk, int, int)):\\n item[axis] = slice(chunk[0], chunk[1], None)\\n else:\\n raise cu.CubeError(5, \\\"Parameters must be of the same type\\\")\\n newdata = self.data[item].sum(axis)\\n else:\\n unit = chunk.unit if isinstance(chunk, u.Quantity) else None\\n pixel = cu.convert_point(chunk, unit, self.axes_wcs, axis)\\n item[axis] = pixel\\n newdata = self.data[item]\\n wcs_indices = [0, 1, 2, 3]\\n wcs_indices.remove(3 - axis)\\n newwcs = wu.reindex_wcs(self.axes_wcs, np.array(wcs_indices))\\n if axis == 2 or axis == 3:\\n newwcs = wu.add_celestial_axis(newwcs)\\n newwcs.was_augmented = True\\n cube = Cube(newdata, newwcs, meta=self.meta, **kwargs)\\n return cube\",\n \"def explode_along_axis(self, axis):\\n # If axis is -ve then calculate the axis from the length of the dimensions of one cube\\n if axis < 0:\\n axis = len(self.dimensions) + axis\\n # To store the resultant cube\\n result_cubes = []\\n # All slices are initially initialised as slice(None, None, None)\\n cube_slices = [slice(None, None, None)] * self.data.ndim\\n # Slicing the cube inside result_cube\\n for i in range(self.data.shape[axis]):\\n # Setting the slice value to the index so that the slices are done correctly.\\n cube_slices[axis] = i\\n # Set to None the metadata of sliced cubes.\\n item = tuple(cube_slices)\\n sliced_cube = self[item]\\n sliced_cube.meta = None\\n # Appending the sliced cubes in the result_cube list\\n result_cubes.append(sliced_cube)\\n # Creating a new NDCubeSequence with the result_cubes and common axis as axis\\n return NDCubeSequence(result_cubes, meta=self.meta)\",\n \"def test_get_first_cube(self):\\n self.assertIs(self.cube_1,\\n self.fix.get_cube_from_list(self.cubes, \\\"cube1\\\"))\",\n \"def slice_during(self, e):\\r\\n\\r\\n if not isinstance(e, Epochs):\\r\\n raise ValueError('e has to be of Epochs type')\\r\\n\\r\\n if e.data.ndim > 0:\\r\\n raise NotImplementedError('e has to be a scalar Epoch')\\r\\n\\r\\n if self.ndim != 1:\\r\\n e_s = 'slicing only implemented for 1-d TimeArrays'\\r\\n return NotImplementedError(e_s)\\r\\n i_start = self.index_at(e.start)\\r\\n i_stop = self.index_at(e.stop)\\r\\n if e.start > self[i_start]: # make sure self[i_start] is in epoch e\\r\\n i_start += 1\\r\\n if e.stop > self[i_stop]: # make sure to include self[i_stop]\\r\\n i_stop += 1\\r\\n\\r\\n return slice(i_start, i_stop)\",\n \"def test_slicing_containers(self):\\n\\n pattern = midi.Pattern()\\n pattern.extend([midi.Track()] * 5)\\n result1 = pattern[1]\\n result2 = pattern[1:5]\\n result3 = pattern[::2]\\n\\n track = midi.Track()\\n track.extend([midi.Event()] * 5)\\n result1 = track[1]\\n result2 = track[1:5]\\n result3 = track[::2]\",\n \"def slice_during(self, e):\\r\\n\\r\\n if not isinstance(e, Epochs):\\r\\n raise ValueError('e has to be of Epochs type')\\r\\n\\r\\n if e.data.ndim > 0:\\r\\n raise NotImplementedError('e has to be a scalar Epoch')\\r\\n\\r\\n if self.ndim != 1:\\r\\n e_s = 'slicing only implemented for 1-d TimeArrays'\\r\\n return NotImplementedError(e_s)\\r\\n\\r\\n # These two should be called with modes, such that they catch the right\\r\\n # slice\\r\\n start = self.index_at(e.start, mode='after')\\r\\n stop = self.index_at(e.stop, mode='before')\\r\\n\\r\\n # If *either* the start or stop index object comes back as the empty\\r\\n # array, then it means the condition is not satisfied, we return the\\r\\n # slice that does [:0], i.e., always slices to nothing.\\r\\n if start.shape == (0,) or stop.shape == (0,):\\r\\n return slice(0)\\r\\n\\r\\n # Now, we know the start/stop are not empty arrays, but they can be\\r\\n # either scalars or arrays.\\r\\n i_start = start if np.isscalar(start) else start.max()\\r\\n i_stop = stop if np.isscalar(stop) else stop.min()\\r\\n\\r\\n if e.start > self[i_start]: # make sure self[i_start] is in epoch e\\r\\n i_start += 1\\r\\n if e.stop > self[i_stop]: # make sure to include self[i_stop]\\r\\n i_stop += 1\\r\\n\\r\\n return slice(i_start, i_stop)\",\n \"def test_getslice1(self):\\n class C(list):\\n def __getitem__(self, index):\\n return (index.start, index.stop)\\n\\n a = C()\\n self.assertEqual(a[32:197], (32,197))\",\n \"def _get_cube(datasets, short_name):\\n datasets = select_metadata(datasets, short_name=short_name)\\n if len(datasets) != 1:\\n raise ValueError(\\n f\\\"Expected exactly one dataset with short_name '{short_name}', \\\"\\n f\\\"got {len(datasets):d}:\\\\n{datasets}\\\")\\n return iris.load_cube(datasets[0]['filename'],\\n NameConstraint(var_name=short_name))\",\n \"def cqt_slices(record, t_len, shuffle=True, auto_restart=True,\\n add_noise=True, random_seed=None,\\n slice_logger=None):\\n def cqt_slicer(cqt, idx, counter, t_len):\\n obs = utils.slice_ndarray(cqt, idx[counter], length=t_len, axis=1)\\n return obs[np.newaxis, ...]\\n\\n for cqt_slice in base_slicer(\\n record, t_len, cqt_slicer,\\n shuffle=shuffle, auto_restart=auto_restart,\\n add_noise=add_noise, random_seed=random_seed,\\n npz_data_key='cqt',\\n slice_logger=slice_logger):\\n yield cqt_slice\",\n \"def test_get_second_cube(self):\\n self.assertIs(self.cube_2,\\n self.fix.get_cube_from_list(self.cubes, \\\"cube2\\\"))\",\n \"def slicer(seq, start=None, stop=None, step=None):\\n return seq[start:stop:step]\",\n \"def simple_slice():\\n examples = [\\n benchmark.Example(\\n inputs=[\\n [[12, 34, 56, 78], [-1, -2, -3, -4]],\\n -1,\\n ],\\n output=[[34, 56], [-2, -3]],\\n ),\\n ]\\n constants = []\\n description = 'Slice a tensor'\\n target_program = 'in1[:, 1:in2]'\\n source = 'handwritten task'\\n return benchmark.Benchmark(examples=examples,\\n constants=constants,\\n description=description,\\n target_program=target_program,\\n source=source,\\n name='simple_slice')\",\n \"def getCube(unique_name):\",\n \"def split_cube(cube):\\n # Split first axis\\n ax0 = cube[0]\\n ax0 -= 0.5\\n ax0[ax0 < 0] = ax0[ax0 < 0] * 2 - 1\\n ax0[ax0 > 0] = ax0[ax0 > 0] * 2\\n if cube.shape[0] > 1:\\n # Scale other axes to be in a useful range for floor divide\\n cube[1:] = cube[1:] * 4\\n # Define the shifts\\n displace = cube[1:].floor() % 2\\n shift = displace[0]\\n # We need an algebra that satisies: 1 * 0 = 0, 1 * 1 = 1, 0 * 1 = 0, 0 * 0 = 1\\n # This is achieved with * = (==)\\n for ax in displace[1:]:\\n shift = shift == ax\\n ax0 += shift\\n cube[1:] -= 2\\n cube *= 2\\n return cube.t()\",\n \"def convert_to_spectral_cube(self):\\n if self.data.ndim == 4:\\n raise cu.CubeError(4, \\\"Too many dimensions: Can only convert a \\\" +\\n \\\"3D cube. Slice the cube before converting\\\")\\n if 'WAVE' not in self.axes_wcs.wcs.ctype:\\n raise cu.CubeError(2, 'Spectral axis needed to create a spectrum')\\n axis = 0 if self.axes_wcs.wcs.ctype[-1] == 'WAVE' else 1\\n coordaxes = [1, 2] if axis == 0 else [0, 2] # Non-spectral axes\\n newwcs = wu.reindex_wcs(self.axes_wcs, np.arary(coordaxes))\\n time_or_x_size = self.data.shape[coordaxes[1]]\\n y_size = self.data.shape[coordaxes[0]]\\n spectra = np.empty((time_or_x_size, y_size), dtype=Spectrum)\\n for i in range(time_or_x_size):\\n for j in range(y_size):\\n spectra[i][j] = self.slice_to_spectrum(i, j)\\n return SpectralCube(spectra, newwcs, self.meta)\",\n \"def getcslice(self,first_,last_,c): # 3\\n _copyback_c = False\\n if c is None:\\n c_ = None\\n else:\\n try:\\n c_ = memoryview(c)\\n except TypeError:\\n try:\\n _tmparr_c = array.array(\\\"d\\\",c)\\n except TypeError:\\n raise TypeError(\\\"Argument c has wrong type\\\")\\n else:\\n c_ = memoryview(_tmparr_c)\\n _copyback_c = True\\n else:\\n if c_.format != \\\"d\\\":\\n c_ = memoryview(array.array(\\\"d\\\",c))\\n _copyback_c = True\\n if c_ is not None and len(c_) != ((last_) - (first_)):\\n raise ValueError(\\\"Array argument c has wrong length\\\")\\n res = self.__obj.getcslice(first_,last_,c_)\\n if res != 0:\\n result,msg = self.__getlasterror(res)\\n raise Error(rescode(res),msg)\\n if _copyback_c:\\n c[:] = _tmparr_c\",\n \"def get_slice(self, limit, offset):\\r\\n if limit == 0:\\r\\n return self.objects[offset:]\\r\\n\\r\\n return self.objects[offset:offset + limit]\",\n \"def get_slice(self, n):\\n if n == 0:\\n return slice(self._lo_atom, self._lo_atom + self._n_atoms)\\n raise IndexError(f\\\"{n} is invalid for a 1 dimension Slice \\\")\",\n \"def __getitem__( self, index ):\\n \\n # check dimensions - this rules out the ellisis (...) for the moment\\n if len( index ) != 3:\\n raise ValueError(\\\"This is a three-dimensional object, please index accordingly.\\\")\\n\\n # get involved file numbers and steps\\n # if index[0] is a single number (not iterable, not a slice), make a list of it\\n if not hasattr( index[0], '__iter__') and not isinstance( index[0], slice ):\\n valid_steps = self._valid_steps[ [index[0]], :2 ]\\n else:\\n valid_steps = self._valid_steps[ index[0], :2 ]\\n \\n # if image should be cropped make sure that slices stay slices (is about 30% faster)\\n if self._cropped: \\n if isinstance( index[1], slice ):\\n a = self._ymin if index[1].start is None else index[1].start+self._ymin\\n b = self._ymax if index[1].stop is None else index[1].stop+self._ymin \\n internal_index1 = slice( a, b, index[1].step )\\n \\n else:\\n internal_index1 = np.arange( self._ymin, self._ymax )[ index[1] ]\\n \\n if isinstance( index[2], slice ):\\n a = self._xmin if index[2].start is None else index[2].start+self._xmin\\n b = self._xmax if index[2].stop is None else index[2].stop+self._xmin \\n internal_index2 = slice( a, b, index[2].step )\\n \\n else:\\n internal_index2 = np.arange( self._xmin, self._xmax )[ index[2] ]\\n\\n else:\\n internal_index1 = index[1]\\n internal_index2 = index[2]\\n\\n # get all data slices and concatenate them (always use data interface here, regardless of whether memory mapping is used or not)\\n slices = []\\n for file_no in np.unique( valid_steps[:,0] ):\\n file = ir.file_hub.open( self._files[file_no] )\\n slices.append( file[ self._selected_ext ].data[ valid_steps[ valid_steps[:,0] == file_no, 1 ], internal_index1, internal_index2 ] )\\n slices = np.vstack( slices )\\n\\n # remove first dimension if there is only one slice\\n if slices.shape[0] == 1 and slices.ndim == 3:\\n slices = slices[0,:,:]\\n \\n return slices\",\n \"def __getitem__(self, index):\\n return (index, self.data_cube[0, index, :])\",\n \"def SliceView(sequence, start=None, stop=None, step=1):\\n start, stop, step = slice(start, stop, step).indices(len(sequence))\\n for i in range(start, stop, step):\\n yield sequence[i]\",\n \"def cube_like_index_to_sequence_and_common_axis_indices(cube_like_index, common_axis,\\n common_axis_lengths):\\n cumul_lengths = np.cumsum(common_axis_lengths)\\n sequence_index = np.arange(len(cumul_lengths))[cumul_lengths > cube_like_index][0]\\n if sequence_index == 0:\\n common_axis_index = cube_like_index\\n else:\\n common_axis_index = cube_like_index - cumul_lengths[sequence_index - 1]\\n return sequence_index, common_axis_index\",\n \"def _collapse_scalar_dimensions(cube: Cube) -> Cube:\\n coords_to_collapse = []\\n for coord in cube.coords(dim_coords=True):\\n if len(coord.points) == 1 and \\\"realization\\\" not in coord.name():\\n coords_to_collapse.append(coord)\\n for coord in coords_to_collapse:\\n cube = next(cube.slices_over(coord))\\n return cube\",\n \"def __getslice__(self, start, stop):\\n return self.__getitem__(slice(start, stop, None))\",\n \"def collapse_time(cube, ntimes, timestep):\\n\\n if timestep == None:\\n print('Averaging over the %s time points' %(str(ntimes)))\\n new_cube = cube.collapsed('time', iris.analysis.MEAN)\\n else:\\n assert new_cube.coords()[0] == 'time'\\n new_cube = cube[timestep, :, :]\\n\\n return new_cube\",\n \"def _simslice(simulation, clump=None):\\n if clump is None:\\n # No slicing required\\n s = simulation\\n \\n else:\\n # Slice according to clump\\n s = simulation[clump]\\n \\n if not isinstance(s, sim):\\n # Cast s as a sim object\\n dummy = sim(1)\\n dummy[0] = s\\n s = dummy\\n \\n return s\",\n \"def select_time(new_cube, lower, upper):\\n\\n sliced_cube = new_cube.extract(iris.Constraint(year=lambda y: lower<=y<=upper))\\n\\n return sliced_cube\",\n \"def slice(self,x=None,y=None,z=None,c=None):\\n\\n if x is None:\\n x = slice(0,self._metaData[\\\"size_x\\\"])\\n if y is None:\\n y = slice(0,self._metaData[\\\"size_y\\\"])\\n if z is None:\\n z = slice(0,self._metaData[\\\"size_z\\\"])\\n if c is None:\\n c = slice(0,self._metaData[\\\"size_c\\\"])\\n\\n img_crop=MicImage()\\n img_crop._metaData={**self._metaData}\\n img_crop.xml=self.xml\\n\\n\\n img_crop.pixels= copy.deepcopy(self.pixels[z,x,y,c])\\n \\n if img_crop.pixels.shape[0]==1:\\n img_crop.pixels=np.squeeze(img_crop.pixels)\\n img_crop.sumprj=np.squeeze(img_crop.pixels)\\n img_crop.maxprj=np.squeeze(img_crop.pixels)\\n else:\\n img_crop.sumprj=(np.sum(img_crop.pixels,axis=0))\\n img_crop.maxprj=(np.amax(img_crop.pixels,axis=0))\\n img_crop.meanprj=(np.mean(img_crop.pixels,axis=0))\\n\\n img_crop._metaData.update({\\\"size_z\\\": img_crop.pixels.shape[0]})\\n img_crop._metaData.update({\\\"size_x\\\": img_crop.pixels.shape[1]})\\n img_crop._metaData.update({\\\"size_y\\\": img_crop.pixels.shape[2]})\\n img_crop._metaData.update({\\\"size_c\\\": img_crop.pixels.shape[3]})\\n\\n return img_crop\",\n \"def __init__(self, cube_size, time_range):\\n\\n # cubesize is in z,y,x for interactions with tile/image data\\n self.zdim, self.ydim, self.xdim = self.cubesize = [cube_size[2], cube_size[1], cube_size[0]]\\n self.time_range = time_range\\n self._newcube = False\",\n \"def test05(self):\\n a = np.arange(1e3)\\n b = bcolz.carray(a, chunklen=10, rootdir=self.rootdir)\\n sl = slice(None, None, -3)\\n # print \\\"b[sl]->\\\", `b[sl]`\\n self.assertRaises(NotImplementedError, b.__getitem__, sl)\",\n \"def subcubes_from_ds9(cube, region_file='../nro_maps/AllShells.reg', pad_factor=1., shape='exact'):\\n from spectral_cube import SpectralCube\\n import pyregion\\n\\n try:\\n #If cube is a str filename, read a SpectralCube.\\n cube = SpectralCube.read(cube)\\n except ValueError:\\n pass\\n\\n if shape == 'square':\\n import astropy.units as u\\n subcube_list = []\\n region_list = pyregion.open(region_file)\\n for region in region_list:\\n half_width = region.coord_list[2] * pad_factor * u.deg\\n ra_center = region.coord_list[0] * u.deg\\n dec_center = region.coord_list[1] * u.deg\\n ra_range = [ra_center - half_width, ra_center + half_width]\\n dec_range = [dec_center - half_width, dec_center + half_width]\\n #print(ra_range, dec_range)\\n subcube_list.append(cube.subcube(ra_range[1], ra_range[0], dec_range[0], dec_range[1]))\\n if shape == 'exact':\\n region_list = pyregion.open(region_file)\\n subcube_list = []\\n for region in region_list:\\n \\n if pad_factor != 1.:\\n new_string = '{};{}({},{},{}\\\")'.format(region.coord_format, region.name,\\n region.coord_list[0], region.coord_list[1],\\n region.coord_list[2]*3600.*pad_factor)\\n region = pyregion.parse(new_string)[0]\\n \\n subcube_list.append(cube.subcube_from_ds9region(pyregion.ShapeList([region])))\\n if len(subcube_list) == 1:\\n return subcube_list[0]\\n else:\\n return subcube_list\",\n \"def _slice(self, start, stop, step=None):\\n\\n slices = [slice(None)] * self.data.ndim\\n slices[self.axis] = slice(start, stop, step)\\n return tuple(slices)\",\n \"def getcslice(self,first_,last_,c_):\\n _c_minlength = ((last_) - (first_))\\n if ((last_) - (first_)) > 0 and c_ is not None and len(c_) != ((last_) - (first_)):\\n raise ValueError(\\\"Array argument c is not long enough: Is %d, expected %d\\\" % (len(c_),((last_) - (first_))))\\n if isinstance(c_,numpy.ndarray) and not c_.flags.writeable:\\n raise ValueError(\\\"Argument c must be writable\\\")\\n if isinstance(c_, numpy.ndarray) and c_.dtype is numpy.dtype(numpy.float64) and c_.flags.contiguous:\\n _c_copyarray = False\\n _c_tmp = ctypes.cast(c_.ctypes._as_parameter_,ctypes.POINTER(ctypes.c_double))\\n elif c_ is not None:\\n _c_copyarray = True\\n _c_np_tmp = numpy.zeros(len(c_),numpy.dtype(numpy.float64))\\n _c_np_tmp[:] = c_\\n assert _c_np_tmp.flags.contiguous\\n _c_tmp = ctypes.cast(_c_np_tmp.ctypes._as_parameter_,ctypes.POINTER(ctypes.c_double))\\n else:\\n _c_copyarray = False\\n _c_tmp = None\\n \\n res = __library__.MSK_XX_getcslice(self.__nativep,first_,last_,_c_tmp)\\n if res != 0:\\n _,msg = self.__getlasterror(res)\\n raise Error(rescode(res),msg)\\n if _c_copyarray:\\n c_[:] = _c_np_tmp\",\n \"def slice(tensor):\\n out = tensor[:, 444:524, :]\\n return out\",\n \"def __getitem__(self, idx):\\n sliced_timeseries = [None] * self.ch_amount\\n return_instant = False\\n if not self.trigger_idx:\\n self.trigger_idx = 0\\n\\n trigger_length = len(self.timeseries[self.trigger_idx])\\n\\n # If idx is an integer, return an \\\"instantaneous slice\\\" and initialise slice\\n if isinstance(idx, int):\\n return_instant = True\\n\\n # If idx is a negative integer, take the idx element from the end.\\n if idx < 0:\\n idx = trigger_length + idx\\n\\n idx = slice(idx, idx + 1)\\n\\n # If idx.start or stop are None, make them 0 or trigger length.\\n if idx.start is None:\\n idx = slice(0, idx.stop)\\n if idx.stop is None:\\n idx = slice(idx.start, trigger_length)\\n\\n # Check that the indexes are not out of bounds\\n if idx.start >= trigger_length or idx.stop > trigger_length:\\n raise IndexError(\\n f\\\"Slice ({idx.start}, {idx.stop}) is out of \\\"\\n f\\\"bounds for channel {self.trigger_idx} \\\"\\n f\\\"with size {trigger_length}\\\"\\n )\\n\\n # Operate on each channel on its own\\n for n, channel in enumerate(self.timeseries):\\n idx_dict = {\\\"start\\\": idx.start, \\\"stop\\\": idx.stop, \\\"step\\\": idx.step}\\n # Adapt the slicing indexes to the right frequency\\n for i in [\\\"start\\\", \\\"stop\\\", \\\"step\\\"]:\\n if idx_dict[i]:\\n idx_dict[i] = int(\\n np.floor(self.freq[n] / self.freq[self.trigger_idx] * idx_dict[i])\\n )\\n\\n # Correct the slicing stop if necessary\\n if idx_dict[\\\"start\\\"] == idx_dict[\\\"stop\\\"] or return_instant:\\n idx_dict[\\\"stop\\\"] = idx_dict[\\\"start\\\"] + 1\\n elif trigger_length == idx.stop:\\n idx_dict[\\\"stop\\\"] = len(channel)\\n\\n new_idx = slice(idx_dict[\\\"start\\\"], idx_dict[\\\"stop\\\"], idx_dict[\\\"step\\\"])\\n sliced_timeseries[n] = channel[new_idx]\\n\\n sliced_bp = BlueprintInput(\\n sliced_timeseries,\\n self.freq,\\n self.ch_name,\\n self.units,\\n self.trigger_idx,\\n self.num_timepoints_found,\\n self.thr,\\n self.time_offset,\\n )\\n\\n sliced_bp._time_resampled_to_trigger = self._time_resampled_to_trigger\\n return sliced_bp\",\n \"def test_timeseries_indexing():\\n s = channel.Slice(channel.TimeSeries([14, 15, 16, 17], [4, 5, 6, 7]))\\n\\n np.testing.assert_equal(s[0:5].data, [14])\\n np.testing.assert_equal(s[0:5].timestamps, [4])\\n np.testing.assert_equal(s[4:5].data, [14])\\n np.testing.assert_equal(s[4:5].timestamps, [4])\\n np.testing.assert_equal(s[4:6].data, [14, 15])\\n np.testing.assert_equal(s[4:6].timestamps, [4, 5])\\n np.testing.assert_equal(s[4:10].data, [14, 15, 16, 17])\\n np.testing.assert_equal(s[4:10].timestamps, [4, 5, 6, 7])\\n\\n with pytest.raises(IndexError) as exc:\\n assert s[1]\\n assert str(exc.value) == \\\"Scalar indexing is not supported, only slicing\\\"\\n with pytest.raises(IndexError) as exc:\\n assert s[1:2:3]\\n assert str(exc.value) == \\\"Slice steps are not supported\\\"\\n\\n s = channel.Slice(channel.TimeSeries([], []))\\n assert len(s[1:2].data) == 0\\n assert len(s[1:2].timestamps) == 0\",\n \"def wcqt_slices(record, t_len, shuffle=True, auto_restart=True, add_noise=True,\\n p_len=54, p_stride=36, random_seed=None, slice_logger=None):\\n def wcqt_slicer(cqt, idx, counter, t_len):\\n # Grab the obs\\n obs = utils.slice_ndarray(cqt, idx[counter], length=t_len, axis=1)\\n # Convert it to WCQT\\n wcqt = utils.fold_array(obs[0], length=p_len, stride=p_stride)\\n # Fix the shape.s\\n return wcqt[np.newaxis, ...]\\n\\n for wcqt_slice in base_slicer(\\n record, t_len, wcqt_slicer,\\n shuffle=shuffle, auto_restart=auto_restart,\\n add_noise=add_noise, random_seed=random_seed,\\n npz_data_key='cqt',\\n slice_logger=slice_logger):\\n yield wcqt_slice\",\n \"def plot_x_slice(self, offset, **kwargs):\\n cumul_cube_lengths = np.cumsum(np.array([c.shape[self.common_axis]\\n for c in self.data]))\\n sequence_index, cube_index = cu._convert_cube_like_index_to_sequence_indices(\\n offset, cumul_cube_lengths)\\n plot = self[sequence_index].plot_x_slice(cube_index, **kwargs)\\n return plot\",\n \"def stack_cuboids(c_list, axis, domain=None, axis_pos='first'):\\n assert isinstance(axis, str)\\n size = len(c_list)\\n cub0 = c_list[0]\\n axes = cub0.axes_names\\n # print 'axes:', axes\\n sh = (size,) + cub0.data.shape\\n stackedData = np.zeros(sh, cub0.data.dtype)\\n newDomains = cub0.axes_domains.copy()\\n if domain is not None:\\n newDomains[axis] = domain\\n targetCub = xndarray(stackedData,\\n axes_names=[axis] + cub0.axes_names,\\n axes_domains=newDomains, value_label=cub0.value_label)\\n # print 'c_list', c_list, c_list[0], c_list[1]\\n for i, cuboid in enumerate(c_list):\\n if debug:\\n print 'targetCub.data[i] :', targetCub.data[i].shape\\n if debug:\\n print 'cuboid', cuboid.descrip()\\n # print 'number:', i\\n # print 'cuboid.axes:', cuboid.axes_names\\n if axes != cuboid.axes_names:\\n raise Exception('%dth cuboid in list does not match other cuboids'\\n 'found axes: %s, should be: %s'\\n % (i, str(cuboid.axes_names), str(axes)))\\n\\n # TODO: better use numpy stacking functions (faster)\\n targetCub.data[i] = cuboid.data\\n\\n if axis_pos == 'last':\\n targetCub.roll(axis)\\n\\n return targetCub\",\n \"def relay_array_getitem(c, a, start, stop, strides):\\n assert start.is_constant(tuple)\\n assert stop.is_constant(tuple)\\n assert strides.is_constant(tuple)\\n return relay.op.transform.strided_slice(c.ref(a), start.value, stop.value,\\n strides.value)\",\n \"def testSliceMiddleWithMixedIndex(self):\\n inst = WireData(b'0123456789')\\n self.assertEqual(inst[-8:3], WireData(b'2'))\\n self.assertEqual(inst[5:-3], WireData(b'56'))\",\n \"def _slice_at_axis(sl, axis):\\n return (slice(None),) * axis + (sl,) + (...,)\",\n \"def __getitem__(self, item):\\n return self.cube[item]\",\n \"def __getitem__(self, idx):\\n if idx >= len(self):\\n raise StopIteration\\n\\n _, timesteps, height, width = self.data.shape\\n\\n # If time=True, return an entire time slice,\\n # otherwise return a single time step\\n t = slice(None)\\n if not self.time:\\n t = idx % timesteps\\n idx = idx // timesteps\\n\\n if self.subset == 'train':\\n # Right quadrants\\n # Return a random subset\\n xl = width // 2\\n xr = width - self.size\\n x = random.randint(xl, xr)\\n\\n yu = 0\\n yl = height - self.size\\n y = random.randint(yu, yl)\\n elif self.subset == 'val':\\n # Bottom left quadrant\\n # Convert the index to a (row, col) location\\n row = idx // (width // 2 // self.size)\\n col = idx % (width // 2 // self.size)\\n\\n # Find the exact coordinates in the array\\n y = row * self.size + (height // 2)\\n x = col * self.size\\n elif self.subset == 'test':\\n # Top left quadrant\\n # Convert the index to a (row, col) location\\n row = idx // (width // 2 // self.size)\\n col = idx % (width // 2 // self.size)\\n\\n # Find the exact coordinates in the array\\n y = row * self.size\\n x = col * self.size\\n else:\\n # All quadrants\\n # Convert the index to a (row, col) location\\n row = idx // (width // self.size)\\n col = idx % (width // self.size)\\n\\n # Find the exact coordinates in the array\\n y = row * self.size\\n x = col * self.size\\n\\n data = self.data[:, t, y:y + self.size, x:x + self.size]\\n target = self.segmentation[y:y + self.size, x:x + self.size]\\n\\n # Apply any requested transforms\\n if self.transform:\\n data = self.transform(data)\\n\\n if self.target_transform:\\n target = self.target_transform(target)\\n\\n if isinstance(t, slice):\\n t = np.zeros_like(y) - 1\\n\\n return data, target, t, y, x\",\n \"def cube_subsample(array, n, mode=\\\"mean\\\", parallactic=None, verbose=False):\\n if not array.ndim == 3:\\n raise TypeError('The input array is not a cube or 3d array.')\\n m = int(array.shape[0]/n) \\n y = array.shape[1]\\n x = array.shape[2]\\n arr = np.empty([m, y, x]) \\n if mode == 'median':\\n for i in xrange(m): \\n arr[i, :, :] = np.median(array[:n, :, :], axis=0) # first new frame, mean of first n frames\\n if i >= 1:\\n arr[i, :, :] = np.median(array[n*i:n*i+n, :, :], axis=0) \\n if mode=='mean':\\n for i in xrange(m): \\n arr[i, :, :] = np.mean(array[:n, :, :], axis=0) \\n if i >= 1:\\n arr[i, :, :] = np.mean(array[n*i:n*i+n, :, :], axis=0)\\n else: \\n raise ValueError('Mode should be either Mean or Median.')\\n if parallactic is not None:\\n angles = parallactic.byteswap().newbyteorder()\\n angles = pn.rolling_mean(angles, n, center=True)\\n angles = pn.DataFrame(angles)\\n angles = pn.DataFrame.fillna(angles, method='pad')\\n angles = pn.DataFrame.fillna(angles, method='bfill')\\n angles = np.array(angles)\\n angles = angles[0:m*n:n]\\n if array.shape[0]/n % 1 != 0:\\n print '\\\\nInitial # of frames and window are not multiples. A few frames were dropped.' \\n if verbose:\\n print \\\"Done {:} over FITS-Cube with window n = {:}\\\".format(mode ,n) \\n if parallactic is not None:\\n return arr, angles\\n else:\\n return arr\",\n \"def getSlice(properties=None, **kw):\",\n \"def __setslice__(self, *args):\\n return _itkSurfaceSpatialObjectPointPython.vectoritkSurfaceSpatialObjectPoint3___setslice__(self, *args)\",\n \"def chunked_collapse_by_time(cube, collapse_dims, agg_method, weights=None):\\n\\n assert agg_method in [iris.analysis.SUM, iris.analysis.MEAN]\\n\\n chunk_list = iris.cube.CubeList([])\\n coord_names = [coord.name() for coord in cube.dim_coords]\\n start_indexes, step = get_chunks(cube.shape, coord_names, chunk=True)\\n for index in start_indexes:\\n if type(weights) in [numpy.ndarray, numpy.ma.core.MaskedArray]:\\n chunk = cube[index:index+step, ...].collapsed(collapse_dims, agg_method, weights=weights[index:index+step, ...])\\n else:\\n chunk = cube[index:index+step, ...].collapsed(collapse_dims, agg_method)\\n chunk_list.append(chunk)\\n\\n collapsed_cube = chunk_list.concatenate()[0]\\n\\n return collapsed_cube\",\n \"def get1DSlice( self, slices: list ):\\n assert(len(slices)==self._nDims-1)\\n slices.append(slice(self._nGlobalCoords[self._layout.dims_order[-1]]))\\n return self._f[tuple(slices)]\",\n \"def zeros(self):\\n super(TimeCube, self).zeros()\\n self.data = np.zeros([self.time_range[1]-self.time_range[0]]+self.cubesize, np.uint8)\",\n \"def slice_timeseries(n_slices,dataset):\\n\\n n,l=np.shape(dataset)\\n\\n X = np.reshape(dataset,(n*n_slices,l//n_slices))\\n\\n print('sliced data shape (nr. of slices, slice length):',np.shape(X))\\n print('#####################################')\\n \\n return X\",\n \"def Cube(center=(0.0, 0.0, 0.0), x_length=1.0, y_length=1.0, z_length=1.0, bounds=None, clean=True):\\n src = _vtk.vtkCubeSource()\\n if bounds is not None:\\n if np.array(bounds).size != 6:\\n raise TypeError(\\n 'Bounds must be given as length 6 tuple: (xMin, xMax, yMin, yMax, zMin, zMax)'\\n )\\n src.SetBounds(bounds)\\n else:\\n src.SetCenter(center)\\n src.SetXLength(x_length)\\n src.SetYLength(y_length)\\n src.SetZLength(z_length)\\n src.Update()\\n cube = wrap(src.GetOutput())\\n\\n # add face index data for compatibility with PlatonicSolid\\n # but make it inactive for backwards compatibility\\n cube.cell_data.set_array([1, 4, 0, 3, 5, 2], 'FaceIndex')\\n\\n # clean duplicate points\\n if clean:\\n cube.clean(inplace=True)\\n\\n return cube\",\n \"def __getslice__( self, *args):\\n return array.array.__getslice__(self, *args).tostring()\",\n \"def init_reshape(cube, nside):\\n half_nside = 2**nside / 2\\n \\n dim1 = cube.shape[1]/2 - half_nside\\n dim2 = cube.shape[1]/2 + half_nside\\n dim3 = cube.shape[2]/2 - half_nside\\n dim4 = cube.shape[2]/2 + half_nside\\n\\n return cube[:, dim1:dim2, dim3:dim4]\",\n \"def __delslice__(self, *args):\\n return _itkSurfaceSpatialObjectPointPython.vectoritkSurfaceSpatialObjectPoint3___delslice__(self, *args)\",\n \"def test_slice_other_dimension(self):\\n for i, shape in enumerate([(3, 0), (1, 2, 0), (2, 0, 1)]):\\n dset = self.f.create_dataset('x%d'%i, shape, dtype=int, maxshape=(None,)*len(shape))\\n self.assertEqual(dset.shape, shape)\\n out = dset[:1]\\n self.assertIsInstance(out, np.ndarray)\\n self.assertEqual(out.shape, (1,)+shape[1:])\",\n \"def test_slice_zero_length_dimension(self):\\n for i, shape in enumerate([(0,), (0, 3), (0, 2, 1)]):\\n dset = self.f.create_dataset('x%d'%i, shape, dtype=int, maxshape=(None,)*len(shape))\\n self.assertEqual(dset.shape, shape)\\n out = dset[...]\\n self.assertIsInstance(out, np.ndarray)\\n self.assertEqual(out.shape, shape)\\n out = dset[:]\\n self.assertIsInstance(out, np.ndarray)\\n self.assertEqual(out.shape, shape)\\n if len(shape) > 1:\\n out = dset[:, :1]\\n self.assertIsInstance(out, np.ndarray)\\n self.assertEqual(out.shape[:2], (0, 1))\",\n \"def __getslice__(self, *args):\\n return _itkSurfaceSpatialObjectPointPython.vectoritkSurfaceSpatialObjectPoint3___getslice__(self, *args)\",\n \"def get_slice_from_list(self,list_,start=0,end=None):\\r\\n start = self._index_to_int(start,True)\\r\\n if end is not None:\\r\\n end= self._index_to_int(end)\\r\\n\\r\\n return list_[start:end]\",\n \"def cube_data(self):\\n cube_data = copy.deepcopy(self.data)\\n cube_data.shape = [self.nints * self.ngroups, self.rows, self.columns]\\n return cube_data\",\n \"def _adimsdi_singlepca(cube, angle_list, scale_list, ncomp, scaling,\\n mask_center_px, debug, svd_mode, imlib, interpolation,\\n collapse, verbose, start_time, full_output):\\n z, n, y_in, x_in = cube.shape\\n\\n if ncomp is None:\\n raise ValueError('`Ncomp` must be provided (positive integer value)')\\n\\n if not angle_list.shape[0] == n:\\n msg = \\\"Angle list vector has wrong length. It must equal the number\\\"\\n msg += \\\" frames in the cube\\\"\\n raise ValueError(msg)\\n\\n if scale_list is None:\\n raise ValueError('Scaling factors vector must be provided')\\n else:\\n if np.array(scale_list).ndim > 1:\\n raise ValueError('Scaling factors vector is not 1d')\\n if not scale_list.shape[0] == cube.shape[0]:\\n raise ValueError('Scaling factors vector has wrong length')\\n\\n scale_list = check_scal_vector(scale_list)\\n big_cube = []\\n\\n if verbose:\\n tit = 'Rescaling the spectral channels to align the speckles'\\n bar = pyprind.ProgBar(n, stream=1, title=tit)\\n for i in range(n):\\n cube_resc, _, _, _, _, _ = scpca(cube[:, i, :, :], scale_list)\\n cube_resc = cube_crop_frames(cube_resc, size=y_in, verbose=False)\\n big_cube.append(cube_resc)\\n if verbose:\\n bar.update()\\n\\n big_cube = np.array(big_cube)\\n big_cube = big_cube.reshape(z * n, y_in, x_in)\\n\\n if verbose:\\n timing(start_time)\\n print('{} total frames'.format(n * z))\\n print('Performing single PCA')\\n res_cube = _subtr_proj_fullfr(big_cube, None, ncomp, scaling,\\n mask_center_px, debug, svd_mode, False, False)\\n\\n if verbose:\\n timing(start_time)\\n\\n resadi_cube = np.zeros((n, y_in, x_in))\\n if verbose:\\n tit = 'Descaling the spectral channels'\\n bar = pyprind.ProgBar(n, stream=1, title=tit)\\n for i in range(n):\\n frame_i = scpca(res_cube[i * z:(i+1) * z, :, :], scale_list,\\n full_output=full_output, inverse=True, y_in=y_in,\\n x_in=x_in)\\n resadi_cube[i] = frame_i\\n if verbose:\\n bar.update()\\n\\n if verbose:\\n print('De-rotating and combining residuals')\\n timing(start_time)\\n der_res = cube_derotate(resadi_cube, angle_list, imlib=imlib,\\n interpolation=interpolation)\\n frame = cube_collapse(der_res, mode=collapse)\\n\\n cube_allfr_residuals = res_cube\\n cube_adi_residuals = resadi_cube\\n return cube_allfr_residuals, cube_adi_residuals, frame\",\n \"def slice(self, begin, end):\\n sliced = self._collection.slice(begin, end)\\n return self.set_collection(sliced)\",\n \"def __getitem__(self, n):\\n if isinstance(n, slice):\\n start, stop, step = n.start, n.stop, n.step\\n if not start:\\n start = 0\\n if not stop:\\n stop = len(self)\\n if stop < 0:\\n stop = len(self) + stop\\n if start < 0:\\n start = len(self) + start\\n return self._fa.get_seq(self.name, start + 1, stop)[::step]\\n\\n elif isinstance(n, int):\\n if n < 0:\\n n = len(self) + n\\n return self._fa.get_seq(self.name, n + 1, n + 1)\",\n \"def getxcslice(self,whichsol_,first_,last_,xc_):\\n _xc_minlength = ((last_) - (first_))\\n if ((last_) - (first_)) > 0 and xc_ is not None and len(xc_) != ((last_) - (first_)):\\n raise ValueError(\\\"Array argument xc is not long enough: Is %d, expected %d\\\" % (len(xc_),((last_) - (first_))))\\n if isinstance(xc_,numpy.ndarray) and not xc_.flags.writeable:\\n raise ValueError(\\\"Argument xc must be writable\\\")\\n if isinstance(xc_, numpy.ndarray) and xc_.dtype is numpy.dtype(numpy.float64) and xc_.flags.contiguous:\\n _xc_copyarray = False\\n _xc_tmp = ctypes.cast(xc_.ctypes._as_parameter_,ctypes.POINTER(ctypes.c_double))\\n elif xc_ is not None:\\n _xc_copyarray = True\\n _xc_np_tmp = numpy.zeros(len(xc_),numpy.dtype(numpy.float64))\\n _xc_np_tmp[:] = xc_\\n assert _xc_np_tmp.flags.contiguous\\n _xc_tmp = ctypes.cast(_xc_np_tmp.ctypes._as_parameter_,ctypes.POINTER(ctypes.c_double))\\n else:\\n _xc_copyarray = False\\n _xc_tmp = None\\n \\n res = __library__.MSK_XX_getxcslice(self.__nativep,whichsol_,first_,last_,_xc_tmp)\\n if res != 0:\\n _,msg = self.__getlasterror(res)\\n raise Error(rescode(res),msg)\\n if _xc_copyarray:\\n xc_[:] = _xc_np_tmp\",\n \"def shuffle_cube(cube):\\n shuffled = []\\n column_group_order = [n for n in range(int(math.sqrt(len(cube))))]\\n random.shuffle(column_group_order)\\n for i in column_group_order:\\n # shuffle columns within each of the 3 column groups\\n column_order = [n for n in range(int(math.sqrt(len(cube))))]\\n random.shuffle([n for n in range(int(math.sqrt(len(cube))))])\\n for j in column_order:\\n shuffled.append(cube[int(math.sqrt(len(cube))) * i + j])\\n\\n return shuffled\",\n \"def batch_slices(batch, sizes=False, include_ends=True):\\n size = scatter_add(torch.ones_like(batch), batch)\\n cumsum = torch.cumsum(size, dim=0)\\n starts = cumsum - size\\n ends = cumsum - 1\\n\\n slices = starts\\n if include_ends:\\n slices = torch.stack([starts, ends], dim=1).view(-1)\\n\\n if sizes:\\n return slices, size\\n return slices\",\n \"def get_cube_from_list(\\n self,\\n cubes: CubeList,\\n short_name: Optional[str] = None,\\n ) -> Cube:\\n if short_name is None:\\n short_name = self.vardef.short_name\\n for cube in cubes:\\n if cube.var_name == short_name:\\n return cube\\n raise Exception(f'Cube for variable \\\"{short_name}\\\" not found')\",\n \"def _get_slice(index, axis, num_axes):\\n idx = [slice(None)] * num_axes\\n idx[axis] = index\\n return tuple(idx)\",\n \"def slice(self) -> Tuple[slice, ...]:\\n\\n total_slice = tuple(slice(None) for _ in self.collection_shape)\\n for obj in self.objects.flat:\\n for i, current_slice in enumerate(obj.slices):\\n if total_slice[i].start is None:\\n total_slice = total_slice[:i] + (current_slice,) + total_slice[i + 1:]\\n else:\\n if current_slice.start < total_slice[i].start:\\n total_slice = total_slice[:i] + (\\n slice(current_slice.start, total_slice[i].stop, total_slice[i].step),) + total_slice[i + 1:]\\n if current_slice.stop > total_slice[i].stop:\\n total_slice = total_slice[:i] + (\\n slice(total_slice[i].start, current_slice.stop, total_slice[i].step),) + total_slice[i + 1:]\\n return total_slice\",\n \"def __getitem__(self, item):\\n # type (Any) -> Any\\n # Workaround for Arrow bug that segfaults on empty slice.\\n # This is fixed in Arrow master, will be released in 0.10\\n if isinstance(item, slice):\\n start = item.start or 0\\n stop = item.stop if item.stop is not None else len(self.data)\\n stop = min(stop, len(self.data))\\n step = item.step if item.step is not None else 1\\n # Arrow can't handle slices with steps other than 1\\n # https://issues.apache.org/jira/browse/ARROW-2714\\n if step != 1:\\n arr = np.asarray(self)[item]\\n # ARROW-2806: Inconsistent handling of np.nan requires adding a mask\\n if pa.types.is_integer(self.dtype.arrow_dtype) or pa.types.is_floating(\\n self.dtype.arrow_dtype\\n ):\\n mask = pd.isna(arr)\\n else:\\n mask = None\\n return type(self)(pa.array(arr, type=self.dtype.arrow_dtype, mask=mask))\\n if stop - start == 0:\\n return type(self)(pa.array([], type=self.data.type))\\n elif isinstance(item, Iterable):\\n if not is_array_like(item):\\n item = np.array(item)\\n if is_integer_dtype(item):\\n return self.take(item)\\n elif is_bool_dtype(item):\\n indices = np.array(item)\\n indices = np.argwhere(indices).flatten()\\n return self.take(indices)\\n else:\\n raise IndexError(\\n \\\"Only integers, slices and integer or boolean arrays are valid indices.\\\"\\n )\\n elif is_integer(item):\\n if item < 0:\\n item += len(self)\\n if item >= len(self):\\n return None\\n value = self.data[item]\\n if isinstance(value, pa.ChunkedArray):\\n return type(self)(value)\\n else:\\n return value.as_py()\",\n \"def hcqt_slices(record, t_len, shuffle=True, auto_restart=True, add_noise=True,\\n random_seed=None, slice_logger=None):\\n def hcqt_slicer(cqt, idx, counter, t_len):\\n # hcqt = np.swapaxes(cqt, 1, 2)\\n # Grab the obs\\n obs = utils.slice_ndarray(cqt, idx[counter], length=t_len, axis=-2)\\n # Fix the shape.\\n return obs[np.newaxis, ...] if np.ndim(obs) == 3 else obs\\n\\n for hcqt_slice in base_slicer(\\n record, t_len, hcqt_slicer,\\n shuffle=shuffle, auto_restart=auto_restart,\\n add_noise=add_noise, random_seed=random_seed,\\n npz_data_key='harmonic_cqt',\\n slice_logger=slice_logger):\\n yield hcqt_slice\",\n \"def transform_cube(self,\\n cube: xr.Dataset,\\n gm: GridMapping,\\n cube_config: CubeConfig) -> TransformedCube:\\n return cube, gm, cube_config\",\n \"def __getitem__(self, item):\\n c_ex = self.examples[item]\\n # randomly select ref mic\\n mics = [x for x in c_ex.keys()]\\n if self.train:\\n np.random.shuffle(mics) # randomly permute during training to change ref mics\\n\\n mixtures = []\\n sources = []\\n for i in range(len(mics)):\\n c_mic = c_ex[mics[i]]\\n\\n if self.segment:\\n offset = 0\\n if c_mic[\\\"length\\\"] > int(self.segment * self.sample_rate):\\n offset = np.random.randint(\\n 0, c_mic[\\\"length\\\"] - int(self.segment * self.sample_rate)\\n )\\n\\n # we load mixture\\n mixture, fs = sf.read(\\n c_mic[\\\"mixture\\\"],\\n start=offset,\\n stop=offset + int(self.segment * self.sample_rate),\\n dtype=\\\"float32\\\",\\n )\\n spk1, fs = sf.read(\\n c_mic[\\\"spk1\\\"],\\n start=offset,\\n stop=offset + int(self.segment * self.sample_rate),\\n dtype=\\\"float32\\\",\\n )\\n spk2, fs = sf.read(\\n c_mic[\\\"spk2\\\"],\\n start=offset,\\n stop=offset + int(self.segment * self.sample_rate),\\n dtype=\\\"float32\\\",\\n )\\n else:\\n mixture, fs = sf.read(c_mic[\\\"mixture\\\"], dtype=\\\"float32\\\") # load all\\n spk1, fs = sf.read(c_mic[\\\"spk1\\\"], dtype=\\\"float32\\\")\\n spk2, fs = sf.read(c_mic[\\\"spk2\\\"], dtype=\\\"float32\\\")\\n\\n mixture = torch.from_numpy(mixture).unsqueeze(0)\\n spk1 = torch.from_numpy(spk1).unsqueeze(0)\\n spk2 = torch.from_numpy(spk2).unsqueeze(0)\\n\\n assert fs == self.sample_rate\\n mixtures.append(mixture)\\n sources.append(torch.cat((spk1, spk2), 0))\\n\\n mixtures = torch.cat(mixtures, 0)\\n sources = torch.stack(sources)\\n # we pad till max_mic\\n valid_mics = mixtures.shape[0]\\n if mixtures.shape[0] < self.max_mics:\\n dummy = torch.zeros((self.max_mics - mixtures.shape[0], mixtures.shape[-1]))\\n mixtures = torch.cat((mixtures, dummy), 0)\\n sources = torch.cat((sources, dummy.unsqueeze(1).repeat(1, sources.shape[1], 1)), 0)\\n return mixtures, sources, valid_mics\",\n \"def test02c(self):\\n a = np.arange(1e3)\\n b = bcolz.carray(a, chunklen=10, rootdir=self.rootdir)\\n sl = slice(1, -3)\\n # print \\\"b[sl]->\\\", `b[sl]`\\n assert_array_equal(a[sl], b[sl], \\\"Arrays are not equal\\\")\",\n \"def __getitem__(self, item):\\n if isinstance(item, slice):\\n start = item.start or 0\\n stop = item.stop if item.stop is not None else len(self.data)\\n stop = min(stop, len(self.data))\\n if stop - start == 0:\\n return type(self)(xnd.xnd([], type=self.data.type))\\n\\n elif isinstance(item, Iterable):\\n if not is_array_like(item):\\n item = np.array(item)\\n if is_integer_dtype(item):\\n return self.take(item)\\n elif is_bool_dtype(item):\\n indices = np.array(item)\\n indices = np.argwhere(indices).flatten()\\n return self.take(indices)\\n else:\\n raise IndexError(\\n \\\"Only integers, slices and integer or boolean \\\\\\n arrays are valid indices.\\\"\\n )\\n\\n elif is_integer(item):\\n if item < 0:\\n item += len(self)\\n if item >= len(self):\\n return None\\n else:\\n\\n return self.data[item]\\n\\n value = self.data[item]\\n return type(self)(value)\",\n \"def query_datacube(product,latitude,longitude,time,measurements):\\r\\n\\r\\n dc = datacube.Datacube(app=\\\"Query\\\")\\r\\n\\r\\n xarr = dc.load(\\r\\n product=product, \\r\\n longitude=longitude, \\r\\n latitude=latitude,\\r\\n # Time format YYYY-MM-DD\\r\\n time=time, \\r\\n measurements=measurements\\r\\n )\\r\\n\\r\\n return xarr\",\n \"def slice(data, size):\\n\\treturn dice(data, size).T\",\n \"def getxcslice(self,whichsol_,first_,last_,xc): # 3\\n if not isinstance(whichsol_,soltype): raise TypeError(\\\"Argument whichsol has wrong type\\\")\\n _copyback_xc = False\\n if xc is None:\\n xc_ = None\\n else:\\n try:\\n xc_ = memoryview(xc)\\n except TypeError:\\n try:\\n _tmparr_xc = array.array(\\\"d\\\",xc)\\n except TypeError:\\n raise TypeError(\\\"Argument xc has wrong type\\\")\\n else:\\n xc_ = memoryview(_tmparr_xc)\\n _copyback_xc = True\\n else:\\n if xc_.format != \\\"d\\\":\\n xc_ = memoryview(array.array(\\\"d\\\",xc))\\n _copyback_xc = True\\n if xc_ is not None and len(xc_) != ((last_) - (first_)):\\n raise ValueError(\\\"Array argument xc has wrong length\\\")\\n res = self.__obj.getxcslice(whichsol_,first_,last_,xc_)\\n if res != 0:\\n result,msg = self.__getlasterror(res)\\n raise Error(rescode(res),msg)\\n if _copyback_xc:\\n xc[:] = _tmparr_xc\",\n \"def transform_cube(self,\\n cube: xr.Dataset,\\n gm: GridMapping,\\n cube_config: CubeConfig) -> TransformedCube:\",\n \"def convert_slice(g, op, block):\\n\\n data = g.get_node(op.input(\\\"Input\\\")[0])\\n dims = len(infer_shape(data))\\n\\n axes = op.attr(\\\"axes\\\")\\n indices = _expr.const(axes, dtype=\\\"int64\\\")\\n\\n decrease_axis = op.attr(\\\"decrease_axis\\\")\\n if isinstance(decrease_axis, int):\\n decrease_axis = [decrease_axis]\\n\\n if op.input(\\\"StartsTensor\\\"):\\n starts = g.get_node(op.input(\\\"StartsTensor\\\")[0])\\n starts, infered = try_infer_value(starts, g.get_params())\\n if infered:\\n starts = starts.tolist()\\n elif op.input(\\\"StartsTensorList\\\"):\\n starts = []\\n for start_index in op.input(\\\"StartsTensorList\\\"):\\n start_index = g.get_node(start_index).astype(\\\"int64\\\")\\n starts.append(start_index)\\n starts = _op.concatenate(starts, axis=0)\\n starts, infered = try_infer_value(starts, g.get_params())\\n if infered:\\n starts = starts.tolist()\\n else:\\n starts = op.attr(\\\"starts\\\")\\n\\n if len(axes) < dims:\\n if isinstance(starts, _expr.Expr):\\n starts = _op.scatter_elements(\\n _op.const([0] * dims, dtype=infer_type(starts).checked_type.dtype),\\n indices,\\n starts,\\n axis=0,\\n )\\n else:\\n base = [0] * dims\\n for i, axis in enumerate(axes):\\n base[axis] = starts[i]\\n starts = base\\n\\n if op.input(\\\"EndsTensor\\\"):\\n ends = g.get_node(op.input(\\\"EndsTensor\\\")[0])\\n ends, infered = try_infer_value(ends, g.get_params())\\n if infered:\\n ends = ends.tolist()\\n elif op.input(\\\"EndsTensorList\\\"):\\n ends = []\\n for end_index in op.input(\\\"EndsTensorList\\\"):\\n end_index = g.get_node(end_index).astype(\\\"int64\\\")\\n ends.append(end_index)\\n ends = _op.concatenate(ends, axis=0)\\n ends, infered = try_infer_value(ends, g.get_params())\\n if infered:\\n ends = ends.tolist()\\n else:\\n ends = op.attr(\\\"ends\\\")\\n\\n if len(axes) < dims:\\n if isinstance(ends, _expr.Expr):\\n ends = _op.scatter_elements(\\n _expr.const(\\n np.array([np.iinfo(np.int32).max] * dims),\\n dtype=infer_type(ends).checked_type.dtype,\\n ),\\n indices,\\n ends,\\n axis=0,\\n )\\n else:\\n base = [np.iinfo(np.int32).max] * dims\\n for i, axis in enumerate(axes):\\n base[axis] = ends[i]\\n ends = base\\n\\n strides = None\\n if \\\"StridesTensor\\\" in op.input_names and op.input(\\\"StridesTensor\\\"):\\n strides = g.get_node(op.input(\\\"StridesTensor\\\")[0])\\n strides, infered = try_infer_value(strides, g.get_params())\\n if infered:\\n strides = strides.tolist()\\n elif \\\"StridesTensorList\\\" in op.input_names and op.input(\\\"StridesTensorList\\\"):\\n strides = []\\n for strides_index in op.input(\\\"StridesTensorList\\\"):\\n strides_index = g.get_node(strides_index).astype(\\\"int64\\\")\\n strides.append(strides_index)\\n strides = _op.concatenate(strides, axis=0)\\n strides, infered = try_infer_value(strides, g.get_params())\\n if infered:\\n strides = strides.tolist()\\n elif op.has_attr(\\\"strides\\\"):\\n strides = op.attr(\\\"strides\\\")\\n\\n if len(axes) < dims:\\n if isinstance(strides, _expr.Expr):\\n strides = _op.scatter_elements(\\n _expr.const(np.array([1] * dims), dtype=infer_type(strides).checked_type.dtype),\\n indices,\\n strides,\\n axis=0,\\n )\\n elif strides:\\n base = [1] * dims\\n for i, axis in enumerate(axes):\\n base[axis] = strides[i]\\n strides = base\\n if not strides:\\n strides = _op.const([1] * dims, dtype=\\\"int64\\\")\\n\\n out = _op.strided_slice(data, begin=starts, end=ends, strides=strides)\\n out_shape = infer_shape(out)\\n if decrease_axis and len(out_shape) > 1:\\n out = _op.squeeze(out, axis=decrease_axis)\\n g.add_node(op.output(\\\"Out\\\")[0], out)\",\n \"def generated_cube(self) -> Optional[xr.Dataset]:\\n return self._generated_cube\",\n \"def during(self, e):\\r\\n\\r\\n if not isinstance(e, Epochs):\\r\\n raise ValueError('e has to be of Epochs type')\\r\\n\\r\\n if e.data.ndim > 0:\\r\\n ## TODO: Implement slicing with 1-d Epochs array,\\r\\n ## resulting in (ragged/jagged) 2-d TimeArray\\r\\n raise NotImplementedError('e has to be a scalar Epoch')\\r\\n\\r\\n return self[self.slice_during(e)]\",\n \"def take_slice(img_3D, view):\\n input_type = isinstance(img_3D, np.ndarray)\\n if input_type:\\n img_3D = [img_3D]\\n img_shape = img_3D[0].shape\\n if view == \\\"sag\\\":\\n slice_pos = np.random.randint(int(0.2 * img_shape[0]), int(0.8 * img_shape[0]))\\n imgs_2D = [imgg_3D[slice_pos, :, :] for imgg_3D in img_3D]\\n elif view == \\\"cor\\\":\\n slice_pos = np.random.randint(int(0.2 * img_shape[1]), int(0.8 * img_shape[1]))\\n imgs_2D = [imgg_3D[:, slice_pos, :] for imgg_3D in img_3D]\\n else:\\n slice_pos = np.random.randint(int(0.2 * img_shape[2]), int(0.8 * img_shape[2]))\\n imgs_2D = [imgg_3D[:, :, slice_pos] for imgg_3D in img_3D]\\n # img_2D = np.expand_dims(img_2D, 2)\\n if input_type:\\n return imgs_2D[0]\\n return imgs_2D\",\n \"def copy(self):\\n new_cubies = [cubie.copy() for cubie in self.cubies]\\n new_cube = Cube(new_cubies)\\n return new_cube\",\n \"def array_slice(items, a1, a2 = None):\\n if (a2 is None):\\n return items[a1:]\\n else:\\n return items[a1:a2]\",\n \"def _get_slice(series, start, length):\\n return [ int(s) for s in series[start:start+length] ]\",\n \"def make_fwd_slice(shape, slices, reverse=None, cull_second=True):\\n if reverse is None:\\n reverse = []\\n if not isinstance(shape, (list, tuple, np.ndarray)):\\n shape = [shape]\\n if not isinstance(slices, (list, tuple)):\\n slices = [slices]\\n if not isinstance(reverse, (list, tuple)):\\n reverse = [reverse]\\n\\n newax_inds = [i for i, x in enumerate(slices) if x == np.newaxis]\\n shape = list(shape)\\n for i in newax_inds:\\n shape.insert(i, 1)\\n\\n # ya know, lets just go through all the dimensions in shape\\n # just to be safe and default to an empty slice / no reverse\\n slices = slices + [slice(None)] * (len(shape) - len(slices))\\n reverse = reverse + [False] * (len(slices) - len(reverse))\\n\\n first_slc = [slice(None)] * len(slices)\\n second_slc = [slice(None, None, 1)] * len(first_slc)\\n\\n for i, slc, L, rev in izip(count(), slices, shape, reverse):\\n if isinstance(slc, slice):\\n step = slc.step if slc.step is not None else 1\\n start = slc.start if slc.start is not None else 0\\n stop = slc.stop if slc.stop is not None else L\\n if start < 0:\\n start += L\\n if stop < 0:\\n stop += L\\n\\n # sanity check the start/stop since we're gunna be playing\\n # fast and loose with them\\n if start < 0 or stop < 0:\\n raise IndexError(\\\"((start = {0}) or (stop = {1})) < 0\\\"\\n \\\"\\\".format(start, stop))\\n if start > L or stop > L:\\n raise IndexError(\\\"((start={0}) or (stop={1})) > (L={2})\\\"\\n \\\"\\\".format(start, stop, L))\\n\\n # now do the math of flipping the slice if needed, these branches\\n # change start, stop, and step so they can be used to create a new\\n # slice below\\n if rev:\\n if step < 0:\\n step = -step\\n if slc.start is None:\\n start = L - 1\\n if slc.stop is None:\\n start = L - 1 - start\\n stop = None\\n else:\\n start, stop = L - 1 - start, L - 1 - stop\\n else:\\n start, stop = L - stop, L - start\\n start += ((stop - 1 - start) % step)\\n second_slc[i] = slice(None, None, -1)\\n elif step < 0:\\n step = -step\\n if slc.start is None:\\n start = L - 1\\n\\n if slc.stop is None:\\n start, stop = 0, start + 1\\n start = ((stop - 1 - start) % step)\\n else:\\n start, stop = stop + 1, start + 1\\n start += ((stop - 1 - start) % step)\\n\\n second_slc[i] = slice(None, None, -1)\\n\\n # check that our slice is valid\\n assert start is None or (0 <= start and start <= L), \\\\\\n \\\"start (={0}) is outside range\\\".format(start)\\n assert start is None or (0 <= start and start <= L), \\\\\\n \\\"start (={0}) is outside range\\\".format(start)\\n assert start is None or stop is None or start < stop, \\\\\\n \\\"bad slice ordering: {0} !< {1}\\\".format(start, stop)\\n assert step > 0\\n slc = slice(start, stop, step)\\n\\n elif isinstance(slc, (int, np.integer)):\\n second_slc[i] = None\\n if rev:\\n slc = (L - 1) - slc\\n\\n elif slc == np.newaxis:\\n second_slc[i] = \\\"NEWAXIS\\\"\\n\\n first_slc[i] = slc\\n\\n first_slc = [s for s in first_slc if s is not np.newaxis]\\n if cull_second:\\n second_slc = [s for s in second_slc if s is not None]\\n second_slc = [np.newaxis if s == \\\"NEWAXIS\\\" else s for s in second_slc]\\n return first_slc, second_slc\",\n \"def subsegment(self, start_time=None, end_time=None):\\n start_time = 0.0 if start_time is None else start_time\\n end_time = self.duration if end_time is None else end_time\\n if start_time < 0.0:\\n start_time = self.duration + start_time\\n if end_time < 0.0:\\n end_time = self.duration + end_time\\n if start_time < 0.0:\\n raise ValueError(\\\"The slice start position (%f s) is out of bounds.\\\" % start_time)\\n if end_time < 0.0:\\n raise ValueError(\\\"The slice end position (%f s) is out of bounds.\\\" % end_time)\\n if start_time > end_time:\\n raise ValueError(\\n \\\"The slice start position (%f s) is later than the end position (%f s).\\\" % (start_time, end_time)\\n )\\n if end_time > self.duration:\\n raise ValueError(\\\"The slice end position (%f s) is out of bounds (> %f s)\\\" % (end_time, self.duration))\\n start_sample = int(round(start_time * self._sample_rate))\\n end_sample = int(round(end_time * self._sample_rate))\\n self._samples = self._samples[start_sample:end_sample]\",\n \"def testSliceMiddleWithNegativeIndex(self):\\n inst = WireData(b'0123456789')\\n self.assertEqual(inst[-6:-3], WireData(b'456'))\",\n \"def __setslice__(self, *args):\\n return _itkLineSpatialObjectPointPython.vectoritkLineSpatialObjectPoint3___setslice__(self, *args)\",\n \"def _slice(tensor, size, i):\\n return tensor[:, i * size : (i + 1) * size]\",\n \"def rotate_cube_left_list(liste):\\n \\n rotate_cube_right_list(liste)\\n rotate_cube_right_list(liste)\\n rotate_cube_right_list(liste)\\n \\n return liste\",\n \"def test_getslice_setslice3(self):\\n class C(object):\\n def __init__(self):\\n self.calls = []\\n def __getitem__(self, index):\\n self.calls.append('get')\\n return 'Ok'\\n def __setitem__(self, index, value):\\n self.calls.append('set')\\n def __delitem__(self, index):\\n self.calls.append('delete')\\n def __len__(self):\\n self.calls.append('len')\\n return 5\\n\\n a = C()\\n self.assertEqual(a[3:5], 'Ok')\\n self.assertEqual(a.calls, ['get'])\\n\\n a = C()\\n a[3:5] = 'abc'\\n self.assertEqual(a.calls, ['set'])\\n\\n a = C()\\n del(a[3:5])\\n self.assertEqual(a.calls, ['delete'])\\n\\n # but call length if it's negative (and we should only call length once)\\n a = C()\\n self.assertEqual(a[-1:5], 'Ok')\\n self.assertEqual(a.calls, ['get'])\\n\\n a = C()\\n self.assertEqual(a[1:-5], 'Ok')\\n self.assertEqual(a.calls, ['get'])\\n\\n a = C()\\n self.assertEqual(a[-1:-5], 'Ok')\\n self.assertEqual(a.calls, ['get'])\\n\\n a = C()\\n a[-1:5] = 'abc'\\n self.assertEqual(a.calls, ['set'])\\n\\n a = C()\\n a[1:-5] = 'abc'\\n self.assertEqual(a.calls, ['set'])\\n\\n a = C()\\n a[-1:-5] = 'abc'\\n self.assertEqual(a.calls, ['set'])\\n\\n a = C()\\n del(a[-1:5])\\n self.assertEqual(a.calls, ['delete'])\\n\\n a = C()\\n del(a[1:-5])\\n self.assertEqual(a.calls, ['delete'])\\n\\n a = C()\\n del(a[-1:-5])\\n self.assertEqual(a.calls, ['delete'])\",\n \"def test_3d_time():\\n dic,data = ng.pipe.read(\\\"common_data/3d_pipe/data/test%03d.fid\\\")\\n sdic,sdata = ng.pipe.read(\\\"common_data/3d_pipe/data/test001.fid\\\")\\n assert data.shape == (128, 88, 1250)\\n assert data.dtype == 'complex64'\\n assert round(data[0,1,2].real,2) == -7.98\\n assert round(data[0,1,2].imag,2) == 33.82\\n assert round(data[10,22,5].real,2) == 15.71\\n assert round(data[10,22,5].imag,2) == 15.1\\n\\n # and the first slice\\n assert sdata.shape == (88, 1250)\\n assert sdata.dtype == 'complex64'\\n assert round(sdata[1,2].real,2) == -7.98\\n assert round(sdata[1,2].imag,2) == 33.82\\n assert round(sdata[22,5].real,2) == 22.65\\n assert round(sdata[22,5].imag,2) == 13.65\\n\\n # slice/data matching\\n assert_array_equal(data[0],sdata)\\n\\n write_readback_3D(dic,data)\",\n \"def _read_index_slice(self, *args, **kwargs): # real signature unknown\\n pass\",\n \"def truth_dataframe_to_cube(df: DataFrame, training_dates: DatetimeIndex,) -> Cube:\\n\\n cubelist = CubeList()\\n for adate in training_dates:\\n time_df = df.loc[(df[\\\"time\\\"] == adate)]\\n\\n time_df = _preprocess_temporal_columns(time_df)\\n\\n if time_df.empty:\\n continue\\n\\n # The following columns are expected to contain one unique value\\n # per column.\\n _unique_check(time_df, \\\"diagnostic\\\")\\n\\n if time_df[\\\"period\\\"].isna().all():\\n time_bounds = None\\n else:\\n period = time_df[\\\"period\\\"].values[0]\\n time_bounds = [adate - period, adate]\\n\\n time_coord = _define_time_coord(adate, time_bounds)\\n height_coord = _define_height_coord(time_df[\\\"height\\\"].values[0])\\n\\n if \\\"station_id\\\" in time_df.columns:\\n unique_site_id = time_df[\\\"station_id\\\"].values.astype(\\\"<U8\\\")\\n unique_site_id_key = \\\"station_id\\\"\\n else:\\n unique_site_id = None\\n unique_site_id_key = None\\n\\n cube = build_spotdata_cube(\\n time_df[\\\"ob_value\\\"].astype(np.float32),\\n time_df[\\\"cf_name\\\"].values[0],\\n time_df[\\\"units\\\"].values[0],\\n time_df[\\\"altitude\\\"].astype(np.float32),\\n time_df[\\\"latitude\\\"].astype(np.float32),\\n time_df[\\\"longitude\\\"].astype(np.float32),\\n time_df[\\\"wmo_id\\\"].values.astype(\\\"U5\\\"),\\n unique_site_id,\\n unique_site_id_key,\\n scalar_coords=[time_coord, height_coord],\\n )\\n cubelist.append(cube)\\n\\n if not cubelist:\\n return\\n\\n return cubelist.merge_cube()\",\n \"def __getitem__(self, item):\\n if isinstance(item, slice):\\n return list(itertools.islice(self._queue, item.start, item.stop, item.step))\\n else:\\n return self._queue[item]\",\n \"def __getslice__(self, *args):\\n return _itkLineSpatialObjectPointPython.vectoritkLineSpatialObjectPoint3___getslice__(self, *args)\",\n \"def __delslice__(self, *args):\\n return _itkLineSpatialObjectPointPython.vectoritkLineSpatialObjectPoint3___delslice__(self, *args)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6331354","0.62150717","0.60088134","0.5788159","0.5405186","0.52887505","0.52854425","0.526346","0.52061605","0.512507","0.51214343","0.5059634","0.50593454","0.5031299","0.50106156","0.5003349","0.49384144","0.493823","0.49368778","0.49356455","0.49280393","0.4906976","0.4889926","0.48846218","0.4881067","0.48807833","0.48766345","0.48755312","0.48687446","0.48332942","0.4829822","0.48290882","0.48152116","0.47976115","0.47789425","0.4770971","0.47640038","0.47505918","0.47490722","0.47436923","0.47324967","0.47207335","0.4713899","0.47118887","0.47101086","0.47086376","0.47015542","0.46953088","0.46814093","0.46755025","0.46711996","0.46602717","0.46503547","0.46398732","0.4634917","0.4630215","0.4630066","0.4628087","0.462139","0.46159086","0.46082613","0.45983517","0.45936286","0.45797536","0.4572085","0.4568256","0.45615193","0.45572633","0.45456207","0.45428142","0.45385313","0.45335135","0.45297644","0.45255923","0.452234","0.4520696","0.45143113","0.4512149","0.45085698","0.45084038","0.45051858","0.45003894","0.44964832","0.44914854","0.4478686","0.44762373","0.44739637","0.44687805","0.4464926","0.44615042","0.44597065","0.44558805","0.44553447","0.44532043","0.44506994","0.44391808","0.44327673","0.442663","0.44241577","0.44232795"],"string":"[\n \"0.6331354\",\n \"0.62150717\",\n \"0.60088134\",\n \"0.5788159\",\n \"0.5405186\",\n \"0.52887505\",\n \"0.52854425\",\n \"0.526346\",\n \"0.52061605\",\n \"0.512507\",\n \"0.51214343\",\n \"0.5059634\",\n \"0.50593454\",\n \"0.5031299\",\n \"0.50106156\",\n \"0.5003349\",\n \"0.49384144\",\n \"0.493823\",\n \"0.49368778\",\n \"0.49356455\",\n \"0.49280393\",\n \"0.4906976\",\n \"0.4889926\",\n \"0.48846218\",\n \"0.4881067\",\n \"0.48807833\",\n \"0.48766345\",\n \"0.48755312\",\n \"0.48687446\",\n \"0.48332942\",\n \"0.4829822\",\n \"0.48290882\",\n \"0.48152116\",\n \"0.47976115\",\n \"0.47789425\",\n \"0.4770971\",\n \"0.47640038\",\n \"0.47505918\",\n \"0.47490722\",\n \"0.47436923\",\n \"0.47324967\",\n \"0.47207335\",\n \"0.4713899\",\n \"0.47118887\",\n \"0.47101086\",\n \"0.47086376\",\n \"0.47015542\",\n \"0.46953088\",\n \"0.46814093\",\n \"0.46755025\",\n \"0.46711996\",\n \"0.46602717\",\n \"0.46503547\",\n \"0.46398732\",\n \"0.4634917\",\n \"0.4630215\",\n \"0.4630066\",\n \"0.4628087\",\n \"0.462139\",\n \"0.46159086\",\n \"0.46082613\",\n \"0.45983517\",\n \"0.45936286\",\n \"0.45797536\",\n \"0.4572085\",\n \"0.4568256\",\n \"0.45615193\",\n \"0.45572633\",\n \"0.45456207\",\n \"0.45428142\",\n \"0.45385313\",\n \"0.45335135\",\n \"0.45297644\",\n \"0.45255923\",\n \"0.452234\",\n \"0.4520696\",\n \"0.45143113\",\n \"0.4512149\",\n \"0.45085698\",\n \"0.45084038\",\n \"0.45051858\",\n \"0.45003894\",\n \"0.44964832\",\n \"0.44914854\",\n \"0.4478686\",\n \"0.44762373\",\n \"0.44739637\",\n \"0.44687805\",\n \"0.4464926\",\n \"0.44615042\",\n \"0.44597065\",\n \"0.44558805\",\n \"0.44553447\",\n \"0.44532043\",\n \"0.44506994\",\n \"0.44391808\",\n \"0.44327673\",\n \"0.442663\",\n \"0.44241577\",\n \"0.44232795\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.5719029"},"document_rank":{"kind":"string","value":"4"}}},{"rowIdx":24989,"cells":{"query":{"kind":"string","value":"Plots an xy graph at a certain specified wavelength onto the current axes. Keyword arguments are passed on to matplotlib."},"document":{"kind":"string","value":"def plot_x_slice(self, offset, **kwargs):\n cumul_cube_lengths = np.cumsum(np.array([c.shape[self.common_axis]\n for c in self.data]))\n sequence_index, cube_index = cu._convert_cube_like_index_to_sequence_indices(\n offset, cumul_cube_lengths)\n plot = self[sequence_index].plot_x_slice(cube_index, **kwargs)\n return plot"},"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 liveplot(x, y, xlim, ylim, title):\n plt.plot(x,y,'b.')\n plt.xlim(xlim)\n plt.ylim(ylim)\n plt.xlabel('North-South Axis')\n plt.ylabel('East-West Axis')\n plt.title(title)\n plt.show()","def plot_xyz():\n plt.subplot(3,1,1) # for x axis\n plt.title('x value v.s. time')\n plt.grid(True)\n plt.ylabel('X')\n plt.xlabel('t')\n plt.plot(x, '-r')\n\n plt.subplot(3,1,2) # for y axis\n plt.title('y value v.s. time')\n plt.grid(True)\n plt.ylabel('Y')\n plt.xlabel('t')\n plt.plot(y, '-g')\n\n plt.subplot(3,1,3) # for z axis\n plt.title('z value v.s. time')\n plt.grid(True)\n plt.ylabel('Z')\n plt.xlabel('t')\n plt.plot(z, '-b')","def xyplot(x_vals,y_vals,name):\n # set the figure's size\n set_figsize(figsize=(5, 2.5))\n # detach() is used to get a variable from the current calculation graph\n # in which this variable is the not gradient tracking version\n plt.plot(x_vals.detach().numpy(), y_vals.detach().numpy())\n # set the constant x axis label\n plt.xlabel('x')\n # combine and set the y axis label\n plt.ylabel(name+'(x)')\n plt.show()","def plot_xy(x, y, ax=None, xlabel='Energy [keV]', **kwargs):\n\n if not ax:\n new_plot = True\n plt.figure()\n ax = plt.axes()\n else:\n new_plot = False\n\n plt.semilogy(x, y, axes=ax, drawstyle='steps-mid', **kwargs)\n\n if new_plot:\n plt.xlabel(xlabel)\n plt.ylabel('Counts')\n\n if 'label' in kwargs:\n plt.legend()\n plt.show()\n\n return ax","def plotWavelet(self):\n\n a = 0\n if(self.axQT is not None):\n self._bxPlot()\n a += 1\n if(self.bxQT is not None):\n self._cxPlot()\n a += 1\n\n if(a > 0):\n return\n\n self._setupPlot()\n self._axPlot()\n self._bxPlot()\n self._cxPlot()\n self._dxPlot()\n self._endingPlot()","def plot(self):\n plot_spectrum(self.data, self.fig, self.ax_e, self.ax_s, title = \"Solar spectrum\")","def plot_simulation_xz(\n sim: td.Simulation,\n x: float = 0.0,\n z: float = 0.0,\n wavelength: Optional[float] = 1.55,\n figsize: Float2 = (11, 4),\n):\n fig = plt.figure(figsize=figsize)\n gs = mpl.gridspec.GridSpec(1, 2, figure=fig, width_ratios=[1, 1.4])\n ax1 = fig.add_subplot(gs[0, 0])\n ax2 = fig.add_subplot(gs[0, 1])\n if wavelength:\n freq = td.constants.C_0 / wavelength\n sim.plot_eps(z=z, ax=ax1, freq=freq)\n sim.plot_eps(x=x, ax=ax2, freq=freq)\n else:\n sim.plot(z=z, ax=ax1)\n sim.plot(x=x, ax=ax2)\n plt.show()\n return fig","def plot(self, ax=..., *, name=..., **kwargs):\n ...","def show_plot() :\n logger.info(\"Show plot\")\n pylab.axis('equal')\n pylab.xlabel(\"Longitud\")\n pylab.ylabel(\"Latitud\")\n pylab.grid(True)\n pylab.title(\"Product tiles and product source\")\n pylab.show()","def plot_xy(self, xpts, ypts):\n self.plot(np.asarray((xpts, ypts)).T)","def plotSpectrum(inp,xrng=[],yrng=[],xlabel='',ylabel='',xlog=False,ylog=False,grid=False,\n legend=[],legend_location='upper right',fontscale=1,legend_fontscale=1,title='',\n color='k',colormap=None,linestyle='-',linewidth=1.5,alpha=1.,\n show_noise=True,color_noise='k',linestyle_noise='-',linewidth_noise=1.5,alpha_noise=0.5,\n comparison=None,color_comparison='grey',linestyle_comparison='-',linewidth_comparison=1.5,alpha_comparison=1,\n residual=False,color_residual='m',linestyle_residual='-',linewidth_residual=1.5,alpha_residual=0.5,\n telluric=False,color_telluric='grey',linestyle_telluric='-',linewidth_telluric=1.5,alpha_telluric=0.2,\n features=[],mdwarf=False,ldwarf=False,tdwarf=False,young=False,binary=False,nsamples=100,\n band=[],band_color='k',band_alpha=0.2,band_label='',band_label_position='bottom',band_width=0.1,\n show_zero=True,stack=0.,zeropoint=0.,color_zero='k',linestyle_zero=':',linewidth_zero=1.5,alpha_zero=0.3,\n inset=False,inset_xrange=[],inset_yrange=[],inset_position=[0.65,0.60,0.20,0.20],inset_features=False,\n output='',multiplot=False,multipage=False,layout=[1,1],figsize=[],tight=True,\n interactive=False,**kwargs):\n\n# keyword parameters (for backward compatability)\n for k in ['showZero','showzero']: show_zero=kwargs.get(k,show_zero)\n for k in ['showNoise','noise','uncertainty','shownoise','showuncertainty','show_uncertainty']: show_noise=kwargs.get(k,show_noise)\n\n for k in ['line_style','lineStyle','ls','linestyles','line_styles']: linestyle=kwargs.get(k,linestyle)\n for k in ['line_width','lineWidth','width','lw','linewidths','line_widths']: linewidth=kwargs.get(k,linewidth)\n for k in ['colors','colour','colours']: color=kwargs.get(k,color)\n for k in ['colorScheme','color_scheme','colorscheme','colorMap','color_map']: colormap=kwargs.get(k,colormap)\n\n for k in ['colornoise','colorNoise','colorUnc','coloruncertainty','color_uncertainty','colorUncertainty']: color_noise=kwargs.get(k,color_noise)\n for k in ['linestylenoise','line_style_noise','linestyleNoise']: linestyle_noise=kwargs.get(k,linestyle_noise)\n for k in ['linewidthnoise','linewidthNoise','line_width_noise']: linewidth_noise=kwargs.get(k,linewidth_noise)\n for k in ['alphanoise','alphaNoise']: alpha_noise=kwargs.get(k,alpha_noise)\n\n for k in ['colorzero','colorZero']: color_zero=kwargs.get(k,color_zero)\n for k in ['linestylezero','line_style_zero','linestyleZero']: linestyle_zero=kwargs.get(k,linestyle_zero)\n for k in ['linewidthzero','linewidthZero','line_width_zero']: linewidth_zero=kwargs.get(k,linewidth_zero)\n for k in ['alphazero','alphaZero']: alpha_zero=kwargs.get(k,alpha_zero)\n\n for k in ['colorcomparison','colorComparison']: color_comparison=kwargs.get(k,color_comparison)\n for k in ['linestyleComparison','line_style_comparison','linestylecomparison']: linestyle_comparison=kwargs.get(k,linestyle_comparison)\n for k in ['linewidthcomparison','linewidthComparison','line_width_comparison']: linewidth_comparison=kwargs.get(k,linewidth_comparison)\n for k in ['alphacomparison','alphaComparison']: alpha_comparison=kwargs.get(k,alpha_comparison)\n\n for k in ['colorresidual','colorResidual']: color_residual=kwargs.get(k,color_residual)\n for k in ['linestyleresidual','line_style_residual','linestyleResidual']: linestyle_residual=kwargs.get(k,linestyle_residual)\n for k in ['linewidthresidual','linewidthResidual','line_width_residual']: linewidth_residual=kwargs.get(k,linewidth_residual)\n for k in ['alpharesidual','alphaResidual']: alpha_residual=kwargs.get(k,alpha_residual)\n\n for k in ['bands']: band=kwargs.get(k,band)\n if len(band) == 2 and isinstance(band[0],list) == False: band = [band]\n for k in ['bandcolors','bandcolor','band_colors']: band_color=kwargs.get(k,band_color)\n for k in ['bandalphas','band_alphas','bandalpha']: band_alpha=kwargs.get(k,band_alpha)\n for k in ['band_labels','bandlabel','bandlabels']: band_label=kwargs.get(k,band_label)\n for k in ['band_label_positions','bandlabelposition','bandlabelpositions']: band_label_position=kwargs.get(k,band_label_position)\n for k in ['bandwidth','bandwidths','band_widths']: band_width=kwargs.get(k,band_width)\n for par in [band_color,band_alpha,band_label,band_label_position,band_width]:\n if not isinstance(par,list): par = [par]*len(band)\n if len(par) < len(band): par.extend([par[-1] for x in range(len(band)-len(par))])\n\n for k in ['legends','label','labels']: legend=kwargs.get(k,legend)\n if not isinstance(legend,list): legend = [legend]\n for k in ['legendfontscale','legendFontscale']: legend_fontscale=kwargs.get(k,legend_fontscale)\n legend_fontscale=legend_fontscale*fontscale\n for k in ['legendLocation','legendlocation','labelLocation','labellocation','label_location']: legend_location=kwargs.get(k,legend_location)\n\n for k in ['xrange','x_range','wave_range','wrange','wrng']: xrng=kwargs.get(k,xrng)\n if not isinstance(xrng,list): xrng = [xrng]\n for k in ['yrange','y_range','flux_range','frange','frng']: yrng=kwargs.get(k,yrng)\n if not isinstance(yrng,list): yrng = [yrng]\n\n for k in ['multilayout','multiLayout','multi_layout']: layout=kwargs.get(k,layout)\n for k in ['file','filename']: output=kwargs.get(k,output)\n if not isinstance(output,str): output=''\n filetype = '.pdf'\n if output!='': filetype=output.split('.')[-1]\n\n if comparison != None and isinstance(comparison,splat.Spectrum) == False and isinstance(comparison,list) == False: \n print('plotSpectrum() Warning: comparison spectrum should be a splat Spectrum object, you passed {}'.format(comparison))\n comparison = None\n\n# some plotting constants\n xlabel_default = 'Wavelength'\n ylabel_deafult = 'Flux'\n\n# telluric bands in micron\n telluric_bands = [[1.1,1.2]*u.micron,[1.3,1.5]*u.micron,[1.75,2.0]*u.micron]\n\n# assign features by group\n if not isinstance(features,list): features = [features]\n if ldwarf==True or mdwarf==True: features.extend(['k','na','feh','tio','co','h2o','h2'])\n if tdwarf==True: features.extend(['k','ch4','h2o','h2'])\n if young==True: features.extend(['vo'])\n if binary==True: features.extend(['sb'])\n\n# clean repeats in features while maintaining order - set does not do this\n if len(features)>0:\n fea = []\n for i in features:\n if i not in fea: fea.append(i)\n features = fea\n\n\n# if a list is passed, use this list\n splist = copy.deepcopy(inp)\n if isinstance(splist,list) == False: splist = [splist]\n \n# set up for multiplot\n if len(splist) == 1: multiplot = False\n \n# array of lists => force multiplot\n elif len(splist) > 1 and isinstance(splist[0],list) == True: multiplot = True\n else: pass\n\n# reformat array of spectra of multiplot is used (i.e., user forgot to set)\n if multiplot == True and isinstance(splist[0],splat.Spectrum):\n splist = [[s] for s in splist]\n\n elif multiplot == False and isinstance(splist[0],splat.Spectrum):\n splist = [splist]\n \n# flatten array if multiplot is not set\n elif multiplot == False and isinstance(splist[0],list) and len(splist) > 1:\n splist = [[item for sublist in splist for item in sublist]] # flatten\n else: pass\n\n# total number of spectra - use to assign default legends\n allsps = [item for sublist in splist for item in sublist] # Total number of spectra\n if len(legend) == 0: legend=[sp.name for sp in allsps]\n if len(legend) < len(allsps):\n legend.extend([allsps[i].name for i in range(len(legend),len(allsps)-len(legend))])\n \n\n# now run a loop through the input subarrays\n plt.close('all')\n\n# set up here for multiple file output\n nplot = 1\n if multipage == True or multiplot == True:\n nplot = layout[0]*layout[1]\n numpages = int(len(splist) / nplot) + 1\n if (len(splist) % nplot == 0):\n numpages -= 1\n fig = []\n \n if multipage == True and filetype.lower() == 'pdf':\n pdf_pages = PdfPages(output)\n \n if multipage == False:\n if len(splist) > 1:\n filebase = output.replace('.{}'.format(filetype),'')\n files = [filebase+'{}.'.format(i+1)+filetype for i in numpy.arange(len(splist))]\n else:\n files = [output]\n\n pg_n = 0 # page counter\n plt_n = 0 # plot per page counter\n lg_n = 0 # legend per plot counter\n\n for plts,sp in enumerate(splist):\n# set specific plot parameters\n if not isinstance(sp[0],splat.Spectrum):\n raise ValueError('\\nInput to plotSpectrum has wrong format:\\n\\n{}\\n\\n'.format(sp[0]))\n\n# set up plotting defaults for the list of spectra - REPLACE THIS\n if not isinstance(zeropoint,list): zeropoint = [zeropoint]*len(sp)\n if len(zeropoint) < len(sp): zeropoint.extend([zeropoint[-1] for x in range(len(sp)-len(zeropoint))])\n if not isinstance(color,list): color = [color]*len(sp)\n if len(color) < len(sp): color.extend([color[-1] for x in range(len(sp)-len(color))])\n if not isinstance(linestyle,list): linestyle = [linestyle]*len(sp)\n if len(linestyle) < len(sp): linestyle.extend([linestyle[-1] for x in range(len(sp)-len(linestyle))])\n if not isinstance(linewidth,list): linewidth = [linewidth]*len(sp)\n if len(linewidth) < len(sp): linewidth.extend([linewidth[-1] for x in range(len(sp)-len(linewidth))])\n if not isinstance(alpha,list): alpha = [alpha]*len(sp)\n if len(alpha) < len(sp): alpha.extend([alpha[-1] for x in range(len(sp)-len(alpha))])\n if not isinstance(color_noise,list): color_noise = [color_noise]*len(sp)\n if len(color_noise) < len(sp): color_noise.extend([color_noise[-1] for x in range(len(sp)-len(color_noise))])\n if not isinstance(linestyle_noise,list): linestyle_noise = [linestyle_noise]*len(sp)\n if len(linestyle_noise) < len(sp): linestyle_noise.extend([linestyle_noise[-1] for x in range(len(sp)-len(linestyle_noise))])\n if not isinstance(linewidth_noise,list): linewidth_noise = [linewidth_noise]*len(sp)\n if len(linewidth_noise) < len(sp): linewidth_noise.extend([linewidth_noise[-1] for x in range(len(sp)-len(linewidth_noise))])\n if not isinstance(alpha_noise,list): alpha_noise = [alpha_noise]*len(sp)\n if len(alpha_noise) < len(sp): alpha_noise.extend([alpha_noise[-1] for x in range(len(sp)-len(color_noise))])\n if not isinstance(color_comparison,list): color_comparison = [color_comparison]*len(sp)\n if len(color_comparison) < len(sp): color_comparison.extend([color_comparison[-1] for x in range(len(sp)-len(color_comparison))])\n if not isinstance(linestyle_comparison,list): linestyle_comparison = [linestyle_comparison]*len(sp)\n if len(linestyle_comparison) < len(sp): linestyle_comparison.extend([linestyle_comparison[-1] for x in range(len(sp)-len(linestyle_comparison))])\n if not isinstance(linewidth_comparison,list): linewidth_comparison = [linewidth_comparison]*len(sp)\n if len(linewidth_comparison) < len(sp): linewidth_comparison.extend([linewidth_comparison[-1] for x in range(len(sp)-len(linewidth_comparison))])\n if not isinstance(alpha_comparison,list): alpha_comparison = [alpha_comparison]*len(sp)\n if len(alpha_comparison) < len(sp): alpha_comparison.extend([alpha_comparison[-1] for x in range(len(sp)-len(alpha_comparison))])\n\n# settings that work if the spectrum was read in as legitmate Spectrum object\n try:\n xlabel = kwargs.get('xlabel','{} ({})'.format(sp[0].wave_label,sp[0].wave.unit))\n ylabel = kwargs.get('ylabel','{} ({})'.format(sp[0].flux_label,sp[0].flux.unit))\n except:\n xlabel = kwargs.get('xlabel',xlabel_default)\n ylabel = kwargs.get('ylabel',ylabel_default)\n# initial plot range\n bound = [numpy.nanmin(sp[0].wave.value),numpy.nanmax(sp[0].wave.value)]\n ymax = [numpy.nanquantile(s.flux.value,0.98) for s in sp]\n bound.extend(numpy.array([-0.02,1.3])*numpy.nanmax(ymax)+\\\n numpy.array([numpy.nanmin(zeropoint),numpy.nanmax(zeropoint)+stack*(len(sp)-1)]))\n\n# set colormap if provided\n if colormap != None:\n values = numpy.arange(len(sp))\n color_map = plt.get_cmap(colormap)\n norm = colmap.Normalize(vmin=0, vmax=1.0*values[-1])\n scalarMap = cm.ScalarMappable(norm=norm, cmap=color_map)\n for i in range(len(sp)): color[i] = scalarMap.to_rgba(values[i])\n\n# GENERATE PLOTS\n if multiplot == True or multipage == True:\n plt_n = plts % nplot\n if (plt_n == 0):\n fig.append(plt.figure())\n pg_n += 1\n ax = fig[pg_n-1].add_subplot(layout[0], layout[1], plt_n+1)\n \n# plotting a single plot with all spectra\n else:\n plt.close('all')\n plt_n = 0\n fig = []\n if len(figsize)>0: fig.append(plt.figure(figsize=figsize))\n else: fig.append(plt.figure())\n ax = fig[0].add_subplot(111)\n \n for ii, a in enumerate(sp):\n# zeropoint and stack\n flx = [i+zeropoint[ii] for i in a.flux.value]\n if stack > 0: flx = [f + (len(sp)-ii-1)*stack for f in flx]\n ax.plot(a.wave.value,flx,color=color[ii],linestyle=linestyle[ii], lw=linewidth[ii], alpha=alpha[ii], zorder = 10, label = legend[lg_n]) \n\n# add comparison\n if comparison != None:\n# zeropoint and stack\n cflx = [i+zeropoint[ii] for i in comparison.flux.value]\n if stack > 0: cflx = [f + (len(sp)-ii-1)*stack for f in cflx]\n ax.plot(comparison.wave.value,cflx,color=color_comparison[ii],linestyle=linestyle_comparison[ii], lw=linewidth_comparison[ii], alpha=alpha_comparison[ii], zorder = 10)\n \n# add residual\n if residual == True and len(sp) == 2:\n # Save flux values from first spectrum\n if ii == 0:\n flx0 = [f - (len(sp)-ii-1)*stack for f in flx]\n \n # Subtract fluxes and plot\n elif ii == 1:\n res = [flx0[f_n] - f for f_n, f in enumerate(flx)]\n ax.plot(a.wave.value, res, alpha = alpha_residual[ii], color = color_residual[ii], linsetyle=linestyle_residual[ii], lw=linewidth_residual[ii])\n \n # Fix bound[2] if residual goes below 0\n if numpy.nanmin(res) < bound[2]:\n b0 = numpy.argmin(a.wave.value[a.wave.value > bound[0]])\n b1 = numpy.argmax(a.wave.value[a.wave.value < bound[1]])\n bound[2] = numpy.nanmin(res[b0:b1])\n\n# noise\n if show_noise == True:\n ns = [i+zeropoint[ii] for i in a.noise.value]\n ax.plot(a.wave.value,ns,color=color_noise[ii],linestyle=linestyle_noise[ii],alpha=alpha_noise[ii], lw=linewidth_noise[ii], zorder = 10)\n\n# zeropoint\n if show_zero == True:\n ze = numpy.ones(len(a.flux))*zeropoint[ii]\n ax.plot(a.wave.value,ze,color=color[ii],linestyle=linestyle_zero,alpha=alpha_zero,lw=linewidth_zero, zorder = 10)\n\n# save maximum flux among all spectra for plotting\n# THIS IS VERY SLOW AND IT WOULD BE BETTER TO FIND AN ALTERNATE APPROACH\n if len(features)>0:\n f = interp1d(a.wave,flx,bounds_error=False,fill_value=0.)\n if ii == 0: \n wvmax = numpy.linspace(bound[0],bound[1],nsamples)\n flxmax = numpy.array(f(wvmax))\n else: flxmax = numpy.maximum(flxmax,numpy.array(f(wvmax)))\n\n# legend counter\n lg_n = lg_n + 1 # Increment legend\n\n\n# label features\n# THIS NEEDS TO BE FIXED WITH GRETEL'S STUFF\n if len(features) > 0:\n yoff = 0.02*(bound[3]-bound[2]) # label offset\n fontsize = int((10-numpy.nanmin([(layout[0]*layout[1]-1),6]))*fontscale)\n for ftr in features:\n ftr = ftr.lower()\n if ftr in FEATURE_LABELS:\n ftrc = checkDict(ftr,FEATURE_LABELS)\n if ftrc != False:\n for ii,waveRng in enumerate(FEATURE_LABELS[ftrc]['wavelengths']):\n wRng = waveRng.to(sp[0].wave.unit).value\n# features must be contained in plot range (may change this)\n if numpy.nanmin(wRng) > bound[0] and numpy.nanmax(wRng) < bound[1]:\n wfeature = numpy.where(numpy.logical_and(wvmax >= numpy.nanmin(wRng),wvmax <= numpy.nanmax(wRng)))\n if len(wvmax[wfeature]) == 0: wfeature = numpy.argmax(numpy.absolute(wvmax-numpy.nanmedian(wRng)))\n y = numpy.nanmax(flxmax[wfeature])+yoff\n flxmax[wfeature] = flxmax[wfeature]+3.*yoff\n\n if FEATURE_LABELS[ftrc]['type'] == 'band':\n ax.plot(wRng,[y+yoff]*2,color='k',linestyle='-')\n ax.plot([wRng[0]]*2,[y,y+yoff],color='k',linestyle='-')\n ax.text(numpy.mean(wRng),y+1.5*yoff,FEATURE_LABELS[ftrc]['label'],horizontalalignment='center',fontsize=fontsize)\n else:\n for w in wRng: ax.plot([w]*2,[y,y+yoff],color='k',linestyle='-')\n ax.text(numpy.mean(wRng),y+1.5*yoff,FEATURE_LABELS[ftrc]['label'],horizontalalignment='center',fontsize=fontsize)\n bound[3] = numpy.nanmax([numpy.nanmax(flxmax)+2.*yoff,bound[3]])\n\n# add grid\n if grid == True: ax.grid() \n\n# axis labels \n fontsize = (numpy.round(numpy.max([13./((layout[0]*layout[1])**0.33),5]))) * fontscale\n legend_fontsize = (13-numpy.min([(layout[0]*layout[1]-1),8])) * legend_fontscale\n ax.set_xlabel(xlabel, fontsize = fontsize)\n ax.set_ylabel(ylabel, fontsize = fontsize)\n ax.tick_params(axis='x', labelsize=fontsize)\n ax.tick_params(axis='y', labelsize=fontsize)\n\n# add title\n if title!='': ax.set_title(title)\n\n# log scale?\n if kwargs.get('xlog',False): ax.set_xscale('log',nonposx='clip')\n if kwargs.get('ylog',False): ax.set_yscale('log',nonposy='clip')\n\n# place legend\n if len(legend) > 0:\n if legend_location == 'outside':\n box = ax.get_position()\n ax.set_position([box.x0, box.y0 + box.height * 0.15, box.width * 0.7, box.height * 0.7])\n ax.legend(loc='center left', bbox_to_anchor=(1, 0.5), prop={'size':legend_fontsize})\n else:\n ax.legend(loc=legend_location, prop={'size':legend_fontsize})\n bound[3] = bound[3]+0.1*(bound[3]-bound[2]) # extend axis for in-plot legends\n\n# overplot telluric absorption\n if telluric == True:\n yoff = 0.02*(bound[3]-bound[2]) # label offset\n for waveRng in telluric_bands:\n wR = waveRng.to(sp[0].wave.unit).value\n rect = patches.Rectangle((wR[0],bound[2]),wR[1]-wR[0],bound[3]-bound[2],facecolor=color_telluric,alpha=alpha_telluric,color=color_telluric)\n ax.add_patch(rect)\n ax.text(numpy.mean(wR),bound[2]+3*yoff,r'$\\oplus$',horizontalalignment='center',fontsize=fontsize)\n\n# overplot color swaths for pre-specified bands\n if len(band) > 0:\n for i,b in enumerate(band):\n if not isinstance(b,list): \n try: b = [float(b)-0.5*band_width,float(b)+0.5*band_width]\n except:\n print('\\nWarning: plotSpectrum bands variables should be array of 2-element arrays; you passed {}'.format(band))\n b = [0.,0.]\n rect = patches.Rectangle((b[0],bound[2]),b[1]-b[0],bound[3]-bound[2],facecolor=band_color[i],color=band_color[i],alpha=band_alpha[i])\n ax.add_patch(rect)\n if band_label_position[i].lower() == 'top':\n ax.text(numpy.mean(b),bound[3]-3*yoff,band_label[i],horizontalalignment='center',fontsize=fontsize)\n elif band_label_position[i].lower() == 'middle':\n ax.text(numpy.mean(b),0.5*(bound[2]+bound[3]),band_label[i],horizontalalignment='center',fontsize=fontsize)\n else:\n ax.text(numpy.mean(b),bound[2]+3*yoff,band_label[i],horizontalalignment='center',fontsize=fontsize)\n\n# place inset - RIGHT NOW ONLY SETTING LIMITS WITH FIRST SPECTRUM IN LIST\n if inset == True and len(inset_xrange) == 2:\n ax_inset = fig[pg_n-1].add_axes(inset_position) #, axisbg='white')\n bound2 = inset_xrange\n if len(inset_yrange) == 0:\n b0 = numpy.argmax(sp[0].wave.value > bound2[0])\n b1 = numpy.argmin(sp[0].wave.value < bound2[1])\n inset_yrange = [numpy.nanmin(sp[0].flux.value[b0:b1]),numpy.nanmax(sp[0].flux.value[b0:b1])]\n bound2.extend(inset_yrange)\n db = (bound2[3]-bound2[2])\n bound2[2] = bound2[2]-0.05*db\n bound2[3] = bound2[3]+0.05*db\n ax_inset.axis(bound2)\n inset_fontsize = fontsize*0.7\n\n for ii,a in enumerate(sp):\n flx = [i+zeropoint[ii] for i in a.flux.value]\n ax_inset.plot(a.wave.value,flx,color=colors[ii],linestyle=linestyle[ii],linewidth=linewidth[ii],alpha=alpha[ii]) \n ax_inset.set_xlabel('')\n ax_inset.set_ylabel('')\n ax_inset.tick_params(axis='x', labelsize=inset_fontsize)\n ax_inset.tick_params(axis='y', labelsize=inset_fontsize)\n# ax_inset.legend()\n\n# inset feature labels\n if len(inset_features) > 0:\n yoff = 0.05*(bound2[3]-bound2[2])\n for ftr in inset_features:\n ftrc = checkDict(ftr,FEATURE_LABELS)\n if ftrc != False:\n for ii,waveRng in enumerate(FEATURE_LABELS[ftrc]['wavelengths']):\n wRng = waveRng.to(sp[0].wave.unit).value\n if (numpy.min(wRng) > bound2[0] and numpy.max(wRng) < bound2[1]):\n wfeature = numpy.where(numpy.logical_and(wvmax >= numpy.nanmin(wRng),wvmax <= numpy.nanmax(wRng)))\n if len(wvmax[wfeature]) == 0: wfeature = numpy.argmax(numpy.absolute(wvmax-numpy.nanmedian(wRng)))\n y = numpy.nanmax(flxmax[wfeature])+yoff\n flxmax[wfeature] = flxmax[wfeature]+3.*yoff\n \n if FEATURE_LABELS[ftrc]['type'] == 'band':\n ax_inset.plot(wR,[y+yoff]*2,color='k',linestyle='-')\n ax_inset.plot([wR[0]]*2,[y,y+yoff],color='k',linestyle='-')\n ax_inset.text(numpy.mean(wR),y+2*yoff,FEATURE_LABELS[ftrc]['label'],horizontalalignment='center',fontsize=inset_fontsize)\n else:\n for w in waveRng:\n ax_inset.plot([w]*2,[y,y+yoff],color='k',linestyle='-')\n ax_inset.text(numpy.mean(wR),y+2*yoff,FEATURE_LABELS[ftrc]['label'],horizontalalignment='center',fontsize=inset_fontsize)\n waveRng = [wR[0]-0.02,wR[1]+0.02] # for overlap\n \n# update offset\n if len(inset_features) > 0: bound2[3] = numpy.nanmax([bound2[3],numpy.nanmax(flxmax)+5.*yoff])\n ax_inset.axis(bound2)\n\n# finalize bounding\n if len(xrng) > 0: bound[0:2] = xrng\n if len(yrng) > 0: bound[2:4] = yrng\n if isUnit(bound[0]): bound = [x.value for x in bound]\n ax.axis(bound)\n \n# save to file or display\n# ERROR HERE - CHECK WHAT FILES\n if multipage == False:\n if files[plts] != '' and (plts % nplot == 3 or plts == len(splist)-1):\n if kwargs.get('tight',True) == True: \n plt.savefig(files[plts], bbox_inches='tight')\n else:\n plt.savefig(files[plts])\n if output == '' and not kwargs.get('web',False):\n plt.show()\n if (kwargs.get('interactive',False) != False): plt.ion()\n else: plt.ioff()\n\n\n# save figures in multipage format and write off pdf file\n if multipage == True: \n for pg_n in numpy.arange(numpages):\n# fig[pg_n].text(0.5, 0.04, xlabel, ha = 'center', va = 'center')\n# fig[pg_n].text(0.06, 0.5, ylabel, ha = 'center', va = 'center', rotation = 'vertical')\n fig[pg_n].tight_layout\n fig[pg_n].suptitle(title, fontsize = int(14*fontsize), fontweight = 'bold')\n pdf_pages.savefig(fig[pg_n])\n if filetype.lower() == 'pdf':\n pdf_pages.close()\n\n plt.clf()\n return fig","def plot(self,include_rho=True,show=True,nx=129):\n xs = np.linspace(0.0,1.0,nx)\n plt.plot(xs,self.f0(xs),'b-')\n plt.plot([self.rho_max,self.rho_max],[0.0,1.0],'b:')\n plt.plot(xs,self.f1(xs),'r-')\n plt.plot([self.rho_min,self.rho_min],[0.0,1.0],'r:')\n plt.plot([0.0,1.0],[0.0,1.0],'k--')\n if include_rho:\n plt.plot([self.rho,self.rho],[0.0,1.0],'g:')\n plt.xlim(0.0,1.0)\n plt.ylim(0.0,1.0)\n plt.axes().set_aspect(1.0)\n if show:\n plt.show()","def plot(self):\n\t\tself.plotOfXray().plot()","def plot(self, **kwargs):\n if self.order != None:\n name = str(_constructModelName(self.teff, self.logg, \n self.metal, self.en, self.order, self.path))\n output = kwargs.get('output', str(name) + '.pdf')\n ylim = kwargs.get('yrange', [min(self.flux)-.2, max(self.flux)+.2])\n title = kwargs.get('title')\n save = kwargs.get('save', False)\n \n plt.figure(figsize=(16,6))\n plt.plot(self.wave, self.flux, color='k', \n alpha=.8, linewidth=1, label=name)\n plt.legend(loc='upper right', fontsize=12)\n plt.ylim(ylim) \n \n minor_locator = AutoMinorLocator(5)\n #ax.xaxis.set_minor_locator(minor_locator)\n # plt.grid(which='minor') \n \n plt.xlabel(r'$\\lambda$ [$\\mathring{A}$]', fontsize=18)\n plt.ylabel(r'$Flux$', fontsize=18)\n #plt.ylabel(r'$F_{\\lambda}$ [$erg/s \\cdot cm^{2}$]', fontsize=18)\n if title != None:\n plt.title(title, fontsize=20)\n plt.tight_layout()\n\n if save == True:\n plt.savefig(output)\n plt.show()\n plt.close()\n\n else:\n output = kwargs.get('output'+ '.pdf')\n ylim = kwargs.get('yrange', [min(self.flux)-.2, max(self.flux)+.2])\n title = kwargs.get('title')\n save = kwargs.get('save', False)\n \n plt.figure(figsize=(16,6))\n plt.plot(self.wave, self.flux, color='k', alpha=.8, linewidth=1)\n plt.legend(loc='upper right', fontsize=12)\n plt.ylim(ylim)\n \n minor_locator = AutoMinorLocator(5)\n #ax.xaxis.set_minor_locator(minor_locator)\n # plt.grid(which='minor') \n \n plt.xlabel(r'$\\lambda$ [$\\mathring{A}$]', fontsize=18)\n plt.ylabel(r'$Flux$', fontsize=18)\n #plt.ylabel(r'$F_{\\lambda}$ [$erg/s \\cdot cm^{2}$]', fontsize=18)\n if title != None:\n plt.title(title, fontsize=20)\n plt.tight_layout()\n\n if save == True:\n plt.savefig(output)\n plt.show()\n plt.close()","def plotSpectrum(self, spectrum=None):\n if spectrum is None:\n spectrum = self.spectrometer.getSpectrum()\n\n if len(self.axes.lines) == 0:\n self.axes.plot(self.spectrometer.wavelength, spectrum, 'k')\n self.axes.set_xlabel(\"Wavelength [nm]\")\n self.axes.set_ylabel(\"Intensity [arb.u]\")\n else:\n self.axes.lines[0].set_data( self.spectrometer.wavelength, spectrum) # set plot data\n self.axes.relim()","def plot(self, *args, **kwargs):\n pass","def graphplot(self):\n if self.binned:\n self.line.set_ydata(self.fft_bins_y)\n else:\n self.line.set_ydata(self.spec_y)\n self.line2.set_ydata(self.wave_y)\n self.ax1.draw_artist(self.ax1.patch)\n self.ax2.draw_artist(self.ax2.patch)\n self.ax1.draw_artist(self.line)\n self.ax2.draw_artist(self.line2)\n self.fig.canvas.update()\n self.fig.canvas.flush_events()","def plot(self,x,y):\r\n scalex,scaley = self.getScale()\r\n x = x*self.samplerate\r\n x = (x-scalex[0])/(scalex[1]-scalex[0])*self.w\r\n y = (y-scaley[0])/(scaley[1]-scaley[0])*self.h\r\n return (x,y)","def plot_data(x, y, Amp, freq, filename):\n plb.plot(x, y, 'b', linestyle = ':')\n y_fit = Amp * np.sin(freq * x)\n plb.plot(x, y_fit, 'r')\n plb.savefig(filename)","def plotXY(xName,xDataRaw,yName, yDataRaw):\n scanFileHolder = getScanFileHolderXY(xName,xDataRaw,yName, yDataRaw) \n scanFileHolder.plot(xName, yName)\n return scanFileHolder","def plot_xy(xy: np.ndarray, *args: Optional, **kwargs: Optional):\n trj = traja.from_xy(xy)\n trj.traja.plot(*args, **kwargs)","def plot_spectrum(spec, ax=None, **kwargs):\n\n if not spec.data.size or not spec.energy.size or np.all(spec.energy == 0):\n raise ValueError('Spectrum must be loaded and calibrated')\n\n ax = plot_xy(spec.energy, spec.data, ax=ax, **kwargs)\n\n return ax","def plot_spectrum(freqs, fluxes, min_lambda=3700, max_lambda=8000):\n plt.plot(freqs, fluxes)\n plt.xlim((min_lambda, max_lambda))\n plt.xlabel(r'$\\lambda\\, (\\AA)$', size=16)\n plt.ylabel(r'$Flux$', size=16)\n #plt.axes().minorticks_on()","def visualisation(self):\n plt.plot(self.x, self.y, 'o', label = 'Example data')\n plt.plot(self.x, np.dot(self.w, self.X), label = 'Model')\n plt.xlim([-1,1])\n plt.ylim([-1,1])","def plot(self, show=True):\n xs, ys = zip(*[(float(ix)/self.sample_rate, val)\n for ix, val in enumerate(self.samples)])\n plt.plot(xs, ys)\n if show:\n plt.show()","def plot(self, **kwargs):\n\n from ..plot import Plot\n\n p = Plot(1, 1, 1, **kwargs)\n\n p.axes[0].plot(self.dispersion.value, self.flux.value,\n drawstyle='steps-mid')\n\n if self.flux.uncertainty is not None:\n p.axes[0].plot(self.dispersion.value, self.flux.uncertainty.value,\n drawstyle='steps-mid')\n\n p.tidy()\n p.display()","def plot():\n pass","def plot(data,fig,figure_number = 1,xlabel='',ylabel='',title=''):\n fig.add_subplot(1,2,figure_number)\n plt.title(title)\n plt.xlabel(xlabel)\n # only plot the y label if ipython is True, else the plot looks to cramped\n if is_ipython:\n plt.ylabel(ylabel)\n plt.plot(np.array(data),'orange')\n plt.ylim((0,1))\n if not is_ipython:\n plt.pause(0.000001) # pause a bit so that plots are updated","def plot(self):\n\t\tself.plotOfLoopVoltage()","def plot_solution(self, identlist, aperture_lst, plot_ax1=False, **kwargs):\n coeff = kwargs.pop('coeff')\n k = kwargs.pop('k')\n offset = kwargs.pop('offset')\n npixel = kwargs.pop('npixel')\n std = kwargs.pop('std')\n nuse = kwargs.pop('nuse')\n ntot = kwargs.pop('ntot')\n xorder = kwargs.pop('xorder')\n yorder = kwargs.pop('yorder')\n clipping = kwargs.pop('clipping')\n maxiter = kwargs.pop('maxiter')\n\n label_size = 13 # fontsize for x, y labels\n tick_size = 12 # fontsize for x, y ticks\n\n #wave_scale = 'linear'\n wave_scale = 'reciprocal'\n\n #colors = 'rgbcmyk'\n\n self._ax2.cla()\n self._ax3.cla()\n\n if plot_ax1:\n self._ax1.cla()\n x = np.linspace(0, npixel-1, 100, dtype=np.float64)\n\n # find the maximum and minimum wavelength\n wl_min, wl_max = 1e9,0\n allwave_lst = {}\n for aperture in aperture_lst:\n order = k*aperture + offset\n wave = get_wavelength(coeff, npixel, x, np.repeat(order, x.size))\n allwave_lst[aperture] = wave\n wl_max = max(wl_max, wave.max())\n wl_min = min(wl_min, wave.min())\n # plot maximum and minimum wavelength, to determine the display\n # range of this axes, and the tick positions\n self._ax1.plot([0, 0],[wl_min, wl_max], color='none')\n yticks = self._ax1.get_yticks()\n self._ax1.cla()\n\n\n for aperture in aperture_lst:\n order = k*aperture + offset\n color = 'C{}'.format(order%10)\n\n # plot pixel vs. wavelength\n if plot_ax1:\n wave = allwave_lst[aperture]\n if wave_scale=='reciprocal':\n self._ax1.plot(x, 1/wave,\n color=color, ls='-', alpha=0.8, lw=0.8)\n else:\n self._ax1.plot(x, wave,\n color=color, ls='-', alpha=0.8, lw=0.8)\n\n # plot identified lines\n if aperture in identlist:\n list1 = identlist[aperture]\n pix_lst = list1['pixel']\n wav_lst = list1['wavelength']\n mask = list1['mask'].astype(bool)\n res_lst = list1['residual']\n\n if plot_ax1:\n if wave_scale=='reciprocal':\n self._ax1.scatter(pix_lst[mask], 1/wav_lst[mask],\n c=color, s=20, lw=0, alpha=0.8)\n self._ax1.scatter(pix_lst[~mask], 1/wav_lst[~mask],\n c='w', s=16, lw=0.7, alpha=0.8,\n edgecolor=color)\n else:\n self._ax1.scatter(pix_lst[mask], wav_lst[mask],\n c=color, s=20, lw=0, alpha=0.8)\n self._ax1.scatter(pix_lst[~mask], wav_lst[~mask],\n c='w', s=16, lw=0.7, alpha=0.8,\n edgecolor=color)\n\n repeat_aper_lst = np.repeat(aperture, pix_lst.size)\n self._ax2.scatter(repeat_aper_lst[mask], res_lst[mask],\n c=color, s=20, lw=0, alpha=0.8)\n self._ax2.scatter(repeat_aper_lst[~mask], res_lst[~mask],\n c='w', s=16, lw=0.7, alpha=0.8, ec=color)\n self._ax3.scatter(pix_lst[mask], res_lst[mask],\n c=color, s=20, lw=0, alpha=0.8)\n self._ax3.scatter(pix_lst[~mask], res_lst[~mask],\n c='w', s=16, lw=0.7, alpha=0.8, ec=color)\n\n # refresh texts in the residual panels\n text = 'R.M.S. = {:.5f}, N = {}/{}'.format(std, nuse, ntot)\n self._ax3._residual_text.set_text(text)\n text = u'Xorder = {}, Yorder = {}, clipping = \\xb1{:g}, Niter = {}'.format(\n xorder, yorder, clipping, maxiter)\n self._ax2._fitpar_text.set_text(text)\n\n # adjust layout for ax1\n if plot_ax1:\n self._ax1.set_xlim(0, npixel-1)\n if wave_scale == 'reciprocal':\n _y11, _y22 = self._ax1.get_ylim()\n newtick_lst, newticklabel_lst = [], []\n for tick in yticks:\n if _y11 < 1/tick < _y22:\n newtick_lst.append(1/tick)\n newticklabel_lst.append(tick)\n self._ax1.set_yticks(newtick_lst)\n self._ax1.set_yticklabels(newticklabel_lst)\n self._ax1.set_ylim(_y22, _y11)\n self._ax1.set_xlabel('Pixel', fontsize=label_size)\n self._ax1.set_ylabel(u'\\u03bb (\\xc5)', fontsize=label_size)\n self._ax1.grid(True, ls=':', color='gray', alpha=1, lw=0.5)\n self._ax1.set_axisbelow(True)\n self._ax1._aperture_text.set_text('')\n for tick in self._ax1.xaxis.get_major_ticks():\n tick.label1.set_fontsize(tick_size)\n for tick in self._ax1.yaxis.get_major_ticks():\n tick.label1.set_fontsize(tick_size)\n\n # adjust axis layout for ax2 (residual on aperture space)\n self._ax2.axhline(y=0, color='k', ls='--', lw=0.5)\n for i in np.arange(-3,3+0.1):\n self._ax2.axhline(y=i*std, color='k', ls=':', lw=0.5)\n x1, x2 = self._ax2.get_xlim()\n x1 = max(x1,aperture_lst.min())\n x2 = min(x2,aperture_lst.max())\n self._ax2.set_xlim(x1, x2)\n self._ax2.set_ylim(-6*std, 6*std)\n self._ax2.set_xlabel('Aperture', fontsize=label_size)\n self._ax2.set_ylabel(u'Residual on \\u03bb (\\xc5)', fontsize=label_size)\n for tick in self._ax2.xaxis.get_major_ticks():\n tick.label1.set_fontsize(tick_size)\n for tick in self._ax2.yaxis.get_major_ticks():\n tick.label1.set_fontsize(tick_size)\n\n ## adjust axis layout for ax3 (residual on pixel space)\n self._ax3.axhline(y=0, color='k', ls='--', lw=0.5)\n for i in np.arange(-3,3+0.1):\n self._ax3.axhline(y=i*std, color='k', ls=':', lw=0.5)\n self._ax3.set_xlim(0, npixel-1)\n self._ax3.set_ylim(-6*std, 6*std)\n self._ax3.set_xlabel('Pixel', fontsize=label_size)\n self._ax3.set_ylabel(u'Residual on \\u03bb (\\xc5)', fontsize=label_size)\n for tick in self._ax3.xaxis.get_major_ticks():\n tick.label1.set_fontsize(tick_size)\n for tick in self._ax3.yaxis.get_major_ticks():\n tick.label1.set_fontsize(tick_size)","def show_waveform(self, peaks=[]):\n if peaks is None:\n peaks = []\n data = self.amplitude\n x_axis = range(0, len(data))\n x_axis = [x / self.fs for x in x_axis]\n plt.plot(x_axis, data)\n plt.axhline(self.height)\n for p in peaks:\n plt.axvline(p / self.fs, color=\"red\", alpha=0.2)\n plt.ylabel(\"Amplitude\")\n plt.xlabel(\"Time (seconds)\")\n plt.title(\"Waveform\")\n plt.show()","def plot_simulation_yz(\n sim: td.Simulation,\n z: float = 0.0,\n y: float = 0.0,\n wavelength: Optional[float] = 1.55,\n figsize: Float2 = (11, 4),\n):\n fig = plt.figure(figsize=figsize)\n if sim.size[2] > 0.1 and sim.size[1] > 0.1:\n gs = mpl.gridspec.GridSpec(1, 2, figure=fig, width_ratios=[1, 1.4])\n ax1 = fig.add_subplot(gs[0, 0])\n ax2 = fig.add_subplot(gs[0, 1])\n if wavelength:\n freq = td.constants.C_0 / wavelength\n sim.plot_eps(z=z, ax=ax1, freq=freq)\n sim.plot_eps(y=y, ax=ax2, freq=freq)\n else:\n sim.plot(z=z, ax=ax1)\n sim.plot(y=y, ax=ax2)\n elif sim.size[2] > 0.1: # 2D grating sim_size_y = 0\n gs = mpl.gridspec.GridSpec(1, 1, figure=fig, width_ratios=[1])\n ax1 = fig.add_subplot(gs[0, 0])\n if wavelength:\n freq = td.constants.C_0 / wavelength\n sim.plot_eps(y=y, ax=ax1, freq=freq)\n else:\n sim.plot(y=y, ax=ax1)\n\n else: # 2D planar component size_z = 0\n gs = mpl.gridspec.GridSpec(1, 1, figure=fig, width_ratios=[1])\n ax1 = fig.add_subplot(gs[0, 0])\n if wavelength:\n freq = td.constants.C_0 / wavelength\n sim.plot_eps(z=z, ax=ax1, freq=freq)\n else:\n sim.plot(z=z, ax=ax1)\n\n plt.show()\n return fig","def draw_plot(self):\n # X axis is auto follow.\n XLEN = 100\n xmax = max(len(self.daq.data0), XLEN)\n xmin = xmax - XLEN\n\n # The Y value will lie between 0.0 and 5.0 volts\n ymax = 5.0\n ymin = 0.0\n\n self.main_plot.set_xbound(lower=xmin, upper=xmax)\n self.main_plot.set_ybound(lower=ymin, upper=ymax)\n\n # Add the grid. Grid looks cool and is actually very helpful.\n self.main_plot.grid(True, color='gray')\n\n pylab.setp(self.main_plot.get_xticklabels(), \n visible=True)\n \n self.plot_data.set_xdata(arange(len(self.daq.data0)))\n self.plot_data.set_ydata(array(self.daq.data0))\n \n self.canvas.draw()","def plot_xy(nc,params,tms,lev=None):\n \n import matplotlib.pyplot as plt\n import ggWRFutils as gW\n from datetime import datetime\n import numpy as np\n wvar={}\n for p in params:\n if p != 'Times':\n if p=='WS10':\n wvar[p]=np.sqrt(nc.variables['U10'][:]**2+nc.variables['U10'][:]**2)\n elif p=='UV10': \n wvar['U10']=nc.variables['U10'][:,:,:] \n wvar['V10']=nc.variables['V10'][:,:,:] \n elif p=='UV':\n wvar['U']=nc.variables['U'][:,lev,:,:] \n wvar['V']=nc.variables['V'][:,lev,:,:] \n elif len(nc.variables[p].shape) > 3:\n wvar[p]=nc.variables[p][:,lev,:,:] \n else: \n wvar[p]=nc.variables[p][:] \n Nx,Ny,Nz,lon,lat,dx,dy=gW.getDimensions(nc)\n for p in params:\n if params[p]=='pcolor':\n plt.pcolor(lon,lat,wvar[p][tms,:,:],shading='flat')\n plt.colorbar()\n if params[p]=='contourf':\n plt.contourf(lon,lat,wvar[p][tms,:,:],50)\n plt.colorbar()\n if params[p]=='contour':\n plt.contourf(lon,lat,wvar[p][tms,:,:])\n plt.colorbar()\n if params[p]=='quiver':\n if p=='UV10':\n plt.quiver(lon[::10,::10],lat[::10,::10],wvar['U10'][tms,::10,::10],wvar['V10'][tms,::10,::10],units='width')\n elif p=='UV':\n plt.quiver(lon,lat,wvar['U'][tms,:,:],wvar['V'][tms,:,:])\n plt.hold(True)\n plt.xlim(lon.min(),lon.max())\n plt.ylim(lat.min(),lat.max())\n fig=plt.gcf()\n return fig","def plot(self, *, ax=..., n_cols=..., line_kw=..., contour_kw=...):\n ...","def plot(self):\n\t\tself.plotOfSpect().plot()","def plots(x_bef,y_bef,z_bef):\r\n # Makes a 3-D plot of the x, y and z axes representing the ball's total trajectory\r\n plt.figure(3)\r\n plot3 = plt.axes(projection=\"3d\")\r\n plot3.plot3D(x_bef,y_bef,z_bef,'blue')\r\n plot3.set_xlabel('x (ft)')\r\n plot3.set_ylabel('y (ft)')\r\n plot3.set_zlabel('z (ft)')\r\n plot3.set_title('Total Trajectory')\r\n \r\n # Makes a 2-D plot of the x, and z axes representing the ball's total 2-D trajectory\r\n plt.figure(4)\r\n plt.plot(x_bef,z_bef)\r\n plt.xlabel('x (ft)')\r\n plt.ylabel('z (ft)')\r\n plt.title('z (ft) vs x (ft)')\r\n plt.show()","def plot(self, num_levels=5):\n Schrodinger1D.plot(self, num_levels)\n xlabel('Electron height, z (nm)')\n ylabel('Energy (GHz)')\n mine = amin(self.energies(num_levels))\n maxe = amax(self.energies(num_levels))\n ylim(mine - (maxe - mine) * .5, maxe + (maxe - mine) * .5)","def plot(self, fig=None, ax=None):\n\n self._plot_setup(fig, ax)\n\n if self.stokes == 'v':\n self.cmap = plt.cm.coolwarm\n\n absmax = max(self.data.max(), self.data.min(), key=abs)\n rms = np.sqrt(np.mean(np.square(self.data)))\n\n logger.debug(f\"Max flux in cutout: {absmax:.2f} mJy.\")\n logger.debug(f\"RMS flux in cutout: {rms:.2f} mJy.\")\n\n self.im = self.ax.imshow(self.data, cmap=self.cmap, norm=self.norm)\n\n if self.options.get('bar', True):\n try:\n self.fig.colorbar(self.im, label=r'Flux Density (mJy beam$^{-1}$)', ax=self.ax)\n except UnboundLocalError:\n logger.error(\"Colorbar failed. Upgrade to recent version of astropy \")\n\n if self.options.get('psf'):\n self.add_psf()\n\n self.add_source_ellipse()","def plot(x, y, z):\n pylab.plot(x, y)\n pylab.plot(x, z)\n pylab.show()","def _xy_plot(cube, x_coord=None, reg_line=False, **plot_kwargs):\n plot_kwargs = deepcopy(plot_kwargs)\n if reg_line:\n if plot_kwargs.get('linestyle', '-') == '-':\n plot_kwargs.setdefault('marker', 'o')\n else:\n plot_kwargs.setdefault('marker', 's')\n plot_kwargs['linestyle'] = 'none'\n plot_kwargs.setdefault('markersize', 3)\n if x_coord is None:\n iris.plot.plot(cube, **plot_kwargs)\n if cube.coords(dim_coords=True):\n coord = cube.coord(dim_coords=True)\n x_data = coord.points\n else:\n coord = None\n x_data = np.arange(cube.shape[0])\n else:\n coord = cube.coord(x_coord)\n iris.plot.plot(coord, cube, **plot_kwargs)\n x_data = coord.points\n if not reg_line:\n return\n plot_kwargs['linestyle'] = '-'\n plot_kwargs['marker'] = None\n plot_kwargs.pop('label', None)\n y_data = cube.data\n reg = linregress(x_data, y_data)\n y_reg = reg.slope * x_data + reg.intercept\n plt.plot(x_data, y_reg, **plot_kwargs)","def __plot(name, x, y):\n import matplotlib.pyplot as plt\n\n plt.plot(x, y)\n plt.xlabel('elements')\n plt.ylabel('time (seconds)')\n plt.savefig(\"{}\".format(name))","def plot(self):\n\t\tself.plotOfSpect()","def plot(self, x_unit='ft', y_unit='psi'):\n\n #Find the grid centers (where the solution exists)\n x_pos = np.cumsum(self.dx_arr) - self.dx_arr[0] / 2.0\n\n #Loop over all stored solutions and plot stair-step line (because\n #pressure is constant over grid block). We skip the first stored values\n #because they are just the initialization values.\n plt.figure()\n for P in self.P_plot:\n plt.plot(x_pos, P)\n\n #Labels, etc.\n plt.xlabel('Reservoir position (' + x_unit + ')')\n plt.ylabel('Pressure (' + y_unit + ')')\n plt.xlim([0, self.res_length])\n plt.show()","def plot_xy(self, subplot = None, center_of_gravity = False, marker = \"b-\"):\n if subplot is None:\n plot = plt.subplot(111)\n\n for mass in self.flatten():\n x,y = mass.geometry.project_xy.plot_coordinates\n subplot.plot(x, y, marker)\n\n if center_of_gravity:\n x, y, _ = mass.center_of_gravity_global.as_tuple()\n subplot.plot(x, y,\"*\")\n\n x, y, _ = self.center_of_gravity_global.as_tuple()\n subplot.plot(x, y, \"o\")\n\n return subplot","def plotSpectrum(self,wavelengths,intensities = 1.0):\n\n fieldAngle,spectralOutput = self.getIntensitySpectum(wavelengths,intensities)\n\n # Do the actual plot\n plot(np.degrees(fieldAngle),spectralOutput)\n grid()\n title(\"Spectral plot\")\n xlabel(\"Angle in degrees\")\n ylabel(\"Intensty\")","def show():\n\tplt.show()","def show_plot(segment_times, sample_freqs, spec, wave, wav_data, vad_feat):\n plt.subplot(3, 1, 1)\n plt.pcolormesh(segment_times, sample_freqs, 10*np.log10(spec), cmap='jet')\n plt.ylabel('Frequency [Hz]')\n plt.xlabel('Time [sec]')\n\n plt.subplot(3,1,2)\n axes = plt.gca()\n axes.set_xlim([0, wave.duration])\n tmp_axis = np.linspace(0, wave.duration, wav_data.shape[0])\n plt.plot(tmp_axis, wav_data/np.abs(np.max(wav_data)))\n plt.xlabel('Time [sec]')\n\n plt.subplot(3,1,3)\n axes = plt.gca()\n axes.set_xlim([0, wave.duration])\n tmp_axis = np.linspace(0, wave.duration, vad_feat.shape[0])\n plt.plot(tmp_axis, vad_feat)\n plt.xlabel('Time [sec]')\n\n plt.savefig('test', bbox_inches='tight')","def generate_plot(self):\r\n\t\tx, y = zip(*[p.p for p in self.universe])\r\n\t\tself.ax.cla()\r\n\t\tself.ax.plot(x, y, '.')\r\n\t\tself.ax.set_title('Universe at time: %d' % self.universe.time)\r\n\t\tself.ax.set_xlim([P_MU-4*P_STD, P_MU+4*P_STD])\r\n\t\tself.ax.set_ylim([P_MU-4*P_STD, P_MU+4*P_STD])","def make_plot(x,y):","def show_graphs ():\n plt.ylim = (0, 300)\n plt.xlim = (0, 300)\n #Set up lidar plot to figure 1\n lidar_plot = plt.figure (1)\n #Assign title\n plt.title ('Lidar data')\n #Assign data\n plt.imshow (lidar_clean)\n #Set up radar plot to figure 2\n radar_plot = plt.figure (2)\n #Assign title\n plt.title ('Radar data')\n #Assign data\n plt.imshow (radar_clean)\n #Show plots\n plt.show ()","def plot_x(t, x):\n plt.figure()\n plt.plot(t, x)\n plt.title(\"Vertical position of the skydiver as a function of time\")\n plt.xlabel(\"Time t [s]\")\n plt.ylabel(\"Height [m]\")\n plt.savefig('Parachute_position.png')","def plot(self, *args, **kwargs):\n raise NotImplementedError","def show_plot(self):\r\n\t\tself.generate_plot()\r\n\t\tplt.show()","def show():\n setup()\n plt.show()","def plot(self, param):\n # process param to be lowercase and without spaces\n param = str(param).lower().replace(\" \", \"\")\n plt.ion() # enable interactive mode\n\n # making plot according to param\n if param == \"illuminantenergy\": # energy of illuminant\n self.illuminant.plot(\"energy\")\n elif param == \"illuminantphotons\": # photons of illuminant\n self.illuminant.plot(\"photons\")\n elif param == \"srgb\": # srgb image of the scene\n plt.imshow(self.srgb)\n plt.show()\n else:\n raise(ValueError, \"Unknown parameter\")","def view(self, lo_en: Quantity = Quantity(0.0, \"keV\"), hi_en: Quantity = Quantity(30.0, \"keV\"),\n figsize: Tuple = (8, 6)):\n if lo_en > hi_en:\n raise ValueError(\"hi_en cannot be greater than lo_en\")\n else:\n lo_en = lo_en.to(\"keV\").value\n hi_en = hi_en.to(\"keV\").value\n\n if len(self._plot_data.keys()) != 0:\n # Create figure object\n plt.figure(figsize=figsize)\n\n # Set the plot up to look nice and professional.\n ax = plt.gca()\n ax.minorticks_on()\n ax.tick_params(axis='both', direction='in', which='both', top=True, right=True)\n\n # Set the title with all relevant information about the spectrum object in it\n plt.title(\"{n} - {o}{i} Spectrum\".format(n=self.src_name, o=self.obs_id, i=self.instrument.upper()))\n for mod_ind, mod in enumerate(self._plot_data):\n x = self._plot_data[mod][\"x\"]\n # If the defaults are left, just update them to the min and max of the dataset\n # to avoid unsightly gaps at the sides of the plot\n if lo_en == 0.:\n lo_en = x.min()\n if hi_en == 30.0:\n hi_en = x.max()\n\n # Cut the x dataset to just the energy range we want\n plot_x = x[(x > lo_en) & (x < hi_en)]\n\n if mod_ind == 0:\n # Read out the data just for line length reasons\n # Make the cuts based on energy values supplied to the view method\n plot_y = self._plot_data[mod][\"y\"][(x > lo_en) & (x < hi_en)]\n plot_xerr = self._plot_data[mod][\"x_err\"][(x > lo_en) & (x < hi_en)]\n plot_yerr = self._plot_data[mod][\"y_err\"][(x > lo_en) & (x < hi_en)]\n plot_mod = self._plot_data[mod][\"model\"][(x > lo_en) & (x < hi_en)]\n\n plt.errorbar(plot_x, plot_y, xerr=plot_xerr, yerr=plot_yerr, fmt=\"k+\", label=\"data\", zorder=1)\n else:\n # Don't want to re-plot data points as they should be identical, so if there is another model\n # only it will be plotted\n plot_mod = self._plot_data[mod][\"model\"][(x > lo_en) & (x < hi_en)]\n\n # The model line is put on\n plt.plot(plot_x, plot_mod, label=mod, linewidth=1.5)\n\n # Generate the legend for the data and model(s)\n plt.legend(loc=\"best\")\n\n # Ensure axis is limited to the chosen energy range\n plt.xlim(lo_en, hi_en)\n\n plt.xlabel(\"Energy [keV]\")\n plt.ylabel(\"Normalised Counts s$^{-1}$ keV$^{-1}$\")\n\n ax.set_xscale(\"log\")\n ax.xaxis.set_major_formatter(ScalarFormatter())\n ax.xaxis.set_minor_formatter(FuncFormatter(lambda inp, _: '{:g}'.format(inp)))\n ax.xaxis.set_major_formatter(FuncFormatter(lambda inp, _: '{:g}'.format(inp)))\n\n plt.tight_layout()\n # Display the spectrum\n plt.show()\n\n # Wipe the figure\n plt.close(\"all\")\n\n else:\n warnings.warn(\"There are no XSPEC fits associated with this Spectrum, you can't view it.\")","def plot(self, num_levels=10,**kwargs):\n Schrodinger1D.plot(self, num_levels,**kwargs)\n xlabel('$\\delta/2\\pi$')\n ylabel('E/h (GHz)')\n ylim(min(self.fluxonium_potential()),min(2*self.energies(num_levels)[-1],max(self.fluxonium_potential())))\n title('(Ej=%.2f , El=%.2f , Ec=%.2f)GHz , ($\\Phi_J=%.2f $,$\\Phi_L=%.2f \\,) \\Phi_0$ ' % (self.Ej, self.El, self.Ec, self.phi,self.phiL))","def plot(self, xminorticks = 250, yminorticks = 0.1,\n show_lims = False, small = False, cumulative = False, return_figure=False,\n *args, **kwargs):\n\n ## Check if there is something in the class to plot\n if hasattr(self, \"wavelength\") and hasattr(self, \"throughput\"):\n\n utils.setup_plot_defaults()\n if hasattr(self._wavelength_units, \"format\"):\n if \"latex\" in self._wavelength_units.format:\n xaxis_label_string = r'$\\textnormal{Wavelength, ' + self._wavelength_units.name + ' (}' + self._wavelength_units._format['latex'] +')$'\n else:\n xaxis_label_string = r'$\\textnormal{Wavelength, ' + self._wavelength_units.name + '}$'\n\n plot_label_string = r'$\\textnormal{' + self.filter_name.replace('_', '\\\\_') + '}$'\n\n yminorLocator = MultipleLocator(yminorticks)\n xminorLocator = MultipleLocator(xminorticks)\n\n if not small:\n fig = plt.figure(figsize=[8, 4])\n else:\n fig = plt.figure(figsize=[4, 2])\n plt.rcParams['font.size'] = 10\n\n fig.subplots_adjust(left = 0.09, bottom = 0.13, top = 0.99,\n right = 0.99, hspace=0, wspace = 0)\n\n ax1 = fig.add_subplot(111)\n\n if cumulative:\n throughput = np.cumsum(self.throughput)/np.sum(self.throughput)\n yaxis_label_string = r'$\\textnormal{Cumulative Throughput}$'\n\n else:\n throughput = self.throughput\n yaxis_label_string = r'$\\textnormal{Fractional Throughput}$'\n\n\n if hasattr(self, \"_plot_colour\"):\n ax1.plot(self.wavelength, throughput, color = self._plot_colour,\n lw = 2, label = plot_label_string)\n else:\n ax1.plot(self.wavelength, throughput, lw = 2, label = plot_label_string)\n\n if show_lims:\n try:\n ax1.plot([self._upper_edge, self._upper_edge], [0,1] ,\n lw = 1.5, alpha = 0.5, ls = ':',\n color = colours.hex['batman'], zorder = 0, )\n ax1.plot([self._lower_edge, self._lower_edge], [0,1] ,\n lw = 1.5, alpha = 0.5, ls = ':',\n color = colours.hex['batman'], zorder = 0, )\n except:\n print(\"Failed\")\n\n ax1.spines['top'].set_visible(True)\n\n ax1.set_xlabel(xaxis_label_string)\n ax1.set_ylabel(yaxis_label_string)\n\n ax1.yaxis.set_minor_locator(yminorLocator)\n ax1.xaxis.set_minor_locator(xminorLocator)\n\n ax1.legend(loc = 0)\n\n if return_figure:\n return fig\n\n plt.show()\n pass\n else:\n warnings.warn(\"Doesn't look like you have loaded a filter into the object\")","def plot(self, inline=True, fname=None, show_colorbar=False):\n color_norm = matplotlib.colors.Normalize(\n vmin=self.decibel_limits[0], vmax=self.decibel_limits[1]\n )\n\n plt.imshow(self.spectrogram[::-1], cmap=\"Greys\", norm=color_norm)\n\n # pick values to show on time and frequency axes\n yvals = self.frequencies.round(-2).astype(int)\n xvals = self.times.round(2)\n y_idx = [int(ti) for ti in np.linspace(0, len(yvals), 8)]\n y_idx[-1] -= 1\n plt.yticks(len(yvals) - np.array(y_idx), yvals[y_idx])\n x_idx = [int(ti) for ti in np.linspace(0, len(xvals), 6)]\n x_idx[-1] -= 1\n plt.xticks(x_idx, xvals[x_idx])\n\n # add axes labels\n plt.ylabel(\"frequency (Hz): mel scale\")\n plt.xlabel(\"time (sec)\")\n\n if show_colorbar:\n plt.colorbar()\n\n # if fname is not None, save to file path fname\n if fname:\n plt.savefig(fname)\n\n # if not saving to file, check if a matplotlib backend is available\n if inline:\n if os.environ.get(\"MPLBACKEND\") is None:\n warnings.warn(\"MPLBACKEND is 'None' in os.environ. Skipping plot.\")\n else:\n plt.show()","def plotPowerSpectrum(self,l_edges,show_angle=True,angle_unit=u.arcmin,fig=None,ax=None,**kwargs):\n\n\t\tif not matplotlib:\n\t\t\traise ImportError(\"matplotlib is not installed, cannot plot the power spectrum!\")\n\n\t\t#Instantiate figure\n\t\tif (fig is None) or (ax is None):\n\t\t\t\n\t\t\tself.fig,self.ax = plt.subplots()\n\n\t\telse:\n\n\t\t\tself.fig = fig\n\t\t\tself.ax = ax\n\n\t\t#Calculate the power spectrum\n\t\tl,Pl = self.powerSpectrum(l_edges)\n\n\t\t#Plot\n\t\tself.ax.plot(l,l*(l+1.)*Pl/(2*np.pi),**kwargs)\n\t\tself.ax.set_xscale(\"log\")\n\t\tself.ax.set_yscale(\"log\")\n\n\t\t#Upper scale shows the angle\n\t\tif show_angle:\n\t\t\tax_top = self.ax.twiny()\n\t\t\tax_top.set_xticks(self.ax.get_xticks())\n\t\t\tax_top.set_xlim(self.ax.get_xlim())\n\t\t\tax_top.set_xticklabels([\"{0:.2f}\".format(((2*np.pi/ell)*u.rad).to(angle_unit).value) for ell in self.ax.get_xticks()])\n\t\t\tax_top.set_xlabel(r\"$\\theta$({0})\".format(angle_unit.to_string()),fontsize=22)\n\n\t\t#Labels\n\t\tself.ax.set_xlabel(r\"$\\ell$\",fontsize=22)\n\t\tself.ax.set_ylabel(r\"$\\ell(\\ell+1)P_\\ell^{\\kappa\\kappa}/2\\pi$\",fontsize=22)","def plot(self, num_levels=10,**kwargs):\n Schrodinger1D.plot(self, num_levels,**kwargs)\n xlabel('$\\delta/2\\pi$')\n ylabel('E/h (GHz)')\n ylim(min(self.flux_qubit_potential()),min(2*self.energies(num_levels)[-1],max(self.flux_qubit_potential())))\n title('Ej=%.2f GHz, El=%.2f GHz, Ec=%.2f GHz, $\\Phi=%.2f \\, \\Phi_0$' % (self.Ej, self.El, self.Ec, self.phi))","def plot_flux( source, ctr_freq, bandwidth, nchan, format1 = False, show = False, **kwargs ):\n\n freqs = psr_u.chan_to_freq( ctr_freq, bandwidth, nchan )\n fluxes = []\n for f in freqs:\n flux = getFlux( f, source, format1 )\n fluxes.append( flux )\n\n if show:\n # Set up figure and axes\n fig = plt.figure()\n ax = fig.add_subplot( 111, facecolor = 'w' )\n\n xText = ax.set_xlabel( r\"Frequency (GHz)\" )\n yText = ax.set_ylabel( r\"Flux (Jy)\" )\n title = ax.set_title( r\"The change in flux (Jy) as a function of frequency (GHz)\" )\n ax.plot( freqs, fluxes, **kwargs )\n plt.show()\n return ax\n else:\n return fluxes","def plot_spectrum(self, sp1d, title=None, color='k'):\n if title is not None:\n self.set_title(title)\n self.set_axis_label(''.join(['Wavelength [', sp1d.wunit.name, ']']),\n 'x')\n self.set_axis_label('Counts', 'y')\n self.axplot.plot(sp1d.wlen, sp1d.counts, color)\n self.axplot.axis('tight')\n self.fig.canvas.draw()\n return","def plot(self, num_levels=10):\n if num_levels == -1:\n num_levels = len(self.energies())\n print(self.energies(num_levels))\n figure(figsize=(20, 5))\n subplot(1, num_levels + 1, 1)\n self.plot_potential()\n #xlabel('$\\phi$')\n for ii, psi2D in enumerate(self.get_2Dpsis(num_levels)):\n subplot(1, num_levels + 1, ii + 2)\n #imshow(psi2D.real,extent=(self.x[0],self.x[-1],self.y[0],self.y[-1]),interpolation=\"None\",aspect='auto')\n imshow(psi2D.real, interpolation=\"None\", aspect='auto')\n xlabel(ii)","def _plot_robot(self):\n try:\n x = 200\n y = 200\n self.ax1.plot(x, y, marker='o', markersize=10, linestyle='None')\n except Exception as err:\n rospy.loginfo(err)","def plot(self, ax, x_coord):\n self._plot_band(ax, x_coord)\n self._plot_label(ax, x_coord)","def set_up(self):\n self.h, = self.ax.plot(self.x, lw=2)\n self.ax.set_ylim(0,100)\n self.ax.set_xlim(0,100)\n self.ax.title.set_text(self.config[\"title\"])\n self.ax.set_xlabel(self.config[\"x_label\"])\n self.ax.set_ylabel(self.config[\"y_label\"])","def view(filename):\n n, data, data_dB,sr,ch=inputwav(filename)\n t=np.linspace(0,n/sr,n)\n py.close()\n fig, (ax1) = py.subplots(nrows=1) \n ax1.plot(t[0:n:100],data[0:n:100],'k-',linewidth=1,label=filename)\n ax1.legend(loc=1)\n ax1.set_ylabel('Amplitude (Rel. Bit)')\n ax1.set_xlabel('Time (s)')","def plot(self):\n self.plotsite()\n self.plotbond()\n plt.show()","def our_plot(ax, event, plot_args, scale=1, limits=None):\n _x = plot_args['x']\n _y = plot_args['y']\n ax.cla()\n ax.plot(_x, _y, zorder=0, color='k', alpha=0.5)\n ax.plot(_x + 200, _y, zorder=0, color='r', alpha=0.5)\n if hasattr(event, 'xdata') and event is not None:\n xmin, xmax, ymin, ymax = limits\n deltax, deltay = xmax - xmin, ymax - ymin\n\n if event.xdata is not None and event.ydata is not None:\n print(event.xdata, event.ydata, xmin, xmax, ymin, ymax, scale)\n ax.set(xlim=[event.xdata - scale * deltax,\n event.xdata + scale * deltax],\n ylim=[event.ydata - scale * deltay,\n event.ydata + scale * deltay])\n ax.set_xticklabels([])\n ax.set_yticklabels([])\n ax.plot([event.xdata], [event.ydata], marker='+', color='k',\n ms=20, alpha=0.25)\n else:\n ax.set(title='Press \"r\" to reset, \"z\" to undo last point')\n\n # plot coords\n for it in range(len(newcoords)):\n ax.scatter(*newcoords[it],\n marker=r\"$ {} $\".format(it),\n color='red', zorder=10)\n for it in range(len(oldcoords)):\n ax.scatter(*oldcoords[it],\n marker=r\"$ {} $\".format(it),\n color='black', zorder=10)","def plot(\n self,\n color_map={\n \"ex\": (1, 0.2, 0.2),\n \"ey\": (1, 0.5, 0),\n \"hx\": (0, 0.5, 1),\n \"hy\": (0.5, 0.2, 1),\n \"hz\": (0.2, 1, 1),\n },\n channel_order=None,\n ):\n\n if channel_order is not None:\n ch_list = channel_order()\n else:\n ch_list = self.channels\n\n n_channels = len(self.channels)\n\n fig = plt.figure()\n fig.subplots_adjust(hspace=0)\n ax_list = []\n for ii, comp in enumerate(ch_list, 1):\n try:\n color = color_map[comp]\n except KeyError:\n color = (0, 0.4, 0.8)\n if ii == 1:\n ax = plt.subplot(n_channels, 1, ii)\n else:\n ax = plt.subplot(n_channels, 1, ii, sharex=ax_list[0])\n self.dataset[comp].plot.line(ax=ax, color=color)\n ax.grid(which=\"major\", color=(0.65, 0.65, 0.65), ls=\"--\", lw=0.75)\n ax.grid(which=\"minor\", color=(0.85, 0.85, 0.85), ls=\"--\", lw=0.5)\n ax.set_axisbelow(True)\n if ii != len(ch_list):\n plt.setp(ax.get_xticklabels(), visible=False)\n\n ax_list.append(ax)","def plot_skyline_5578(fig_size,\n flux_5578,\n flux_5578_medfilt, show_plot=False):\n fig, ax = plt.subplots(figsize=(fig_size, fig_size / 2.5))\n ax.plot(flux_5578, alpha=0.5)\n ax.plot(flux_5578_medfilt, alpha=1.0)\n ax.set_ylabel(r\"Integrated flux of skyline 5578 $\\AA$\")\n ax.set_xlabel(\"Fibre\")\n p01 = np.nanpercentile(flux_5578, 1)\n p99 = np.nanpercentile(flux_5578, 99)\n ax.set_ylim(p01, p99)\n ax.set_title(r\"Checking throughput correction using skyline 5578 $\\AA$\")\n ax.tick_params(axis='both', which='minor')\n if show_plot:\n plt.show()\n\n return fig","def plot_sine_evaluation(real_samples, fake_samples, idx, identifier):\n ### frequency\n seq_length = len(real_samples[0]) # assumes samples are all the same length\n frate = seq_length\n freqs_hz = np.fft.rfftfreq(seq_length)*frate # this is for labelling the plot\n # TODO, just taking axis 0 for now...\n w_real = np.mean(np.abs(np.fft.rfft(real_samples[:, :, 0])), axis=0)\n w_fake = np.mean(np.abs(np.fft.rfft(fake_samples[:, :, 0])), axis=0)\n ### amplitude\n A_real = np.max(np.abs(real_samples[:, :, 0]), axis=1)\n A_fake = np.max(np.abs(fake_samples[:, :, 0]), axis=1)\n ### now plot\n nrow = 2\n ncol = 2\n fig, axarr = plt.subplots(nrow, ncol, sharex='col', figsize=(6, 6))\n # freq\n axarr[0, 0].vlines(freqs_hz, ymin=np.minimum(np.zeros_like(w_real), w_real), ymax=np.maximum(np.zeros_like(w_real), w_real), color='#30ba50')\n axarr[0, 0].set_title(\"frequency\", fontsize=16)\n axarr[0, 0].set_ylabel(\"real\", fontsize=16)\n axarr[1, 0].vlines(freqs_hz, ymin=np.minimum(np.zeros_like(w_fake), w_fake), ymax=np.maximum(np.zeros_like(w_fake), w_fake), color='#ba4730')\n axarr[1, 0].set_ylabel(\"generated\", fontsize=16)\n # amplitude\n axarr[0, 1].hist(A_real, normed=True, color='#30ba50', bins=30)\n axarr[0, 1].set_title(\"amplitude\", fontsize=16)\n axarr[1, 1].hist(A_fake, normed=True, color='#ba4730', bins=30)\n\n fig.savefig('./experiments/plots/' + identifier + '_eval' + str(idx).zfill(4) +'.png')\n plt.clf()\n plt.close()\n return True","def plot_waveforms(data, name, title, directory_name):\n plt.figure(figsize=(20, 10))\n plt.plot(data)\n plt.title(title)\n plt.savefig('./' + directory_name + '/' + name)\n pass","def mplot(m, xlabel='', ylabel='', title='', custom=(7,7)):\n lag = ps.lag_spatial(m.w, m.z)\n fit = ps.spreg.OLS(m.z[:, None], lag[:,None])\n\n # Customize plot\n fig = plt.figure(figsize=custom)\n ax = fig.add_subplot(111)\n\n ax.set_xlabel(xlabel)\n ax.set_ylabel(ylabel)\n fig.suptitle(title)\n\n ax.scatter(m.z, lag, s=60, color='k', alpha=.6)\n ax.plot(lag, fit.predy, color='r')\n\n ax.axvline(0, alpha=0.5)\n ax.axhline(0, alpha=0.5)\n\n return fig","def plot(self, *args, ax=None,\n cmap_name='seismic', if_show=False, **kwargs):\n import matplotlib.pylab as plt\n\n if ax is None:\n ax = plt.gca()\n plt.sca(ax)\n\n plt.imshow(\n self, *args, cmap=plt.get_cmap(cmap_name),\n extent=self.extent, **kwargs\n )\n\n if if_show:\n plt.colorbar(orientation='horizontal')\n plt.show()","def data2energy_plot(params, datadir, ylimmax='auto', plotBIND=False):\n # get dirs\n xypath = sorted(glob.glob(datadir + 'xyv/'))[0]\n KLpath = sorted(glob.glob(datadir + 'KL/'))[0]\n print 'found KL dir : ', KLpath\n # list files\n xyfiles = sorted(glob.glob(xypath + '*.txt'))\n KLfiles = sorted(glob.glob(KLpath + '*.txt'))\n # load setup\n xy0file = sorted(glob.glob(datadir + 'xy.txt'))[0]\n xyv0file = sorted(glob.glob(datadir + 'xyv0.txt'))[0]\n\n # Note the inversion of the naming system below!\n # xy file is mesh, here stored as the variable xy0\n xy0 = np.loadtxt(xy0file, delimiter=',', usecols=(0, 1))\n\n # xyv0 file is initial condition, store as xy and v, etc\n xy = np.loadtxt(xyv0file, delimiter=',', usecols=(0, 1))\n try:\n '''Data is 5D (x,y,theta,phi,psi)'''\n theta, phi, vx, vy, vtheta, vphi, vpsi = \\\n np.loadtxt(xyv0file, delimiter=',', usecols=(2, 3, 5, 6, 7, 8, 9), unpack=True)\n dimension = 5\n except:\n try:\n '''Data is 3D'''\n v0 = np.loadtxt(xyv0file, delimiter=',', usecols=(3, 4))\n dimension = 3\n except:\n '''Data is 2D'''\n v0 = np.loadtxt(xyv0file, delimiter=',', usecols=(2, 3))\n dimension = 2\n\n NLfile = sorted(glob.glob(datadir + 'NL.txt'))[0]\n NL = np.loadtxt(NLfile, dtype='int', delimiter=',')\n # hfile = sorted(glob.glob(datadir+'h.txt'))[0]\n # h = np.loadtxt(hfile)\n h = params['h']\n\n # Load masses, from file, or else from params, or else define it as unity\n if os.path.exists(datadir + 'Mm.txt'):\n Mfile = sorted(glob.glob(datadir + 'Mm.txt'))[0]\n Mm = np.loadtxt(Mfile)\n print 'Loaded mass list from txt file...'\n else:\n try:\n Mm = params['Mm']\n print 'Loaded mass list from params dict...'\n except:\n Mm = np.ones_like(xy0[:, 0])\n print 'le: WARNING: Could not find mass array, defined as unity...'\n\n # Calculate or load initial setup --> assumes KL at h=0 is same as initial\n KL = np.loadtxt(KLfiles[0], delimiter=',')\n BL = NL2BL(NL, KL)\n bo = bond_length_list(xy0, BL)\n\n kL = KL2kL(NL, KL, BL) * params['k']\n nzcount = np.count_nonzero(KL)\n NP = len(xy0[:, 0])\n print('NP = ' + str(NP))\n\n fig = plt.figure(1)\n plt.clf()\n if dimension < 5:\n ax = plt.subplot(2, 1, 1)\n ax2 = plt.subplot(2, 1, 2)\n else:\n ax = plt.subplot(4, 1, 1)\n ax2 = plt.subplot(4, 1, 2)\n ax3 = plt.subplot(4, 1, 3)\n ax4 = plt.subplot(4, 1, 4)\n\n # Calc and plot initial vals\n bU = potential_energy(xy, BL, bo, kL)\n if dimension < 5:\n KE = kinetic_energy(v0, Mm)\n totE = bU + KE\n else:\n KE, KEvec, KE_bulk, T1, T2, T3, T4 = \\\n kinetic_energy_rigidbody(theta, phi, vx, vy, vtheta, vphi, vpsi, Mm, params)\n print 'KE = ', KE\n # Gravitational potential energy\n gU_v = Mm * params['g'] * params['l'] * np.cos(theta)\n gU = np.sum(gU_v)\n totE = bU + KE + gU\n ax4.plot(-h, gU, 'g.') # label='Gravitational')\n # ax3.plot(-h,totE-np.sum(0.5*params['I3']*(vpsi+vphi*np.cos(theta))**2),'k.')\n\n ax.plot(-h, totE - T4, 'k.') # ,label='Total')\n ax3.plot(-h, bU, 'b.') # ,label='Elastic')\n ax2.plot(-h, KE - T4, 'r.') # ,label='Kinetic')\n ax2.plot(-h, T3, 'rx') # ,label='Kinetic')\n\n if plotBIND:\n if 'BIND' in params:\n if len(params['BIND']) > 0:\n BIND = params['BIND']\n fig2 = plt.figure(2)\n plt.clf()\n ax21 = plt.subplot(4, 1, 1)\n ax22 = plt.subplot(4, 1, 2)\n ax23 = plt.subplot(4, 1, 3)\n ax24 = plt.subplot(4, 1, 4)\n # ax.plot(-h,bU,'b.',label='Bulk Potential')\n bulkIND = np.setdiff1d(np.arange(len(xy[:, 0])), BIND)\n gU_bulk = np.sum(gU_v[bulkIND])\n print 'bulkIND = ', bulkIND\n print 'gU_particle4 = ', gU_bulk\n totE_bulk = KE_bulk + bU + gU_bulk\n ax21.plot(-h, totE_bulk, 's', color=[0.3, .3, .3])\n ax22.plot(-h, KE_bulk, 's', color=[1.0, .5, .5]) # ,label='Bulk Kinetic')\n ax23.plot(-h, bU, 'bs')\n ax24.plot(-h, gU_bulk, 's', color=[0.5, 1.0, .5], markeredgecolor='none')\n\n ax21.set_ylabel('Total')\n ax24.set_xlabel('time')\n ax22.set_ylabel('Kinetic')\n ax23.set_ylabel('Elastic')\n ax24.set_ylabel('Gravitational')\n\n # make list of indices to plot\n doall = range(0, len(xyfiles))\n\n print('Plotting energy vs t...')\n for i in doall:\n KL = np.loadtxt(KLfiles[i], delimiter=',')\n iterind = (xyfiles[i].split('_')[-1]).split('.')[0]\n t = float(iterind) * h\n\n if dimension < 5:\n xy = np.loadtxt(xyfiles[i], delimiter=',', usecols=(0, 1))\n v = np.loadtxt(xyfiles[i], delimiter=',', usecols=(2, 3))\n KE = kinetic_energy(v, Mm)\n else:\n x, y, theta, phi = np.loadtxt(xyfiles[i], delimiter=',', usecols=(0, 1, 2, 3), unpack=True)\n vx, vy, vtheta, vphi, vpsi = np.loadtxt(xyfiles[i], delimiter=',', usecols=(5, 6, 7, 8, 9), unpack=True)\n xy = np.dstack((x, y))[0]\n KE, KEvec, KE_bulk, T1, T2, T3, T4 = kinetic_energy_rigidbody(theta, phi, vx, vy, vtheta, vphi, vpsi, Mm,\n params)\n # Gravitational potential energy\n gU_v = Mm * params['g'] ** params['l'] * np.cos(theta)\n gU = np.sum(gU_v)\n\n # redo calculations of BL, bo, kL if bonds were cut\n if np.count_nonzero(KL) != nzcount:\n BL = NL2BL(NL, KL)\n bo = bond_length_list(xy0, BL)\n kL = KL2kL(NL, KL, BL) * params['k']\n nzcount = np.count_nonzero(KL)\n\n if 'shrinkrate' in params:\n if 'prestrain' in params:\n bU = potential_energy(xy, BL, bo * (1. - params['prestrain'] - params['shrinkrate'] * t), kL)\n else:\n bU = potential_energy(xy, BL, bo * (1. - params['shrinkrate'] * t), kL)\n else:\n bU = potential_energy(xy, BL, bo, kL)\n\n if dimension < 5:\n totE = bU + KE\n else:\n totE = bU + KE + gU\n ax4.plot(t, gU, 'g.')\n # ax3.plot(t,totE-np.sum(0.5*params['I3']*(vpsi+vphi*np.cos(theta))**2),'k.')\n # ax3.plot(t,totE-np.sum(0.5*params['I3']*params['w3']**2),'k.')\n\n ax.plot(t, totE - T4, 'k.')\n ax2.plot(t, KE - T4, 'r.')\n # ax2.plot(t,T1,'ro') #,label='Kinetic')\n # ax2.plot(t,T2,'r^') #,label='Kinetic')\n # ax2.plot(t,T3,'rx') #,label='Kinetic')\n ax3.plot(t, bU, 'b.')\n\n if plotBIND:\n if 'BIND' in params:\n if len(params['BIND']) > 0:\n # ax.plot(-h,bU,'b.',label='Bulk Potential')\n ax22.plot(t, KE_bulk, 's', color=[1.0, .5, .5], markeredgecolor='none') # 'Bulk Kinetic'\n gU_bulk = np.sum(gU_v[bulkIND])\n totE_bulk = KE_bulk + bU + gU_bulk\n ax24.plot(t, gU_bulk, 's', color=[0.5, 1.0, .5], markeredgecolor='none')\n ax23.plot(t, bU, 'bs')\n ax21.plot(t, totE_bulk, 's', color=[0.5, .3, .3], markeredgecolor='none') # 'Bulk Total'\n\n title = 'Energy Conservation'\n ax.set_title(title)\n ax.set_ylabel(r'Total - $\\frac{I_3 \\omega_3^2}{2} $')\n ax3.set_xlabel('time')\n ax2.set_ylabel(r'Kinetic - $\\frac{I_3 \\omega_3^2}{2}$')\n ax3.set_ylabel('Elastic')\n\n ax.set_xlim([-h, t])\n ax2.set_xlim([-h, t])\n ax3.set_xlim([-h, t])\n\n if dimension == 5:\n ax4.set_ylabel('Gravitational')\n ax4.set_xlim([-h, t])\n ax3.set_xlabel('')\n ax4.set_xlabel('time')\n ax3.set_xticks([])\n\n # ylimit of first axis is either the last total energy or a large number\n if ylimmax != 'auto':\n ax.set_ylim(0, NP * ylimmax) # np.nanmin((totE,NP*ylimmax)))\n print('ylim_max = ' + str(np.nanmin((totE, NP * ylimmax))))\n\n ax.set_xticks([])\n ax2.set_xticks([])\n\n outname = datadir + 'Energy_vs_t.png'\n plt.figure(1)\n plt.savefig(outname)\n\n if plotBIND:\n if 'BIND' in params:\n if len(params['BIND']) > 0:\n plt.figure(2)\n ax21.set_xlim([-h, t])\n ax22.set_xlim([-h, t])\n ax23.set_xlim([-h, t])\n ax24.set_xlim([-h, t])\n\n ax21.set_xticks([])\n ax22.set_xticks([])\n ax23.set_xticks([])\n\n outname = datadir + 'Energy_vs_t_BIND.png'\n plt.savefig(outname)\n\n # ax.set_xlim([-h,5])\n # ax2.set_xlim([-h,5])\n # ax3.set_xlim([-h,5])\n # ax4.set_xlim([-h,5])\n #\n # ax.set_xticks([])\n # ax2.set_xticks([])\n #\n # outname = datadir+'Energy_vs_t_zoom.png'\n # #plt.show()\n # plt.figure(1)\n # plt.savefig(outname)","def builtin_plot(self, **kwargs):\n self.gp.plot(**kwargs)\n return","def plot_couplingmatrix(self,lmax,nwins,show=True,fname=None):\n figsize = mpl.rcParams['figure.figsize']\n figsize[0] = figsize[1]\n fig = plt.figure(figsize=figsize)\n ax = fig.add_subplot(111)\n coupling_matrix = self.get_couplingmatrix(lmax,nwins)\n ax.imshow(coupling_matrix)\n ax.set_xlabel('output power')\n ax.set_ylabel('input power')\n fig.tight_layout(pad=0.1)\n\n if show: plt.show()\n if fname is not None:\n fig.savefig(fname)","def show():\n plt.show()","def show():\n plt.show()","def show():\n plt.show()","def show(self):\n lines, = pylab.plot(self.wavelengths, self.intensities)\n return lines","def plot_zoom(ax, xlims):\n\n xmin, xmax, ymin, ymax = get_y_lims(ax, xlims)\n ax.set_xlim(xmin, xmax)\n ax.set_ylim(ymin, ymax)\n\n return ax","def plot(axes, axis, values, c='chartreuse'):\n a = axes[axis]\n a.set_xlabel('time (s)')\n x = np.array(range(len(values))) / 1000\n dim = 'x' if axis == 0 else 'y' if axis == 1 else 'z'\n a.set_title('-'.join([dim, 'acceleration']))\n a.plot(x, values / 1000, c=c)","def plot(self): \n\t\txandy = sep_xy(self.start, self.end)\n\t\tplt.plot(xandy[0], xandy[1], 'k-', lw=1, color='blue')","def plot(self):\n pass","def peek(self, **kwargs):\n\n plt.figure()\n axes = plt.gca()\n data_lab=self.meta['OBS-FREQ'][0:2] + ' ' + self.meta['OBS-FREQ'][2:5]\n axes.plot(self.data.index,self.data,label=data_lab)\n axes.set_yscale(\"log\")\n axes.set_ylim(1e-4,1)\n axes.set_title('Nobeyama Radioheliograph')\n axes.set_xlabel('Start time: ' + self.data.index[0].strftime(TIME_FORMAT))\n axes.set_ylabel('Correlation')\n axes.legend()\n plt.show()","def plot_powerlaw(self, **kwargs):\n\n if self.gamma is None:\n self.exponent()\n p = powerlaw.plot(exponent=-self.gamma,\n xmax=self.max_deg, xmin=self.k_min,\n **kwargs\n )\n pylab.show()\n return p","def _plot(self):\r\n fig = plt.figure()\r\n\r\n # Take out second component of intensity if needed\r\n # if self._vna.isTwoComponents():\r\n # intensitySimplified = []\r\n # for i in range(len(self._intensity)):\r\n # tempSet = []\r\n # for j in range(len(self._intensity[i])):\r\n # if (j%2) == 0:\r\n # tempSet.append(self._intensity[i][j])\r\n # intensitySimplified.append(tempSet)\r\n # for i in range(len(self._frequency)):\r\n # plt.plot(self._frequency[i],intensitySimplified[i],label=('%sv' % self._voltages[i][0]))\r\n # else:\r\n for i in range(len(self._frequency)):\r\n plt.plot(self._frequency[i],self._intensity[i],label=('%sv' % self._voltages[i][0]))\r\n plt.legend(loc='upper left')\r\n fig.suptitle('Intensity-Frequency with non-Constant Voltage', fontsize=18)\r\n plt.xlabel('Frequency (Hz)', fontsize=18)\r\n plt.ylabel('Intensity (dBm)', fontsize=16)\r\n\r\n # Save plot\r\n self._saveFig()","def plot(self, x, y, mX = 1, mY = 1):\n x = self.xy[x]\n y = self.xy[y]\n\n # Find pareto front:\n xp, yp = self.pareto_frontier(x,y, mX, mY)\n\n plt.plot(x, y, 'o')\n plt.plot(xp, yp, '-')\n plt.tight_layout()\n plt.show()","def plot_track_rigidbody(params, datadir, pp=4, zoom=None):\n h = params['h']\n\n # get dirs\n xypath = sorted(glob.glob(datadir + 'xyv/'))[0]\n # list files\n xyfiles = sorted(glob.glob(xypath + '*.txt'))\n\n plt.clf()\n ax1 = plt.subplot(5, 1, 1)\n ax2 = plt.subplot(5, 1, 2)\n ax3 = plt.subplot(5, 1, 3)\n ax4 = plt.subplot(5, 1, 4)\n ax5 = plt.subplot(5, 1, 5)\n doall = range(0, len(xyfiles))\n for i in doall:\n iterind = (xyfiles[i].split('_')[-1]).split('.')[0]\n t = float(iterind) * h\n\n x, y, theta, phi, psi = np.loadtxt(xyfiles[i], delimiter=',', usecols=(0, 1, 2, 3, 4), unpack=True)\n # vX,vY,vtheta,vphi,vpsi = np.loadtxt(xyfiles[i],delimiter=',', usecols=(5,6,7,8,9), unpack=True)\n\n ax1.plot(t, x[pp], 'k.')\n ax2.plot(t, y[pp], 'r.')\n ax3.plot(t, theta[pp], 'r.')\n ax4.plot(t, phi[pp], 'r.')\n ax5.plot(t, psi[pp], 'g.')\n\n title = 'Tracking Single Gyro'\n ax1.set_title(title)\n ax5.set_xlabel('time')\n ax1.set_ylabel('X')\n ax2.set_ylabel('Y')\n ax3.set_ylabel(r'$\\theta$')\n ax4.set_ylabel(r'$\\phi$')\n ax5.set_ylabel(r'$\\psi$')\n\n ax1.set_xlim([-h, t])\n ax2.set_xlim([-h, t])\n ax3.set_xlim([-h, t])\n ax4.set_xlim([-h, t])\n ax5.set_xlim([-h, t])\n\n ax1.set_xticks([])\n ax2.set_xticks([])\n ax3.set_xticks([])\n ax4.set_xticks([])\n\n outname = datadir + 'Track.png'\n plt.savefig(outname)\n\n if zoom != None:\n ax1.set_xlim([-h, zoom])\n ax2.set_xlim([-h, zoom])\n ax3.set_xlim([-h, zoom])\n ax4.set_xlim([-h, zoom])\n ax5.set_xlim([-h, zoom])\n\n outname = datadir + 'Track_zoom.png'\n plt.savefig(outname)","def showPlot1(title, x_label, y_label):\n num_robot_range = range(1, 11)\n times1 = []\n times2 = []\n for num_robots in num_robot_range:\n print \"Plotting\", num_robots, \"robots...\"\n times1.append(runSimulation(num_robots, 1.0, 20, 20, 0.8, 20, StandardRobot))\n times2.append(runSimulation(num_robots, 1.0, 20, 20, 0.8, 20, RandomWalkRobot))\n pylab.plot(num_robot_range, times1)\n pylab.plot(num_robot_range, times2)\n pylab.title(title)\n pylab.legend(('StandardRobot', 'RandomWalkRobot'))\n pylab.xlabel(x_label)\n pylab.ylabel(y_label)\n pylab.show()","def display1(*args):\n #----------*----------* # unpack\n twiss_func = args[0]\n lat_plot = args[3]\n #-------------------- beta x,y & dispersion x\n s = [twiss_func(i,'s') for i in range(twiss_func.nbpoints)]\n bx = [twiss_func(i,'bx') for i in range(twiss_func.nbpoints)]\n by = [twiss_func(i,'by') for i in range(twiss_func.nbpoints)]\n dx = [twiss_func(i,'dx') for i in range(twiss_func.nbpoints)]\n #-------------------- lattice viseo\n vzero = [0. for i in range(lat_plot.nbpoints)] # zero line\n vis_abszisse = [lat_plot(i,'s') for i in range(lat_plot.nbpoints)]\n vis_ordinate = [lat_plot(i,'viseo') for i in range(lat_plot.nbpoints)]\n #-------------------- figure frame\n width=14; height=7.6\n plt.figure(num=0,figsize=(width,height),facecolor='#eaecef',tight_layout=False)\n\n #-------------------- transverse X\n splot111=plt.subplot(111)\n splot111.set_title('beta functions')\n plt.plot(s,bx, label=r'$\\beta_x$ [m]', color='red', linestyle='-') # beta x\n plt.plot(s,by, label=r'$\\beta_y$ [m]', color='blue', linestyle='-') # beta y\n plt.plot(s,dx, label=r'$\\eta_x$ [m]' , color='green',linestyle='-') # dispersion x\n vscale=splot111.axis()[3]*0.25\n viseoz = [x*vscale for x in vis_ordinate]\n plt.plot(vis_abszisse,viseoz,label='',color='black')\n plt.plot(vis_abszisse,vzero,color='black')\n plt.legend(loc='lower right',fontsize='x-small')","def visualize_signal(self):\n plt.figure()\n plt.title('Accelerometer Signal')\n plt.plot(range(len(self.data)), self.data[1])","def raster_plot(nucleus, label=None, **kwargs):\r\n\r\n # Get fireds data\r\n fireds = nucleus.historique['fired']\r\n\r\n # Build x-axis and y-axis data by looping through fireds\r\n xdata, ydata = [], []\r\n for x, fires in fireds.items():\r\n for y in fires:\r\n xdata.append(x)\r\n ydata.append(y)\r\n\r\n # Matplotlib\r\n fig = plt.figure()\r\n plt.plot(xdata, ydata, '|', **kwargs)\r\n plt.ylabel('Neuron indexes')\r\n plt.xlabel('time')\r\n if label is None and nucleus.label is None:\r\n plt.title('Raster plot')\r\n elif label is not None and nucleus.label is None:\r\n plt.title('Raster plot (%s)' % label)\r\n elif label is None and nucleus.label is not None:\r\n plt.title('Raster plot of %s' % nucleus.label)\r\n else:\r\n plt.title('Raster plot of %s (%s)' % (nucleus.label, label))\r\n\r\n return fig","def plot(self, A = None):\r\n if A is not None: self.A = A\r\n self.im.set_data(self.A)\r\n self.ax.draw_artist(self.im)\r\n self.fig.canvas.blit(self.ax.bbox)","def plot_linear(x_range, w, b):\n\tplt.plot(x_range, x_range * w + b)","def plot_motion(x, y):\n plt.xlabel(\"X Position (m)\")\n plt.ylabel(\"Y Position (m)\")\n plt.plot(x, y)\n plt.show()","def plot_3d(self, ax_3d: Axes3D, lims_x: array_like = (-1, 1), lims_y: array_like = (-1, 1), **kwargs) -> None:\n X, Y, Z = self.to_mesh(lims_x, lims_y)\n\n ax_3d.plot_surface(X, Y, Z, **kwargs)"],"string":"[\n \"def liveplot(x, y, xlim, ylim, title):\\n plt.plot(x,y,'b.')\\n plt.xlim(xlim)\\n plt.ylim(ylim)\\n plt.xlabel('North-South Axis')\\n plt.ylabel('East-West Axis')\\n plt.title(title)\\n plt.show()\",\n \"def plot_xyz():\\n plt.subplot(3,1,1) # for x axis\\n plt.title('x value v.s. time')\\n plt.grid(True)\\n plt.ylabel('X')\\n plt.xlabel('t')\\n plt.plot(x, '-r')\\n\\n plt.subplot(3,1,2) # for y axis\\n plt.title('y value v.s. time')\\n plt.grid(True)\\n plt.ylabel('Y')\\n plt.xlabel('t')\\n plt.plot(y, '-g')\\n\\n plt.subplot(3,1,3) # for z axis\\n plt.title('z value v.s. time')\\n plt.grid(True)\\n plt.ylabel('Z')\\n plt.xlabel('t')\\n plt.plot(z, '-b')\",\n \"def xyplot(x_vals,y_vals,name):\\n # set the figure's size\\n set_figsize(figsize=(5, 2.5))\\n # detach() is used to get a variable from the current calculation graph\\n # in which this variable is the not gradient tracking version\\n plt.plot(x_vals.detach().numpy(), y_vals.detach().numpy())\\n # set the constant x axis label\\n plt.xlabel('x')\\n # combine and set the y axis label\\n plt.ylabel(name+'(x)')\\n plt.show()\",\n \"def plot_xy(x, y, ax=None, xlabel='Energy [keV]', **kwargs):\\n\\n if not ax:\\n new_plot = True\\n plt.figure()\\n ax = plt.axes()\\n else:\\n new_plot = False\\n\\n plt.semilogy(x, y, axes=ax, drawstyle='steps-mid', **kwargs)\\n\\n if new_plot:\\n plt.xlabel(xlabel)\\n plt.ylabel('Counts')\\n\\n if 'label' in kwargs:\\n plt.legend()\\n plt.show()\\n\\n return ax\",\n \"def plotWavelet(self):\\n\\n a = 0\\n if(self.axQT is not None):\\n self._bxPlot()\\n a += 1\\n if(self.bxQT is not None):\\n self._cxPlot()\\n a += 1\\n\\n if(a > 0):\\n return\\n\\n self._setupPlot()\\n self._axPlot()\\n self._bxPlot()\\n self._cxPlot()\\n self._dxPlot()\\n self._endingPlot()\",\n \"def plot(self):\\n plot_spectrum(self.data, self.fig, self.ax_e, self.ax_s, title = \\\"Solar spectrum\\\")\",\n \"def plot_simulation_xz(\\n sim: td.Simulation,\\n x: float = 0.0,\\n z: float = 0.0,\\n wavelength: Optional[float] = 1.55,\\n figsize: Float2 = (11, 4),\\n):\\n fig = plt.figure(figsize=figsize)\\n gs = mpl.gridspec.GridSpec(1, 2, figure=fig, width_ratios=[1, 1.4])\\n ax1 = fig.add_subplot(gs[0, 0])\\n ax2 = fig.add_subplot(gs[0, 1])\\n if wavelength:\\n freq = td.constants.C_0 / wavelength\\n sim.plot_eps(z=z, ax=ax1, freq=freq)\\n sim.plot_eps(x=x, ax=ax2, freq=freq)\\n else:\\n sim.plot(z=z, ax=ax1)\\n sim.plot(x=x, ax=ax2)\\n plt.show()\\n return fig\",\n \"def plot(self, ax=..., *, name=..., **kwargs):\\n ...\",\n \"def show_plot() :\\n logger.info(\\\"Show plot\\\")\\n pylab.axis('equal')\\n pylab.xlabel(\\\"Longitud\\\")\\n pylab.ylabel(\\\"Latitud\\\")\\n pylab.grid(True)\\n pylab.title(\\\"Product tiles and product source\\\")\\n pylab.show()\",\n \"def plot_xy(self, xpts, ypts):\\n self.plot(np.asarray((xpts, ypts)).T)\",\n \"def plotSpectrum(inp,xrng=[],yrng=[],xlabel='',ylabel='',xlog=False,ylog=False,grid=False,\\n legend=[],legend_location='upper right',fontscale=1,legend_fontscale=1,title='',\\n color='k',colormap=None,linestyle='-',linewidth=1.5,alpha=1.,\\n show_noise=True,color_noise='k',linestyle_noise='-',linewidth_noise=1.5,alpha_noise=0.5,\\n comparison=None,color_comparison='grey',linestyle_comparison='-',linewidth_comparison=1.5,alpha_comparison=1,\\n residual=False,color_residual='m',linestyle_residual='-',linewidth_residual=1.5,alpha_residual=0.5,\\n telluric=False,color_telluric='grey',linestyle_telluric='-',linewidth_telluric=1.5,alpha_telluric=0.2,\\n features=[],mdwarf=False,ldwarf=False,tdwarf=False,young=False,binary=False,nsamples=100,\\n band=[],band_color='k',band_alpha=0.2,band_label='',band_label_position='bottom',band_width=0.1,\\n show_zero=True,stack=0.,zeropoint=0.,color_zero='k',linestyle_zero=':',linewidth_zero=1.5,alpha_zero=0.3,\\n inset=False,inset_xrange=[],inset_yrange=[],inset_position=[0.65,0.60,0.20,0.20],inset_features=False,\\n output='',multiplot=False,multipage=False,layout=[1,1],figsize=[],tight=True,\\n interactive=False,**kwargs):\\n\\n# keyword parameters (for backward compatability)\\n for k in ['showZero','showzero']: show_zero=kwargs.get(k,show_zero)\\n for k in ['showNoise','noise','uncertainty','shownoise','showuncertainty','show_uncertainty']: show_noise=kwargs.get(k,show_noise)\\n\\n for k in ['line_style','lineStyle','ls','linestyles','line_styles']: linestyle=kwargs.get(k,linestyle)\\n for k in ['line_width','lineWidth','width','lw','linewidths','line_widths']: linewidth=kwargs.get(k,linewidth)\\n for k in ['colors','colour','colours']: color=kwargs.get(k,color)\\n for k in ['colorScheme','color_scheme','colorscheme','colorMap','color_map']: colormap=kwargs.get(k,colormap)\\n\\n for k in ['colornoise','colorNoise','colorUnc','coloruncertainty','color_uncertainty','colorUncertainty']: color_noise=kwargs.get(k,color_noise)\\n for k in ['linestylenoise','line_style_noise','linestyleNoise']: linestyle_noise=kwargs.get(k,linestyle_noise)\\n for k in ['linewidthnoise','linewidthNoise','line_width_noise']: linewidth_noise=kwargs.get(k,linewidth_noise)\\n for k in ['alphanoise','alphaNoise']: alpha_noise=kwargs.get(k,alpha_noise)\\n\\n for k in ['colorzero','colorZero']: color_zero=kwargs.get(k,color_zero)\\n for k in ['linestylezero','line_style_zero','linestyleZero']: linestyle_zero=kwargs.get(k,linestyle_zero)\\n for k in ['linewidthzero','linewidthZero','line_width_zero']: linewidth_zero=kwargs.get(k,linewidth_zero)\\n for k in ['alphazero','alphaZero']: alpha_zero=kwargs.get(k,alpha_zero)\\n\\n for k in ['colorcomparison','colorComparison']: color_comparison=kwargs.get(k,color_comparison)\\n for k in ['linestyleComparison','line_style_comparison','linestylecomparison']: linestyle_comparison=kwargs.get(k,linestyle_comparison)\\n for k in ['linewidthcomparison','linewidthComparison','line_width_comparison']: linewidth_comparison=kwargs.get(k,linewidth_comparison)\\n for k in ['alphacomparison','alphaComparison']: alpha_comparison=kwargs.get(k,alpha_comparison)\\n\\n for k in ['colorresidual','colorResidual']: color_residual=kwargs.get(k,color_residual)\\n for k in ['linestyleresidual','line_style_residual','linestyleResidual']: linestyle_residual=kwargs.get(k,linestyle_residual)\\n for k in ['linewidthresidual','linewidthResidual','line_width_residual']: linewidth_residual=kwargs.get(k,linewidth_residual)\\n for k in ['alpharesidual','alphaResidual']: alpha_residual=kwargs.get(k,alpha_residual)\\n\\n for k in ['bands']: band=kwargs.get(k,band)\\n if len(band) == 2 and isinstance(band[0],list) == False: band = [band]\\n for k in ['bandcolors','bandcolor','band_colors']: band_color=kwargs.get(k,band_color)\\n for k in ['bandalphas','band_alphas','bandalpha']: band_alpha=kwargs.get(k,band_alpha)\\n for k in ['band_labels','bandlabel','bandlabels']: band_label=kwargs.get(k,band_label)\\n for k in ['band_label_positions','bandlabelposition','bandlabelpositions']: band_label_position=kwargs.get(k,band_label_position)\\n for k in ['bandwidth','bandwidths','band_widths']: band_width=kwargs.get(k,band_width)\\n for par in [band_color,band_alpha,band_label,band_label_position,band_width]:\\n if not isinstance(par,list): par = [par]*len(band)\\n if len(par) < len(band): par.extend([par[-1] for x in range(len(band)-len(par))])\\n\\n for k in ['legends','label','labels']: legend=kwargs.get(k,legend)\\n if not isinstance(legend,list): legend = [legend]\\n for k in ['legendfontscale','legendFontscale']: legend_fontscale=kwargs.get(k,legend_fontscale)\\n legend_fontscale=legend_fontscale*fontscale\\n for k in ['legendLocation','legendlocation','labelLocation','labellocation','label_location']: legend_location=kwargs.get(k,legend_location)\\n\\n for k in ['xrange','x_range','wave_range','wrange','wrng']: xrng=kwargs.get(k,xrng)\\n if not isinstance(xrng,list): xrng = [xrng]\\n for k in ['yrange','y_range','flux_range','frange','frng']: yrng=kwargs.get(k,yrng)\\n if not isinstance(yrng,list): yrng = [yrng]\\n\\n for k in ['multilayout','multiLayout','multi_layout']: layout=kwargs.get(k,layout)\\n for k in ['file','filename']: output=kwargs.get(k,output)\\n if not isinstance(output,str): output=''\\n filetype = '.pdf'\\n if output!='': filetype=output.split('.')[-1]\\n\\n if comparison != None and isinstance(comparison,splat.Spectrum) == False and isinstance(comparison,list) == False: \\n print('plotSpectrum() Warning: comparison spectrum should be a splat Spectrum object, you passed {}'.format(comparison))\\n comparison = None\\n\\n# some plotting constants\\n xlabel_default = 'Wavelength'\\n ylabel_deafult = 'Flux'\\n\\n# telluric bands in micron\\n telluric_bands = [[1.1,1.2]*u.micron,[1.3,1.5]*u.micron,[1.75,2.0]*u.micron]\\n\\n# assign features by group\\n if not isinstance(features,list): features = [features]\\n if ldwarf==True or mdwarf==True: features.extend(['k','na','feh','tio','co','h2o','h2'])\\n if tdwarf==True: features.extend(['k','ch4','h2o','h2'])\\n if young==True: features.extend(['vo'])\\n if binary==True: features.extend(['sb'])\\n\\n# clean repeats in features while maintaining order - set does not do this\\n if len(features)>0:\\n fea = []\\n for i in features:\\n if i not in fea: fea.append(i)\\n features = fea\\n\\n\\n# if a list is passed, use this list\\n splist = copy.deepcopy(inp)\\n if isinstance(splist,list) == False: splist = [splist]\\n \\n# set up for multiplot\\n if len(splist) == 1: multiplot = False\\n \\n# array of lists => force multiplot\\n elif len(splist) > 1 and isinstance(splist[0],list) == True: multiplot = True\\n else: pass\\n\\n# reformat array of spectra of multiplot is used (i.e., user forgot to set)\\n if multiplot == True and isinstance(splist[0],splat.Spectrum):\\n splist = [[s] for s in splist]\\n\\n elif multiplot == False and isinstance(splist[0],splat.Spectrum):\\n splist = [splist]\\n \\n# flatten array if multiplot is not set\\n elif multiplot == False and isinstance(splist[0],list) and len(splist) > 1:\\n splist = [[item for sublist in splist for item in sublist]] # flatten\\n else: pass\\n\\n# total number of spectra - use to assign default legends\\n allsps = [item for sublist in splist for item in sublist] # Total number of spectra\\n if len(legend) == 0: legend=[sp.name for sp in allsps]\\n if len(legend) < len(allsps):\\n legend.extend([allsps[i].name for i in range(len(legend),len(allsps)-len(legend))])\\n \\n\\n# now run a loop through the input subarrays\\n plt.close('all')\\n\\n# set up here for multiple file output\\n nplot = 1\\n if multipage == True or multiplot == True:\\n nplot = layout[0]*layout[1]\\n numpages = int(len(splist) / nplot) + 1\\n if (len(splist) % nplot == 0):\\n numpages -= 1\\n fig = []\\n \\n if multipage == True and filetype.lower() == 'pdf':\\n pdf_pages = PdfPages(output)\\n \\n if multipage == False:\\n if len(splist) > 1:\\n filebase = output.replace('.{}'.format(filetype),'')\\n files = [filebase+'{}.'.format(i+1)+filetype for i in numpy.arange(len(splist))]\\n else:\\n files = [output]\\n\\n pg_n = 0 # page counter\\n plt_n = 0 # plot per page counter\\n lg_n = 0 # legend per plot counter\\n\\n for plts,sp in enumerate(splist):\\n# set specific plot parameters\\n if not isinstance(sp[0],splat.Spectrum):\\n raise ValueError('\\\\nInput to plotSpectrum has wrong format:\\\\n\\\\n{}\\\\n\\\\n'.format(sp[0]))\\n\\n# set up plotting defaults for the list of spectra - REPLACE THIS\\n if not isinstance(zeropoint,list): zeropoint = [zeropoint]*len(sp)\\n if len(zeropoint) < len(sp): zeropoint.extend([zeropoint[-1] for x in range(len(sp)-len(zeropoint))])\\n if not isinstance(color,list): color = [color]*len(sp)\\n if len(color) < len(sp): color.extend([color[-1] for x in range(len(sp)-len(color))])\\n if not isinstance(linestyle,list): linestyle = [linestyle]*len(sp)\\n if len(linestyle) < len(sp): linestyle.extend([linestyle[-1] for x in range(len(sp)-len(linestyle))])\\n if not isinstance(linewidth,list): linewidth = [linewidth]*len(sp)\\n if len(linewidth) < len(sp): linewidth.extend([linewidth[-1] for x in range(len(sp)-len(linewidth))])\\n if not isinstance(alpha,list): alpha = [alpha]*len(sp)\\n if len(alpha) < len(sp): alpha.extend([alpha[-1] for x in range(len(sp)-len(alpha))])\\n if not isinstance(color_noise,list): color_noise = [color_noise]*len(sp)\\n if len(color_noise) < len(sp): color_noise.extend([color_noise[-1] for x in range(len(sp)-len(color_noise))])\\n if not isinstance(linestyle_noise,list): linestyle_noise = [linestyle_noise]*len(sp)\\n if len(linestyle_noise) < len(sp): linestyle_noise.extend([linestyle_noise[-1] for x in range(len(sp)-len(linestyle_noise))])\\n if not isinstance(linewidth_noise,list): linewidth_noise = [linewidth_noise]*len(sp)\\n if len(linewidth_noise) < len(sp): linewidth_noise.extend([linewidth_noise[-1] for x in range(len(sp)-len(linewidth_noise))])\\n if not isinstance(alpha_noise,list): alpha_noise = [alpha_noise]*len(sp)\\n if len(alpha_noise) < len(sp): alpha_noise.extend([alpha_noise[-1] for x in range(len(sp)-len(color_noise))])\\n if not isinstance(color_comparison,list): color_comparison = [color_comparison]*len(sp)\\n if len(color_comparison) < len(sp): color_comparison.extend([color_comparison[-1] for x in range(len(sp)-len(color_comparison))])\\n if not isinstance(linestyle_comparison,list): linestyle_comparison = [linestyle_comparison]*len(sp)\\n if len(linestyle_comparison) < len(sp): linestyle_comparison.extend([linestyle_comparison[-1] for x in range(len(sp)-len(linestyle_comparison))])\\n if not isinstance(linewidth_comparison,list): linewidth_comparison = [linewidth_comparison]*len(sp)\\n if len(linewidth_comparison) < len(sp): linewidth_comparison.extend([linewidth_comparison[-1] for x in range(len(sp)-len(linewidth_comparison))])\\n if not isinstance(alpha_comparison,list): alpha_comparison = [alpha_comparison]*len(sp)\\n if len(alpha_comparison) < len(sp): alpha_comparison.extend([alpha_comparison[-1] for x in range(len(sp)-len(alpha_comparison))])\\n\\n# settings that work if the spectrum was read in as legitmate Spectrum object\\n try:\\n xlabel = kwargs.get('xlabel','{} ({})'.format(sp[0].wave_label,sp[0].wave.unit))\\n ylabel = kwargs.get('ylabel','{} ({})'.format(sp[0].flux_label,sp[0].flux.unit))\\n except:\\n xlabel = kwargs.get('xlabel',xlabel_default)\\n ylabel = kwargs.get('ylabel',ylabel_default)\\n# initial plot range\\n bound = [numpy.nanmin(sp[0].wave.value),numpy.nanmax(sp[0].wave.value)]\\n ymax = [numpy.nanquantile(s.flux.value,0.98) for s in sp]\\n bound.extend(numpy.array([-0.02,1.3])*numpy.nanmax(ymax)+\\\\\\n numpy.array([numpy.nanmin(zeropoint),numpy.nanmax(zeropoint)+stack*(len(sp)-1)]))\\n\\n# set colormap if provided\\n if colormap != None:\\n values = numpy.arange(len(sp))\\n color_map = plt.get_cmap(colormap)\\n norm = colmap.Normalize(vmin=0, vmax=1.0*values[-1])\\n scalarMap = cm.ScalarMappable(norm=norm, cmap=color_map)\\n for i in range(len(sp)): color[i] = scalarMap.to_rgba(values[i])\\n\\n# GENERATE PLOTS\\n if multiplot == True or multipage == True:\\n plt_n = plts % nplot\\n if (plt_n == 0):\\n fig.append(plt.figure())\\n pg_n += 1\\n ax = fig[pg_n-1].add_subplot(layout[0], layout[1], plt_n+1)\\n \\n# plotting a single plot with all spectra\\n else:\\n plt.close('all')\\n plt_n = 0\\n fig = []\\n if len(figsize)>0: fig.append(plt.figure(figsize=figsize))\\n else: fig.append(plt.figure())\\n ax = fig[0].add_subplot(111)\\n \\n for ii, a in enumerate(sp):\\n# zeropoint and stack\\n flx = [i+zeropoint[ii] for i in a.flux.value]\\n if stack > 0: flx = [f + (len(sp)-ii-1)*stack for f in flx]\\n ax.plot(a.wave.value,flx,color=color[ii],linestyle=linestyle[ii], lw=linewidth[ii], alpha=alpha[ii], zorder = 10, label = legend[lg_n]) \\n\\n# add comparison\\n if comparison != None:\\n# zeropoint and stack\\n cflx = [i+zeropoint[ii] for i in comparison.flux.value]\\n if stack > 0: cflx = [f + (len(sp)-ii-1)*stack for f in cflx]\\n ax.plot(comparison.wave.value,cflx,color=color_comparison[ii],linestyle=linestyle_comparison[ii], lw=linewidth_comparison[ii], alpha=alpha_comparison[ii], zorder = 10)\\n \\n# add residual\\n if residual == True and len(sp) == 2:\\n # Save flux values from first spectrum\\n if ii == 0:\\n flx0 = [f - (len(sp)-ii-1)*stack for f in flx]\\n \\n # Subtract fluxes and plot\\n elif ii == 1:\\n res = [flx0[f_n] - f for f_n, f in enumerate(flx)]\\n ax.plot(a.wave.value, res, alpha = alpha_residual[ii], color = color_residual[ii], linsetyle=linestyle_residual[ii], lw=linewidth_residual[ii])\\n \\n # Fix bound[2] if residual goes below 0\\n if numpy.nanmin(res) < bound[2]:\\n b0 = numpy.argmin(a.wave.value[a.wave.value > bound[0]])\\n b1 = numpy.argmax(a.wave.value[a.wave.value < bound[1]])\\n bound[2] = numpy.nanmin(res[b0:b1])\\n\\n# noise\\n if show_noise == True:\\n ns = [i+zeropoint[ii] for i in a.noise.value]\\n ax.plot(a.wave.value,ns,color=color_noise[ii],linestyle=linestyle_noise[ii],alpha=alpha_noise[ii], lw=linewidth_noise[ii], zorder = 10)\\n\\n# zeropoint\\n if show_zero == True:\\n ze = numpy.ones(len(a.flux))*zeropoint[ii]\\n ax.plot(a.wave.value,ze,color=color[ii],linestyle=linestyle_zero,alpha=alpha_zero,lw=linewidth_zero, zorder = 10)\\n\\n# save maximum flux among all spectra for plotting\\n# THIS IS VERY SLOW AND IT WOULD BE BETTER TO FIND AN ALTERNATE APPROACH\\n if len(features)>0:\\n f = interp1d(a.wave,flx,bounds_error=False,fill_value=0.)\\n if ii == 0: \\n wvmax = numpy.linspace(bound[0],bound[1],nsamples)\\n flxmax = numpy.array(f(wvmax))\\n else: flxmax = numpy.maximum(flxmax,numpy.array(f(wvmax)))\\n\\n# legend counter\\n lg_n = lg_n + 1 # Increment legend\\n\\n\\n# label features\\n# THIS NEEDS TO BE FIXED WITH GRETEL'S STUFF\\n if len(features) > 0:\\n yoff = 0.02*(bound[3]-bound[2]) # label offset\\n fontsize = int((10-numpy.nanmin([(layout[0]*layout[1]-1),6]))*fontscale)\\n for ftr in features:\\n ftr = ftr.lower()\\n if ftr in FEATURE_LABELS:\\n ftrc = checkDict(ftr,FEATURE_LABELS)\\n if ftrc != False:\\n for ii,waveRng in enumerate(FEATURE_LABELS[ftrc]['wavelengths']):\\n wRng = waveRng.to(sp[0].wave.unit).value\\n# features must be contained in plot range (may change this)\\n if numpy.nanmin(wRng) > bound[0] and numpy.nanmax(wRng) < bound[1]:\\n wfeature = numpy.where(numpy.logical_and(wvmax >= numpy.nanmin(wRng),wvmax <= numpy.nanmax(wRng)))\\n if len(wvmax[wfeature]) == 0: wfeature = numpy.argmax(numpy.absolute(wvmax-numpy.nanmedian(wRng)))\\n y = numpy.nanmax(flxmax[wfeature])+yoff\\n flxmax[wfeature] = flxmax[wfeature]+3.*yoff\\n\\n if FEATURE_LABELS[ftrc]['type'] == 'band':\\n ax.plot(wRng,[y+yoff]*2,color='k',linestyle='-')\\n ax.plot([wRng[0]]*2,[y,y+yoff],color='k',linestyle='-')\\n ax.text(numpy.mean(wRng),y+1.5*yoff,FEATURE_LABELS[ftrc]['label'],horizontalalignment='center',fontsize=fontsize)\\n else:\\n for w in wRng: ax.plot([w]*2,[y,y+yoff],color='k',linestyle='-')\\n ax.text(numpy.mean(wRng),y+1.5*yoff,FEATURE_LABELS[ftrc]['label'],horizontalalignment='center',fontsize=fontsize)\\n bound[3] = numpy.nanmax([numpy.nanmax(flxmax)+2.*yoff,bound[3]])\\n\\n# add grid\\n if grid == True: ax.grid() \\n\\n# axis labels \\n fontsize = (numpy.round(numpy.max([13./((layout[0]*layout[1])**0.33),5]))) * fontscale\\n legend_fontsize = (13-numpy.min([(layout[0]*layout[1]-1),8])) * legend_fontscale\\n ax.set_xlabel(xlabel, fontsize = fontsize)\\n ax.set_ylabel(ylabel, fontsize = fontsize)\\n ax.tick_params(axis='x', labelsize=fontsize)\\n ax.tick_params(axis='y', labelsize=fontsize)\\n\\n# add title\\n if title!='': ax.set_title(title)\\n\\n# log scale?\\n if kwargs.get('xlog',False): ax.set_xscale('log',nonposx='clip')\\n if kwargs.get('ylog',False): ax.set_yscale('log',nonposy='clip')\\n\\n# place legend\\n if len(legend) > 0:\\n if legend_location == 'outside':\\n box = ax.get_position()\\n ax.set_position([box.x0, box.y0 + box.height * 0.15, box.width * 0.7, box.height * 0.7])\\n ax.legend(loc='center left', bbox_to_anchor=(1, 0.5), prop={'size':legend_fontsize})\\n else:\\n ax.legend(loc=legend_location, prop={'size':legend_fontsize})\\n bound[3] = bound[3]+0.1*(bound[3]-bound[2]) # extend axis for in-plot legends\\n\\n# overplot telluric absorption\\n if telluric == True:\\n yoff = 0.02*(bound[3]-bound[2]) # label offset\\n for waveRng in telluric_bands:\\n wR = waveRng.to(sp[0].wave.unit).value\\n rect = patches.Rectangle((wR[0],bound[2]),wR[1]-wR[0],bound[3]-bound[2],facecolor=color_telluric,alpha=alpha_telluric,color=color_telluric)\\n ax.add_patch(rect)\\n ax.text(numpy.mean(wR),bound[2]+3*yoff,r'$\\\\oplus$',horizontalalignment='center',fontsize=fontsize)\\n\\n# overplot color swaths for pre-specified bands\\n if len(band) > 0:\\n for i,b in enumerate(band):\\n if not isinstance(b,list): \\n try: b = [float(b)-0.5*band_width,float(b)+0.5*band_width]\\n except:\\n print('\\\\nWarning: plotSpectrum bands variables should be array of 2-element arrays; you passed {}'.format(band))\\n b = [0.,0.]\\n rect = patches.Rectangle((b[0],bound[2]),b[1]-b[0],bound[3]-bound[2],facecolor=band_color[i],color=band_color[i],alpha=band_alpha[i])\\n ax.add_patch(rect)\\n if band_label_position[i].lower() == 'top':\\n ax.text(numpy.mean(b),bound[3]-3*yoff,band_label[i],horizontalalignment='center',fontsize=fontsize)\\n elif band_label_position[i].lower() == 'middle':\\n ax.text(numpy.mean(b),0.5*(bound[2]+bound[3]),band_label[i],horizontalalignment='center',fontsize=fontsize)\\n else:\\n ax.text(numpy.mean(b),bound[2]+3*yoff,band_label[i],horizontalalignment='center',fontsize=fontsize)\\n\\n# place inset - RIGHT NOW ONLY SETTING LIMITS WITH FIRST SPECTRUM IN LIST\\n if inset == True and len(inset_xrange) == 2:\\n ax_inset = fig[pg_n-1].add_axes(inset_position) #, axisbg='white')\\n bound2 = inset_xrange\\n if len(inset_yrange) == 0:\\n b0 = numpy.argmax(sp[0].wave.value > bound2[0])\\n b1 = numpy.argmin(sp[0].wave.value < bound2[1])\\n inset_yrange = [numpy.nanmin(sp[0].flux.value[b0:b1]),numpy.nanmax(sp[0].flux.value[b0:b1])]\\n bound2.extend(inset_yrange)\\n db = (bound2[3]-bound2[2])\\n bound2[2] = bound2[2]-0.05*db\\n bound2[3] = bound2[3]+0.05*db\\n ax_inset.axis(bound2)\\n inset_fontsize = fontsize*0.7\\n\\n for ii,a in enumerate(sp):\\n flx = [i+zeropoint[ii] for i in a.flux.value]\\n ax_inset.plot(a.wave.value,flx,color=colors[ii],linestyle=linestyle[ii],linewidth=linewidth[ii],alpha=alpha[ii]) \\n ax_inset.set_xlabel('')\\n ax_inset.set_ylabel('')\\n ax_inset.tick_params(axis='x', labelsize=inset_fontsize)\\n ax_inset.tick_params(axis='y', labelsize=inset_fontsize)\\n# ax_inset.legend()\\n\\n# inset feature labels\\n if len(inset_features) > 0:\\n yoff = 0.05*(bound2[3]-bound2[2])\\n for ftr in inset_features:\\n ftrc = checkDict(ftr,FEATURE_LABELS)\\n if ftrc != False:\\n for ii,waveRng in enumerate(FEATURE_LABELS[ftrc]['wavelengths']):\\n wRng = waveRng.to(sp[0].wave.unit).value\\n if (numpy.min(wRng) > bound2[0] and numpy.max(wRng) < bound2[1]):\\n wfeature = numpy.where(numpy.logical_and(wvmax >= numpy.nanmin(wRng),wvmax <= numpy.nanmax(wRng)))\\n if len(wvmax[wfeature]) == 0: wfeature = numpy.argmax(numpy.absolute(wvmax-numpy.nanmedian(wRng)))\\n y = numpy.nanmax(flxmax[wfeature])+yoff\\n flxmax[wfeature] = flxmax[wfeature]+3.*yoff\\n \\n if FEATURE_LABELS[ftrc]['type'] == 'band':\\n ax_inset.plot(wR,[y+yoff]*2,color='k',linestyle='-')\\n ax_inset.plot([wR[0]]*2,[y,y+yoff],color='k',linestyle='-')\\n ax_inset.text(numpy.mean(wR),y+2*yoff,FEATURE_LABELS[ftrc]['label'],horizontalalignment='center',fontsize=inset_fontsize)\\n else:\\n for w in waveRng:\\n ax_inset.plot([w]*2,[y,y+yoff],color='k',linestyle='-')\\n ax_inset.text(numpy.mean(wR),y+2*yoff,FEATURE_LABELS[ftrc]['label'],horizontalalignment='center',fontsize=inset_fontsize)\\n waveRng = [wR[0]-0.02,wR[1]+0.02] # for overlap\\n \\n# update offset\\n if len(inset_features) > 0: bound2[3] = numpy.nanmax([bound2[3],numpy.nanmax(flxmax)+5.*yoff])\\n ax_inset.axis(bound2)\\n\\n# finalize bounding\\n if len(xrng) > 0: bound[0:2] = xrng\\n if len(yrng) > 0: bound[2:4] = yrng\\n if isUnit(bound[0]): bound = [x.value for x in bound]\\n ax.axis(bound)\\n \\n# save to file or display\\n# ERROR HERE - CHECK WHAT FILES\\n if multipage == False:\\n if files[plts] != '' and (plts % nplot == 3 or plts == len(splist)-1):\\n if kwargs.get('tight',True) == True: \\n plt.savefig(files[plts], bbox_inches='tight')\\n else:\\n plt.savefig(files[plts])\\n if output == '' and not kwargs.get('web',False):\\n plt.show()\\n if (kwargs.get('interactive',False) != False): plt.ion()\\n else: plt.ioff()\\n\\n\\n# save figures in multipage format and write off pdf file\\n if multipage == True: \\n for pg_n in numpy.arange(numpages):\\n# fig[pg_n].text(0.5, 0.04, xlabel, ha = 'center', va = 'center')\\n# fig[pg_n].text(0.06, 0.5, ylabel, ha = 'center', va = 'center', rotation = 'vertical')\\n fig[pg_n].tight_layout\\n fig[pg_n].suptitle(title, fontsize = int(14*fontsize), fontweight = 'bold')\\n pdf_pages.savefig(fig[pg_n])\\n if filetype.lower() == 'pdf':\\n pdf_pages.close()\\n\\n plt.clf()\\n return fig\",\n \"def plot(self,include_rho=True,show=True,nx=129):\\n xs = np.linspace(0.0,1.0,nx)\\n plt.plot(xs,self.f0(xs),'b-')\\n plt.plot([self.rho_max,self.rho_max],[0.0,1.0],'b:')\\n plt.plot(xs,self.f1(xs),'r-')\\n plt.plot([self.rho_min,self.rho_min],[0.0,1.0],'r:')\\n plt.plot([0.0,1.0],[0.0,1.0],'k--')\\n if include_rho:\\n plt.plot([self.rho,self.rho],[0.0,1.0],'g:')\\n plt.xlim(0.0,1.0)\\n plt.ylim(0.0,1.0)\\n plt.axes().set_aspect(1.0)\\n if show:\\n plt.show()\",\n \"def plot(self):\\n\\t\\tself.plotOfXray().plot()\",\n \"def plot(self, **kwargs):\\n if self.order != None:\\n name = str(_constructModelName(self.teff, self.logg, \\n self.metal, self.en, self.order, self.path))\\n output = kwargs.get('output', str(name) + '.pdf')\\n ylim = kwargs.get('yrange', [min(self.flux)-.2, max(self.flux)+.2])\\n title = kwargs.get('title')\\n save = kwargs.get('save', False)\\n \\n plt.figure(figsize=(16,6))\\n plt.plot(self.wave, self.flux, color='k', \\n alpha=.8, linewidth=1, label=name)\\n plt.legend(loc='upper right', fontsize=12)\\n plt.ylim(ylim) \\n \\n minor_locator = AutoMinorLocator(5)\\n #ax.xaxis.set_minor_locator(minor_locator)\\n # plt.grid(which='minor') \\n \\n plt.xlabel(r'$\\\\lambda$ [$\\\\mathring{A}$]', fontsize=18)\\n plt.ylabel(r'$Flux$', fontsize=18)\\n #plt.ylabel(r'$F_{\\\\lambda}$ [$erg/s \\\\cdot cm^{2}$]', fontsize=18)\\n if title != None:\\n plt.title(title, fontsize=20)\\n plt.tight_layout()\\n\\n if save == True:\\n plt.savefig(output)\\n plt.show()\\n plt.close()\\n\\n else:\\n output = kwargs.get('output'+ '.pdf')\\n ylim = kwargs.get('yrange', [min(self.flux)-.2, max(self.flux)+.2])\\n title = kwargs.get('title')\\n save = kwargs.get('save', False)\\n \\n plt.figure(figsize=(16,6))\\n plt.plot(self.wave, self.flux, color='k', alpha=.8, linewidth=1)\\n plt.legend(loc='upper right', fontsize=12)\\n plt.ylim(ylim)\\n \\n minor_locator = AutoMinorLocator(5)\\n #ax.xaxis.set_minor_locator(minor_locator)\\n # plt.grid(which='minor') \\n \\n plt.xlabel(r'$\\\\lambda$ [$\\\\mathring{A}$]', fontsize=18)\\n plt.ylabel(r'$Flux$', fontsize=18)\\n #plt.ylabel(r'$F_{\\\\lambda}$ [$erg/s \\\\cdot cm^{2}$]', fontsize=18)\\n if title != None:\\n plt.title(title, fontsize=20)\\n plt.tight_layout()\\n\\n if save == True:\\n plt.savefig(output)\\n plt.show()\\n plt.close()\",\n \"def plotSpectrum(self, spectrum=None):\\n if spectrum is None:\\n spectrum = self.spectrometer.getSpectrum()\\n\\n if len(self.axes.lines) == 0:\\n self.axes.plot(self.spectrometer.wavelength, spectrum, 'k')\\n self.axes.set_xlabel(\\\"Wavelength [nm]\\\")\\n self.axes.set_ylabel(\\\"Intensity [arb.u]\\\")\\n else:\\n self.axes.lines[0].set_data( self.spectrometer.wavelength, spectrum) # set plot data\\n self.axes.relim()\",\n \"def plot(self, *args, **kwargs):\\n pass\",\n \"def graphplot(self):\\n if self.binned:\\n self.line.set_ydata(self.fft_bins_y)\\n else:\\n self.line.set_ydata(self.spec_y)\\n self.line2.set_ydata(self.wave_y)\\n self.ax1.draw_artist(self.ax1.patch)\\n self.ax2.draw_artist(self.ax2.patch)\\n self.ax1.draw_artist(self.line)\\n self.ax2.draw_artist(self.line2)\\n self.fig.canvas.update()\\n self.fig.canvas.flush_events()\",\n \"def plot(self,x,y):\\r\\n scalex,scaley = self.getScale()\\r\\n x = x*self.samplerate\\r\\n x = (x-scalex[0])/(scalex[1]-scalex[0])*self.w\\r\\n y = (y-scaley[0])/(scaley[1]-scaley[0])*self.h\\r\\n return (x,y)\",\n \"def plot_data(x, y, Amp, freq, filename):\\n plb.plot(x, y, 'b', linestyle = ':')\\n y_fit = Amp * np.sin(freq * x)\\n plb.plot(x, y_fit, 'r')\\n plb.savefig(filename)\",\n \"def plotXY(xName,xDataRaw,yName, yDataRaw):\\n scanFileHolder = getScanFileHolderXY(xName,xDataRaw,yName, yDataRaw) \\n scanFileHolder.plot(xName, yName)\\n return scanFileHolder\",\n \"def plot_xy(xy: np.ndarray, *args: Optional, **kwargs: Optional):\\n trj = traja.from_xy(xy)\\n trj.traja.plot(*args, **kwargs)\",\n \"def plot_spectrum(spec, ax=None, **kwargs):\\n\\n if not spec.data.size or not spec.energy.size or np.all(spec.energy == 0):\\n raise ValueError('Spectrum must be loaded and calibrated')\\n\\n ax = plot_xy(spec.energy, spec.data, ax=ax, **kwargs)\\n\\n return ax\",\n \"def plot_spectrum(freqs, fluxes, min_lambda=3700, max_lambda=8000):\\n plt.plot(freqs, fluxes)\\n plt.xlim((min_lambda, max_lambda))\\n plt.xlabel(r'$\\\\lambda\\\\, (\\\\AA)$', size=16)\\n plt.ylabel(r'$Flux$', size=16)\\n #plt.axes().minorticks_on()\",\n \"def visualisation(self):\\n plt.plot(self.x, self.y, 'o', label = 'Example data')\\n plt.plot(self.x, np.dot(self.w, self.X), label = 'Model')\\n plt.xlim([-1,1])\\n plt.ylim([-1,1])\",\n \"def plot(self, show=True):\\n xs, ys = zip(*[(float(ix)/self.sample_rate, val)\\n for ix, val in enumerate(self.samples)])\\n plt.plot(xs, ys)\\n if show:\\n plt.show()\",\n \"def plot(self, **kwargs):\\n\\n from ..plot import Plot\\n\\n p = Plot(1, 1, 1, **kwargs)\\n\\n p.axes[0].plot(self.dispersion.value, self.flux.value,\\n drawstyle='steps-mid')\\n\\n if self.flux.uncertainty is not None:\\n p.axes[0].plot(self.dispersion.value, self.flux.uncertainty.value,\\n drawstyle='steps-mid')\\n\\n p.tidy()\\n p.display()\",\n \"def plot():\\n pass\",\n \"def plot(data,fig,figure_number = 1,xlabel='',ylabel='',title=''):\\n fig.add_subplot(1,2,figure_number)\\n plt.title(title)\\n plt.xlabel(xlabel)\\n # only plot the y label if ipython is True, else the plot looks to cramped\\n if is_ipython:\\n plt.ylabel(ylabel)\\n plt.plot(np.array(data),'orange')\\n plt.ylim((0,1))\\n if not is_ipython:\\n plt.pause(0.000001) # pause a bit so that plots are updated\",\n \"def plot(self):\\n\\t\\tself.plotOfLoopVoltage()\",\n \"def plot_solution(self, identlist, aperture_lst, plot_ax1=False, **kwargs):\\n coeff = kwargs.pop('coeff')\\n k = kwargs.pop('k')\\n offset = kwargs.pop('offset')\\n npixel = kwargs.pop('npixel')\\n std = kwargs.pop('std')\\n nuse = kwargs.pop('nuse')\\n ntot = kwargs.pop('ntot')\\n xorder = kwargs.pop('xorder')\\n yorder = kwargs.pop('yorder')\\n clipping = kwargs.pop('clipping')\\n maxiter = kwargs.pop('maxiter')\\n\\n label_size = 13 # fontsize for x, y labels\\n tick_size = 12 # fontsize for x, y ticks\\n\\n #wave_scale = 'linear'\\n wave_scale = 'reciprocal'\\n\\n #colors = 'rgbcmyk'\\n\\n self._ax2.cla()\\n self._ax3.cla()\\n\\n if plot_ax1:\\n self._ax1.cla()\\n x = np.linspace(0, npixel-1, 100, dtype=np.float64)\\n\\n # find the maximum and minimum wavelength\\n wl_min, wl_max = 1e9,0\\n allwave_lst = {}\\n for aperture in aperture_lst:\\n order = k*aperture + offset\\n wave = get_wavelength(coeff, npixel, x, np.repeat(order, x.size))\\n allwave_lst[aperture] = wave\\n wl_max = max(wl_max, wave.max())\\n wl_min = min(wl_min, wave.min())\\n # plot maximum and minimum wavelength, to determine the display\\n # range of this axes, and the tick positions\\n self._ax1.plot([0, 0],[wl_min, wl_max], color='none')\\n yticks = self._ax1.get_yticks()\\n self._ax1.cla()\\n\\n\\n for aperture in aperture_lst:\\n order = k*aperture + offset\\n color = 'C{}'.format(order%10)\\n\\n # plot pixel vs. wavelength\\n if plot_ax1:\\n wave = allwave_lst[aperture]\\n if wave_scale=='reciprocal':\\n self._ax1.plot(x, 1/wave,\\n color=color, ls='-', alpha=0.8, lw=0.8)\\n else:\\n self._ax1.plot(x, wave,\\n color=color, ls='-', alpha=0.8, lw=0.8)\\n\\n # plot identified lines\\n if aperture in identlist:\\n list1 = identlist[aperture]\\n pix_lst = list1['pixel']\\n wav_lst = list1['wavelength']\\n mask = list1['mask'].astype(bool)\\n res_lst = list1['residual']\\n\\n if plot_ax1:\\n if wave_scale=='reciprocal':\\n self._ax1.scatter(pix_lst[mask], 1/wav_lst[mask],\\n c=color, s=20, lw=0, alpha=0.8)\\n self._ax1.scatter(pix_lst[~mask], 1/wav_lst[~mask],\\n c='w', s=16, lw=0.7, alpha=0.8,\\n edgecolor=color)\\n else:\\n self._ax1.scatter(pix_lst[mask], wav_lst[mask],\\n c=color, s=20, lw=0, alpha=0.8)\\n self._ax1.scatter(pix_lst[~mask], wav_lst[~mask],\\n c='w', s=16, lw=0.7, alpha=0.8,\\n edgecolor=color)\\n\\n repeat_aper_lst = np.repeat(aperture, pix_lst.size)\\n self._ax2.scatter(repeat_aper_lst[mask], res_lst[mask],\\n c=color, s=20, lw=0, alpha=0.8)\\n self._ax2.scatter(repeat_aper_lst[~mask], res_lst[~mask],\\n c='w', s=16, lw=0.7, alpha=0.8, ec=color)\\n self._ax3.scatter(pix_lst[mask], res_lst[mask],\\n c=color, s=20, lw=0, alpha=0.8)\\n self._ax3.scatter(pix_lst[~mask], res_lst[~mask],\\n c='w', s=16, lw=0.7, alpha=0.8, ec=color)\\n\\n # refresh texts in the residual panels\\n text = 'R.M.S. = {:.5f}, N = {}/{}'.format(std, nuse, ntot)\\n self._ax3._residual_text.set_text(text)\\n text = u'Xorder = {}, Yorder = {}, clipping = \\\\xb1{:g}, Niter = {}'.format(\\n xorder, yorder, clipping, maxiter)\\n self._ax2._fitpar_text.set_text(text)\\n\\n # adjust layout for ax1\\n if plot_ax1:\\n self._ax1.set_xlim(0, npixel-1)\\n if wave_scale == 'reciprocal':\\n _y11, _y22 = self._ax1.get_ylim()\\n newtick_lst, newticklabel_lst = [], []\\n for tick in yticks:\\n if _y11 < 1/tick < _y22:\\n newtick_lst.append(1/tick)\\n newticklabel_lst.append(tick)\\n self._ax1.set_yticks(newtick_lst)\\n self._ax1.set_yticklabels(newticklabel_lst)\\n self._ax1.set_ylim(_y22, _y11)\\n self._ax1.set_xlabel('Pixel', fontsize=label_size)\\n self._ax1.set_ylabel(u'\\\\u03bb (\\\\xc5)', fontsize=label_size)\\n self._ax1.grid(True, ls=':', color='gray', alpha=1, lw=0.5)\\n self._ax1.set_axisbelow(True)\\n self._ax1._aperture_text.set_text('')\\n for tick in self._ax1.xaxis.get_major_ticks():\\n tick.label1.set_fontsize(tick_size)\\n for tick in self._ax1.yaxis.get_major_ticks():\\n tick.label1.set_fontsize(tick_size)\\n\\n # adjust axis layout for ax2 (residual on aperture space)\\n self._ax2.axhline(y=0, color='k', ls='--', lw=0.5)\\n for i in np.arange(-3,3+0.1):\\n self._ax2.axhline(y=i*std, color='k', ls=':', lw=0.5)\\n x1, x2 = self._ax2.get_xlim()\\n x1 = max(x1,aperture_lst.min())\\n x2 = min(x2,aperture_lst.max())\\n self._ax2.set_xlim(x1, x2)\\n self._ax2.set_ylim(-6*std, 6*std)\\n self._ax2.set_xlabel('Aperture', fontsize=label_size)\\n self._ax2.set_ylabel(u'Residual on \\\\u03bb (\\\\xc5)', fontsize=label_size)\\n for tick in self._ax2.xaxis.get_major_ticks():\\n tick.label1.set_fontsize(tick_size)\\n for tick in self._ax2.yaxis.get_major_ticks():\\n tick.label1.set_fontsize(tick_size)\\n\\n ## adjust axis layout for ax3 (residual on pixel space)\\n self._ax3.axhline(y=0, color='k', ls='--', lw=0.5)\\n for i in np.arange(-3,3+0.1):\\n self._ax3.axhline(y=i*std, color='k', ls=':', lw=0.5)\\n self._ax3.set_xlim(0, npixel-1)\\n self._ax3.set_ylim(-6*std, 6*std)\\n self._ax3.set_xlabel('Pixel', fontsize=label_size)\\n self._ax3.set_ylabel(u'Residual on \\\\u03bb (\\\\xc5)', fontsize=label_size)\\n for tick in self._ax3.xaxis.get_major_ticks():\\n tick.label1.set_fontsize(tick_size)\\n for tick in self._ax3.yaxis.get_major_ticks():\\n tick.label1.set_fontsize(tick_size)\",\n \"def show_waveform(self, peaks=[]):\\n if peaks is None:\\n peaks = []\\n data = self.amplitude\\n x_axis = range(0, len(data))\\n x_axis = [x / self.fs for x in x_axis]\\n plt.plot(x_axis, data)\\n plt.axhline(self.height)\\n for p in peaks:\\n plt.axvline(p / self.fs, color=\\\"red\\\", alpha=0.2)\\n plt.ylabel(\\\"Amplitude\\\")\\n plt.xlabel(\\\"Time (seconds)\\\")\\n plt.title(\\\"Waveform\\\")\\n plt.show()\",\n \"def plot_simulation_yz(\\n sim: td.Simulation,\\n z: float = 0.0,\\n y: float = 0.0,\\n wavelength: Optional[float] = 1.55,\\n figsize: Float2 = (11, 4),\\n):\\n fig = plt.figure(figsize=figsize)\\n if sim.size[2] > 0.1 and sim.size[1] > 0.1:\\n gs = mpl.gridspec.GridSpec(1, 2, figure=fig, width_ratios=[1, 1.4])\\n ax1 = fig.add_subplot(gs[0, 0])\\n ax2 = fig.add_subplot(gs[0, 1])\\n if wavelength:\\n freq = td.constants.C_0 / wavelength\\n sim.plot_eps(z=z, ax=ax1, freq=freq)\\n sim.plot_eps(y=y, ax=ax2, freq=freq)\\n else:\\n sim.plot(z=z, ax=ax1)\\n sim.plot(y=y, ax=ax2)\\n elif sim.size[2] > 0.1: # 2D grating sim_size_y = 0\\n gs = mpl.gridspec.GridSpec(1, 1, figure=fig, width_ratios=[1])\\n ax1 = fig.add_subplot(gs[0, 0])\\n if wavelength:\\n freq = td.constants.C_0 / wavelength\\n sim.plot_eps(y=y, ax=ax1, freq=freq)\\n else:\\n sim.plot(y=y, ax=ax1)\\n\\n else: # 2D planar component size_z = 0\\n gs = mpl.gridspec.GridSpec(1, 1, figure=fig, width_ratios=[1])\\n ax1 = fig.add_subplot(gs[0, 0])\\n if wavelength:\\n freq = td.constants.C_0 / wavelength\\n sim.plot_eps(z=z, ax=ax1, freq=freq)\\n else:\\n sim.plot(z=z, ax=ax1)\\n\\n plt.show()\\n return fig\",\n \"def draw_plot(self):\\n # X axis is auto follow.\\n XLEN = 100\\n xmax = max(len(self.daq.data0), XLEN)\\n xmin = xmax - XLEN\\n\\n # The Y value will lie between 0.0 and 5.0 volts\\n ymax = 5.0\\n ymin = 0.0\\n\\n self.main_plot.set_xbound(lower=xmin, upper=xmax)\\n self.main_plot.set_ybound(lower=ymin, upper=ymax)\\n\\n # Add the grid. Grid looks cool and is actually very helpful.\\n self.main_plot.grid(True, color='gray')\\n\\n pylab.setp(self.main_plot.get_xticklabels(), \\n visible=True)\\n \\n self.plot_data.set_xdata(arange(len(self.daq.data0)))\\n self.plot_data.set_ydata(array(self.daq.data0))\\n \\n self.canvas.draw()\",\n \"def plot_xy(nc,params,tms,lev=None):\\n \\n import matplotlib.pyplot as plt\\n import ggWRFutils as gW\\n from datetime import datetime\\n import numpy as np\\n wvar={}\\n for p in params:\\n if p != 'Times':\\n if p=='WS10':\\n wvar[p]=np.sqrt(nc.variables['U10'][:]**2+nc.variables['U10'][:]**2)\\n elif p=='UV10': \\n wvar['U10']=nc.variables['U10'][:,:,:] \\n wvar['V10']=nc.variables['V10'][:,:,:] \\n elif p=='UV':\\n wvar['U']=nc.variables['U'][:,lev,:,:] \\n wvar['V']=nc.variables['V'][:,lev,:,:] \\n elif len(nc.variables[p].shape) > 3:\\n wvar[p]=nc.variables[p][:,lev,:,:] \\n else: \\n wvar[p]=nc.variables[p][:] \\n Nx,Ny,Nz,lon,lat,dx,dy=gW.getDimensions(nc)\\n for p in params:\\n if params[p]=='pcolor':\\n plt.pcolor(lon,lat,wvar[p][tms,:,:],shading='flat')\\n plt.colorbar()\\n if params[p]=='contourf':\\n plt.contourf(lon,lat,wvar[p][tms,:,:],50)\\n plt.colorbar()\\n if params[p]=='contour':\\n plt.contourf(lon,lat,wvar[p][tms,:,:])\\n plt.colorbar()\\n if params[p]=='quiver':\\n if p=='UV10':\\n plt.quiver(lon[::10,::10],lat[::10,::10],wvar['U10'][tms,::10,::10],wvar['V10'][tms,::10,::10],units='width')\\n elif p=='UV':\\n plt.quiver(lon,lat,wvar['U'][tms,:,:],wvar['V'][tms,:,:])\\n plt.hold(True)\\n plt.xlim(lon.min(),lon.max())\\n plt.ylim(lat.min(),lat.max())\\n fig=plt.gcf()\\n return fig\",\n \"def plot(self, *, ax=..., n_cols=..., line_kw=..., contour_kw=...):\\n ...\",\n \"def plot(self):\\n\\t\\tself.plotOfSpect().plot()\",\n \"def plots(x_bef,y_bef,z_bef):\\r\\n # Makes a 3-D plot of the x, y and z axes representing the ball's total trajectory\\r\\n plt.figure(3)\\r\\n plot3 = plt.axes(projection=\\\"3d\\\")\\r\\n plot3.plot3D(x_bef,y_bef,z_bef,'blue')\\r\\n plot3.set_xlabel('x (ft)')\\r\\n plot3.set_ylabel('y (ft)')\\r\\n plot3.set_zlabel('z (ft)')\\r\\n plot3.set_title('Total Trajectory')\\r\\n \\r\\n # Makes a 2-D plot of the x, and z axes representing the ball's total 2-D trajectory\\r\\n plt.figure(4)\\r\\n plt.plot(x_bef,z_bef)\\r\\n plt.xlabel('x (ft)')\\r\\n plt.ylabel('z (ft)')\\r\\n plt.title('z (ft) vs x (ft)')\\r\\n plt.show()\",\n \"def plot(self, num_levels=5):\\n Schrodinger1D.plot(self, num_levels)\\n xlabel('Electron height, z (nm)')\\n ylabel('Energy (GHz)')\\n mine = amin(self.energies(num_levels))\\n maxe = amax(self.energies(num_levels))\\n ylim(mine - (maxe - mine) * .5, maxe + (maxe - mine) * .5)\",\n \"def plot(self, fig=None, ax=None):\\n\\n self._plot_setup(fig, ax)\\n\\n if self.stokes == 'v':\\n self.cmap = plt.cm.coolwarm\\n\\n absmax = max(self.data.max(), self.data.min(), key=abs)\\n rms = np.sqrt(np.mean(np.square(self.data)))\\n\\n logger.debug(f\\\"Max flux in cutout: {absmax:.2f} mJy.\\\")\\n logger.debug(f\\\"RMS flux in cutout: {rms:.2f} mJy.\\\")\\n\\n self.im = self.ax.imshow(self.data, cmap=self.cmap, norm=self.norm)\\n\\n if self.options.get('bar', True):\\n try:\\n self.fig.colorbar(self.im, label=r'Flux Density (mJy beam$^{-1}$)', ax=self.ax)\\n except UnboundLocalError:\\n logger.error(\\\"Colorbar failed. Upgrade to recent version of astropy \\\")\\n\\n if self.options.get('psf'):\\n self.add_psf()\\n\\n self.add_source_ellipse()\",\n \"def plot(x, y, z):\\n pylab.plot(x, y)\\n pylab.plot(x, z)\\n pylab.show()\",\n \"def _xy_plot(cube, x_coord=None, reg_line=False, **plot_kwargs):\\n plot_kwargs = deepcopy(plot_kwargs)\\n if reg_line:\\n if plot_kwargs.get('linestyle', '-') == '-':\\n plot_kwargs.setdefault('marker', 'o')\\n else:\\n plot_kwargs.setdefault('marker', 's')\\n plot_kwargs['linestyle'] = 'none'\\n plot_kwargs.setdefault('markersize', 3)\\n if x_coord is None:\\n iris.plot.plot(cube, **plot_kwargs)\\n if cube.coords(dim_coords=True):\\n coord = cube.coord(dim_coords=True)\\n x_data = coord.points\\n else:\\n coord = None\\n x_data = np.arange(cube.shape[0])\\n else:\\n coord = cube.coord(x_coord)\\n iris.plot.plot(coord, cube, **plot_kwargs)\\n x_data = coord.points\\n if not reg_line:\\n return\\n plot_kwargs['linestyle'] = '-'\\n plot_kwargs['marker'] = None\\n plot_kwargs.pop('label', None)\\n y_data = cube.data\\n reg = linregress(x_data, y_data)\\n y_reg = reg.slope * x_data + reg.intercept\\n plt.plot(x_data, y_reg, **plot_kwargs)\",\n \"def __plot(name, x, y):\\n import matplotlib.pyplot as plt\\n\\n plt.plot(x, y)\\n plt.xlabel('elements')\\n plt.ylabel('time (seconds)')\\n plt.savefig(\\\"{}\\\".format(name))\",\n \"def plot(self):\\n\\t\\tself.plotOfSpect()\",\n \"def plot(self, x_unit='ft', y_unit='psi'):\\n\\n #Find the grid centers (where the solution exists)\\n x_pos = np.cumsum(self.dx_arr) - self.dx_arr[0] / 2.0\\n\\n #Loop over all stored solutions and plot stair-step line (because\\n #pressure is constant over grid block). We skip the first stored values\\n #because they are just the initialization values.\\n plt.figure()\\n for P in self.P_plot:\\n plt.plot(x_pos, P)\\n\\n #Labels, etc.\\n plt.xlabel('Reservoir position (' + x_unit + ')')\\n plt.ylabel('Pressure (' + y_unit + ')')\\n plt.xlim([0, self.res_length])\\n plt.show()\",\n \"def plot_xy(self, subplot = None, center_of_gravity = False, marker = \\\"b-\\\"):\\n if subplot is None:\\n plot = plt.subplot(111)\\n\\n for mass in self.flatten():\\n x,y = mass.geometry.project_xy.plot_coordinates\\n subplot.plot(x, y, marker)\\n\\n if center_of_gravity:\\n x, y, _ = mass.center_of_gravity_global.as_tuple()\\n subplot.plot(x, y,\\\"*\\\")\\n\\n x, y, _ = self.center_of_gravity_global.as_tuple()\\n subplot.plot(x, y, \\\"o\\\")\\n\\n return subplot\",\n \"def plotSpectrum(self,wavelengths,intensities = 1.0):\\n\\n fieldAngle,spectralOutput = self.getIntensitySpectum(wavelengths,intensities)\\n\\n # Do the actual plot\\n plot(np.degrees(fieldAngle),spectralOutput)\\n grid()\\n title(\\\"Spectral plot\\\")\\n xlabel(\\\"Angle in degrees\\\")\\n ylabel(\\\"Intensty\\\")\",\n \"def show():\\n\\tplt.show()\",\n \"def show_plot(segment_times, sample_freqs, spec, wave, wav_data, vad_feat):\\n plt.subplot(3, 1, 1)\\n plt.pcolormesh(segment_times, sample_freqs, 10*np.log10(spec), cmap='jet')\\n plt.ylabel('Frequency [Hz]')\\n plt.xlabel('Time [sec]')\\n\\n plt.subplot(3,1,2)\\n axes = plt.gca()\\n axes.set_xlim([0, wave.duration])\\n tmp_axis = np.linspace(0, wave.duration, wav_data.shape[0])\\n plt.plot(tmp_axis, wav_data/np.abs(np.max(wav_data)))\\n plt.xlabel('Time [sec]')\\n\\n plt.subplot(3,1,3)\\n axes = plt.gca()\\n axes.set_xlim([0, wave.duration])\\n tmp_axis = np.linspace(0, wave.duration, vad_feat.shape[0])\\n plt.plot(tmp_axis, vad_feat)\\n plt.xlabel('Time [sec]')\\n\\n plt.savefig('test', bbox_inches='tight')\",\n \"def generate_plot(self):\\r\\n\\t\\tx, y = zip(*[p.p for p in self.universe])\\r\\n\\t\\tself.ax.cla()\\r\\n\\t\\tself.ax.plot(x, y, '.')\\r\\n\\t\\tself.ax.set_title('Universe at time: %d' % self.universe.time)\\r\\n\\t\\tself.ax.set_xlim([P_MU-4*P_STD, P_MU+4*P_STD])\\r\\n\\t\\tself.ax.set_ylim([P_MU-4*P_STD, P_MU+4*P_STD])\",\n \"def make_plot(x,y):\",\n \"def show_graphs ():\\n plt.ylim = (0, 300)\\n plt.xlim = (0, 300)\\n #Set up lidar plot to figure 1\\n lidar_plot = plt.figure (1)\\n #Assign title\\n plt.title ('Lidar data')\\n #Assign data\\n plt.imshow (lidar_clean)\\n #Set up radar plot to figure 2\\n radar_plot = plt.figure (2)\\n #Assign title\\n plt.title ('Radar data')\\n #Assign data\\n plt.imshow (radar_clean)\\n #Show plots\\n plt.show ()\",\n \"def plot_x(t, x):\\n plt.figure()\\n plt.plot(t, x)\\n plt.title(\\\"Vertical position of the skydiver as a function of time\\\")\\n plt.xlabel(\\\"Time t [s]\\\")\\n plt.ylabel(\\\"Height [m]\\\")\\n plt.savefig('Parachute_position.png')\",\n \"def plot(self, *args, **kwargs):\\n raise NotImplementedError\",\n \"def show_plot(self):\\r\\n\\t\\tself.generate_plot()\\r\\n\\t\\tplt.show()\",\n \"def show():\\n setup()\\n plt.show()\",\n \"def plot(self, param):\\n # process param to be lowercase and without spaces\\n param = str(param).lower().replace(\\\" \\\", \\\"\\\")\\n plt.ion() # enable interactive mode\\n\\n # making plot according to param\\n if param == \\\"illuminantenergy\\\": # energy of illuminant\\n self.illuminant.plot(\\\"energy\\\")\\n elif param == \\\"illuminantphotons\\\": # photons of illuminant\\n self.illuminant.plot(\\\"photons\\\")\\n elif param == \\\"srgb\\\": # srgb image of the scene\\n plt.imshow(self.srgb)\\n plt.show()\\n else:\\n raise(ValueError, \\\"Unknown parameter\\\")\",\n \"def view(self, lo_en: Quantity = Quantity(0.0, \\\"keV\\\"), hi_en: Quantity = Quantity(30.0, \\\"keV\\\"),\\n figsize: Tuple = (8, 6)):\\n if lo_en > hi_en:\\n raise ValueError(\\\"hi_en cannot be greater than lo_en\\\")\\n else:\\n lo_en = lo_en.to(\\\"keV\\\").value\\n hi_en = hi_en.to(\\\"keV\\\").value\\n\\n if len(self._plot_data.keys()) != 0:\\n # Create figure object\\n plt.figure(figsize=figsize)\\n\\n # Set the plot up to look nice and professional.\\n ax = plt.gca()\\n ax.minorticks_on()\\n ax.tick_params(axis='both', direction='in', which='both', top=True, right=True)\\n\\n # Set the title with all relevant information about the spectrum object in it\\n plt.title(\\\"{n} - {o}{i} Spectrum\\\".format(n=self.src_name, o=self.obs_id, i=self.instrument.upper()))\\n for mod_ind, mod in enumerate(self._plot_data):\\n x = self._plot_data[mod][\\\"x\\\"]\\n # If the defaults are left, just update them to the min and max of the dataset\\n # to avoid unsightly gaps at the sides of the plot\\n if lo_en == 0.:\\n lo_en = x.min()\\n if hi_en == 30.0:\\n hi_en = x.max()\\n\\n # Cut the x dataset to just the energy range we want\\n plot_x = x[(x > lo_en) & (x < hi_en)]\\n\\n if mod_ind == 0:\\n # Read out the data just for line length reasons\\n # Make the cuts based on energy values supplied to the view method\\n plot_y = self._plot_data[mod][\\\"y\\\"][(x > lo_en) & (x < hi_en)]\\n plot_xerr = self._plot_data[mod][\\\"x_err\\\"][(x > lo_en) & (x < hi_en)]\\n plot_yerr = self._plot_data[mod][\\\"y_err\\\"][(x > lo_en) & (x < hi_en)]\\n plot_mod = self._plot_data[mod][\\\"model\\\"][(x > lo_en) & (x < hi_en)]\\n\\n plt.errorbar(plot_x, plot_y, xerr=plot_xerr, yerr=plot_yerr, fmt=\\\"k+\\\", label=\\\"data\\\", zorder=1)\\n else:\\n # Don't want to re-plot data points as they should be identical, so if there is another model\\n # only it will be plotted\\n plot_mod = self._plot_data[mod][\\\"model\\\"][(x > lo_en) & (x < hi_en)]\\n\\n # The model line is put on\\n plt.plot(plot_x, plot_mod, label=mod, linewidth=1.5)\\n\\n # Generate the legend for the data and model(s)\\n plt.legend(loc=\\\"best\\\")\\n\\n # Ensure axis is limited to the chosen energy range\\n plt.xlim(lo_en, hi_en)\\n\\n plt.xlabel(\\\"Energy [keV]\\\")\\n plt.ylabel(\\\"Normalised Counts s$^{-1}$ keV$^{-1}$\\\")\\n\\n ax.set_xscale(\\\"log\\\")\\n ax.xaxis.set_major_formatter(ScalarFormatter())\\n ax.xaxis.set_minor_formatter(FuncFormatter(lambda inp, _: '{:g}'.format(inp)))\\n ax.xaxis.set_major_formatter(FuncFormatter(lambda inp, _: '{:g}'.format(inp)))\\n\\n plt.tight_layout()\\n # Display the spectrum\\n plt.show()\\n\\n # Wipe the figure\\n plt.close(\\\"all\\\")\\n\\n else:\\n warnings.warn(\\\"There are no XSPEC fits associated with this Spectrum, you can't view it.\\\")\",\n \"def plot(self, num_levels=10,**kwargs):\\n Schrodinger1D.plot(self, num_levels,**kwargs)\\n xlabel('$\\\\delta/2\\\\pi$')\\n ylabel('E/h (GHz)')\\n ylim(min(self.fluxonium_potential()),min(2*self.energies(num_levels)[-1],max(self.fluxonium_potential())))\\n title('(Ej=%.2f , El=%.2f , Ec=%.2f)GHz , ($\\\\Phi_J=%.2f $,$\\\\Phi_L=%.2f \\\\,) \\\\Phi_0$ ' % (self.Ej, self.El, self.Ec, self.phi,self.phiL))\",\n \"def plot(self, xminorticks = 250, yminorticks = 0.1,\\n show_lims = False, small = False, cumulative = False, return_figure=False,\\n *args, **kwargs):\\n\\n ## Check if there is something in the class to plot\\n if hasattr(self, \\\"wavelength\\\") and hasattr(self, \\\"throughput\\\"):\\n\\n utils.setup_plot_defaults()\\n if hasattr(self._wavelength_units, \\\"format\\\"):\\n if \\\"latex\\\" in self._wavelength_units.format:\\n xaxis_label_string = r'$\\\\textnormal{Wavelength, ' + self._wavelength_units.name + ' (}' + self._wavelength_units._format['latex'] +')$'\\n else:\\n xaxis_label_string = r'$\\\\textnormal{Wavelength, ' + self._wavelength_units.name + '}$'\\n\\n plot_label_string = r'$\\\\textnormal{' + self.filter_name.replace('_', '\\\\\\\\_') + '}$'\\n\\n yminorLocator = MultipleLocator(yminorticks)\\n xminorLocator = MultipleLocator(xminorticks)\\n\\n if not small:\\n fig = plt.figure(figsize=[8, 4])\\n else:\\n fig = plt.figure(figsize=[4, 2])\\n plt.rcParams['font.size'] = 10\\n\\n fig.subplots_adjust(left = 0.09, bottom = 0.13, top = 0.99,\\n right = 0.99, hspace=0, wspace = 0)\\n\\n ax1 = fig.add_subplot(111)\\n\\n if cumulative:\\n throughput = np.cumsum(self.throughput)/np.sum(self.throughput)\\n yaxis_label_string = r'$\\\\textnormal{Cumulative Throughput}$'\\n\\n else:\\n throughput = self.throughput\\n yaxis_label_string = r'$\\\\textnormal{Fractional Throughput}$'\\n\\n\\n if hasattr(self, \\\"_plot_colour\\\"):\\n ax1.plot(self.wavelength, throughput, color = self._plot_colour,\\n lw = 2, label = plot_label_string)\\n else:\\n ax1.plot(self.wavelength, throughput, lw = 2, label = plot_label_string)\\n\\n if show_lims:\\n try:\\n ax1.plot([self._upper_edge, self._upper_edge], [0,1] ,\\n lw = 1.5, alpha = 0.5, ls = ':',\\n color = colours.hex['batman'], zorder = 0, )\\n ax1.plot([self._lower_edge, self._lower_edge], [0,1] ,\\n lw = 1.5, alpha = 0.5, ls = ':',\\n color = colours.hex['batman'], zorder = 0, )\\n except:\\n print(\\\"Failed\\\")\\n\\n ax1.spines['top'].set_visible(True)\\n\\n ax1.set_xlabel(xaxis_label_string)\\n ax1.set_ylabel(yaxis_label_string)\\n\\n ax1.yaxis.set_minor_locator(yminorLocator)\\n ax1.xaxis.set_minor_locator(xminorLocator)\\n\\n ax1.legend(loc = 0)\\n\\n if return_figure:\\n return fig\\n\\n plt.show()\\n pass\\n else:\\n warnings.warn(\\\"Doesn't look like you have loaded a filter into the object\\\")\",\n \"def plot(self, inline=True, fname=None, show_colorbar=False):\\n color_norm = matplotlib.colors.Normalize(\\n vmin=self.decibel_limits[0], vmax=self.decibel_limits[1]\\n )\\n\\n plt.imshow(self.spectrogram[::-1], cmap=\\\"Greys\\\", norm=color_norm)\\n\\n # pick values to show on time and frequency axes\\n yvals = self.frequencies.round(-2).astype(int)\\n xvals = self.times.round(2)\\n y_idx = [int(ti) for ti in np.linspace(0, len(yvals), 8)]\\n y_idx[-1] -= 1\\n plt.yticks(len(yvals) - np.array(y_idx), yvals[y_idx])\\n x_idx = [int(ti) for ti in np.linspace(0, len(xvals), 6)]\\n x_idx[-1] -= 1\\n plt.xticks(x_idx, xvals[x_idx])\\n\\n # add axes labels\\n plt.ylabel(\\\"frequency (Hz): mel scale\\\")\\n plt.xlabel(\\\"time (sec)\\\")\\n\\n if show_colorbar:\\n plt.colorbar()\\n\\n # if fname is not None, save to file path fname\\n if fname:\\n plt.savefig(fname)\\n\\n # if not saving to file, check if a matplotlib backend is available\\n if inline:\\n if os.environ.get(\\\"MPLBACKEND\\\") is None:\\n warnings.warn(\\\"MPLBACKEND is 'None' in os.environ. Skipping plot.\\\")\\n else:\\n plt.show()\",\n \"def plotPowerSpectrum(self,l_edges,show_angle=True,angle_unit=u.arcmin,fig=None,ax=None,**kwargs):\\n\\n\\t\\tif not matplotlib:\\n\\t\\t\\traise ImportError(\\\"matplotlib is not installed, cannot plot the power spectrum!\\\")\\n\\n\\t\\t#Instantiate figure\\n\\t\\tif (fig is None) or (ax is None):\\n\\t\\t\\t\\n\\t\\t\\tself.fig,self.ax = plt.subplots()\\n\\n\\t\\telse:\\n\\n\\t\\t\\tself.fig = fig\\n\\t\\t\\tself.ax = ax\\n\\n\\t\\t#Calculate the power spectrum\\n\\t\\tl,Pl = self.powerSpectrum(l_edges)\\n\\n\\t\\t#Plot\\n\\t\\tself.ax.plot(l,l*(l+1.)*Pl/(2*np.pi),**kwargs)\\n\\t\\tself.ax.set_xscale(\\\"log\\\")\\n\\t\\tself.ax.set_yscale(\\\"log\\\")\\n\\n\\t\\t#Upper scale shows the angle\\n\\t\\tif show_angle:\\n\\t\\t\\tax_top = self.ax.twiny()\\n\\t\\t\\tax_top.set_xticks(self.ax.get_xticks())\\n\\t\\t\\tax_top.set_xlim(self.ax.get_xlim())\\n\\t\\t\\tax_top.set_xticklabels([\\\"{0:.2f}\\\".format(((2*np.pi/ell)*u.rad).to(angle_unit).value) for ell in self.ax.get_xticks()])\\n\\t\\t\\tax_top.set_xlabel(r\\\"$\\\\theta$({0})\\\".format(angle_unit.to_string()),fontsize=22)\\n\\n\\t\\t#Labels\\n\\t\\tself.ax.set_xlabel(r\\\"$\\\\ell$\\\",fontsize=22)\\n\\t\\tself.ax.set_ylabel(r\\\"$\\\\ell(\\\\ell+1)P_\\\\ell^{\\\\kappa\\\\kappa}/2\\\\pi$\\\",fontsize=22)\",\n \"def plot(self, num_levels=10,**kwargs):\\n Schrodinger1D.plot(self, num_levels,**kwargs)\\n xlabel('$\\\\delta/2\\\\pi$')\\n ylabel('E/h (GHz)')\\n ylim(min(self.flux_qubit_potential()),min(2*self.energies(num_levels)[-1],max(self.flux_qubit_potential())))\\n title('Ej=%.2f GHz, El=%.2f GHz, Ec=%.2f GHz, $\\\\Phi=%.2f \\\\, \\\\Phi_0$' % (self.Ej, self.El, self.Ec, self.phi))\",\n \"def plot_flux( source, ctr_freq, bandwidth, nchan, format1 = False, show = False, **kwargs ):\\n\\n freqs = psr_u.chan_to_freq( ctr_freq, bandwidth, nchan )\\n fluxes = []\\n for f in freqs:\\n flux = getFlux( f, source, format1 )\\n fluxes.append( flux )\\n\\n if show:\\n # Set up figure and axes\\n fig = plt.figure()\\n ax = fig.add_subplot( 111, facecolor = 'w' )\\n\\n xText = ax.set_xlabel( r\\\"Frequency (GHz)\\\" )\\n yText = ax.set_ylabel( r\\\"Flux (Jy)\\\" )\\n title = ax.set_title( r\\\"The change in flux (Jy) as a function of frequency (GHz)\\\" )\\n ax.plot( freqs, fluxes, **kwargs )\\n plt.show()\\n return ax\\n else:\\n return fluxes\",\n \"def plot_spectrum(self, sp1d, title=None, color='k'):\\n if title is not None:\\n self.set_title(title)\\n self.set_axis_label(''.join(['Wavelength [', sp1d.wunit.name, ']']),\\n 'x')\\n self.set_axis_label('Counts', 'y')\\n self.axplot.plot(sp1d.wlen, sp1d.counts, color)\\n self.axplot.axis('tight')\\n self.fig.canvas.draw()\\n return\",\n \"def plot(self, num_levels=10):\\n if num_levels == -1:\\n num_levels = len(self.energies())\\n print(self.energies(num_levels))\\n figure(figsize=(20, 5))\\n subplot(1, num_levels + 1, 1)\\n self.plot_potential()\\n #xlabel('$\\\\phi$')\\n for ii, psi2D in enumerate(self.get_2Dpsis(num_levels)):\\n subplot(1, num_levels + 1, ii + 2)\\n #imshow(psi2D.real,extent=(self.x[0],self.x[-1],self.y[0],self.y[-1]),interpolation=\\\"None\\\",aspect='auto')\\n imshow(psi2D.real, interpolation=\\\"None\\\", aspect='auto')\\n xlabel(ii)\",\n \"def _plot_robot(self):\\n try:\\n x = 200\\n y = 200\\n self.ax1.plot(x, y, marker='o', markersize=10, linestyle='None')\\n except Exception as err:\\n rospy.loginfo(err)\",\n \"def plot(self, ax, x_coord):\\n self._plot_band(ax, x_coord)\\n self._plot_label(ax, x_coord)\",\n \"def set_up(self):\\n self.h, = self.ax.plot(self.x, lw=2)\\n self.ax.set_ylim(0,100)\\n self.ax.set_xlim(0,100)\\n self.ax.title.set_text(self.config[\\\"title\\\"])\\n self.ax.set_xlabel(self.config[\\\"x_label\\\"])\\n self.ax.set_ylabel(self.config[\\\"y_label\\\"])\",\n \"def view(filename):\\n n, data, data_dB,sr,ch=inputwav(filename)\\n t=np.linspace(0,n/sr,n)\\n py.close()\\n fig, (ax1) = py.subplots(nrows=1) \\n ax1.plot(t[0:n:100],data[0:n:100],'k-',linewidth=1,label=filename)\\n ax1.legend(loc=1)\\n ax1.set_ylabel('Amplitude (Rel. Bit)')\\n ax1.set_xlabel('Time (s)')\",\n \"def plot(self):\\n self.plotsite()\\n self.plotbond()\\n plt.show()\",\n \"def our_plot(ax, event, plot_args, scale=1, limits=None):\\n _x = plot_args['x']\\n _y = plot_args['y']\\n ax.cla()\\n ax.plot(_x, _y, zorder=0, color='k', alpha=0.5)\\n ax.plot(_x + 200, _y, zorder=0, color='r', alpha=0.5)\\n if hasattr(event, 'xdata') and event is not None:\\n xmin, xmax, ymin, ymax = limits\\n deltax, deltay = xmax - xmin, ymax - ymin\\n\\n if event.xdata is not None and event.ydata is not None:\\n print(event.xdata, event.ydata, xmin, xmax, ymin, ymax, scale)\\n ax.set(xlim=[event.xdata - scale * deltax,\\n event.xdata + scale * deltax],\\n ylim=[event.ydata - scale * deltay,\\n event.ydata + scale * deltay])\\n ax.set_xticklabels([])\\n ax.set_yticklabels([])\\n ax.plot([event.xdata], [event.ydata], marker='+', color='k',\\n ms=20, alpha=0.25)\\n else:\\n ax.set(title='Press \\\"r\\\" to reset, \\\"z\\\" to undo last point')\\n\\n # plot coords\\n for it in range(len(newcoords)):\\n ax.scatter(*newcoords[it],\\n marker=r\\\"$ {} $\\\".format(it),\\n color='red', zorder=10)\\n for it in range(len(oldcoords)):\\n ax.scatter(*oldcoords[it],\\n marker=r\\\"$ {} $\\\".format(it),\\n color='black', zorder=10)\",\n \"def plot(\\n self,\\n color_map={\\n \\\"ex\\\": (1, 0.2, 0.2),\\n \\\"ey\\\": (1, 0.5, 0),\\n \\\"hx\\\": (0, 0.5, 1),\\n \\\"hy\\\": (0.5, 0.2, 1),\\n \\\"hz\\\": (0.2, 1, 1),\\n },\\n channel_order=None,\\n ):\\n\\n if channel_order is not None:\\n ch_list = channel_order()\\n else:\\n ch_list = self.channels\\n\\n n_channels = len(self.channels)\\n\\n fig = plt.figure()\\n fig.subplots_adjust(hspace=0)\\n ax_list = []\\n for ii, comp in enumerate(ch_list, 1):\\n try:\\n color = color_map[comp]\\n except KeyError:\\n color = (0, 0.4, 0.8)\\n if ii == 1:\\n ax = plt.subplot(n_channels, 1, ii)\\n else:\\n ax = plt.subplot(n_channels, 1, ii, sharex=ax_list[0])\\n self.dataset[comp].plot.line(ax=ax, color=color)\\n ax.grid(which=\\\"major\\\", color=(0.65, 0.65, 0.65), ls=\\\"--\\\", lw=0.75)\\n ax.grid(which=\\\"minor\\\", color=(0.85, 0.85, 0.85), ls=\\\"--\\\", lw=0.5)\\n ax.set_axisbelow(True)\\n if ii != len(ch_list):\\n plt.setp(ax.get_xticklabels(), visible=False)\\n\\n ax_list.append(ax)\",\n \"def plot_skyline_5578(fig_size,\\n flux_5578,\\n flux_5578_medfilt, show_plot=False):\\n fig, ax = plt.subplots(figsize=(fig_size, fig_size / 2.5))\\n ax.plot(flux_5578, alpha=0.5)\\n ax.plot(flux_5578_medfilt, alpha=1.0)\\n ax.set_ylabel(r\\\"Integrated flux of skyline 5578 $\\\\AA$\\\")\\n ax.set_xlabel(\\\"Fibre\\\")\\n p01 = np.nanpercentile(flux_5578, 1)\\n p99 = np.nanpercentile(flux_5578, 99)\\n ax.set_ylim(p01, p99)\\n ax.set_title(r\\\"Checking throughput correction using skyline 5578 $\\\\AA$\\\")\\n ax.tick_params(axis='both', which='minor')\\n if show_plot:\\n plt.show()\\n\\n return fig\",\n \"def plot_sine_evaluation(real_samples, fake_samples, idx, identifier):\\n ### frequency\\n seq_length = len(real_samples[0]) # assumes samples are all the same length\\n frate = seq_length\\n freqs_hz = np.fft.rfftfreq(seq_length)*frate # this is for labelling the plot\\n # TODO, just taking axis 0 for now...\\n w_real = np.mean(np.abs(np.fft.rfft(real_samples[:, :, 0])), axis=0)\\n w_fake = np.mean(np.abs(np.fft.rfft(fake_samples[:, :, 0])), axis=0)\\n ### amplitude\\n A_real = np.max(np.abs(real_samples[:, :, 0]), axis=1)\\n A_fake = np.max(np.abs(fake_samples[:, :, 0]), axis=1)\\n ### now plot\\n nrow = 2\\n ncol = 2\\n fig, axarr = plt.subplots(nrow, ncol, sharex='col', figsize=(6, 6))\\n # freq\\n axarr[0, 0].vlines(freqs_hz, ymin=np.minimum(np.zeros_like(w_real), w_real), ymax=np.maximum(np.zeros_like(w_real), w_real), color='#30ba50')\\n axarr[0, 0].set_title(\\\"frequency\\\", fontsize=16)\\n axarr[0, 0].set_ylabel(\\\"real\\\", fontsize=16)\\n axarr[1, 0].vlines(freqs_hz, ymin=np.minimum(np.zeros_like(w_fake), w_fake), ymax=np.maximum(np.zeros_like(w_fake), w_fake), color='#ba4730')\\n axarr[1, 0].set_ylabel(\\\"generated\\\", fontsize=16)\\n # amplitude\\n axarr[0, 1].hist(A_real, normed=True, color='#30ba50', bins=30)\\n axarr[0, 1].set_title(\\\"amplitude\\\", fontsize=16)\\n axarr[1, 1].hist(A_fake, normed=True, color='#ba4730', bins=30)\\n\\n fig.savefig('./experiments/plots/' + identifier + '_eval' + str(idx).zfill(4) +'.png')\\n plt.clf()\\n plt.close()\\n return True\",\n \"def plot_waveforms(data, name, title, directory_name):\\n plt.figure(figsize=(20, 10))\\n plt.plot(data)\\n plt.title(title)\\n plt.savefig('./' + directory_name + '/' + name)\\n pass\",\n \"def mplot(m, xlabel='', ylabel='', title='', custom=(7,7)):\\n lag = ps.lag_spatial(m.w, m.z)\\n fit = ps.spreg.OLS(m.z[:, None], lag[:,None])\\n\\n # Customize plot\\n fig = plt.figure(figsize=custom)\\n ax = fig.add_subplot(111)\\n\\n ax.set_xlabel(xlabel)\\n ax.set_ylabel(ylabel)\\n fig.suptitle(title)\\n\\n ax.scatter(m.z, lag, s=60, color='k', alpha=.6)\\n ax.plot(lag, fit.predy, color='r')\\n\\n ax.axvline(0, alpha=0.5)\\n ax.axhline(0, alpha=0.5)\\n\\n return fig\",\n \"def plot(self, *args, ax=None,\\n cmap_name='seismic', if_show=False, **kwargs):\\n import matplotlib.pylab as plt\\n\\n if ax is None:\\n ax = plt.gca()\\n plt.sca(ax)\\n\\n plt.imshow(\\n self, *args, cmap=plt.get_cmap(cmap_name),\\n extent=self.extent, **kwargs\\n )\\n\\n if if_show:\\n plt.colorbar(orientation='horizontal')\\n plt.show()\",\n \"def data2energy_plot(params, datadir, ylimmax='auto', plotBIND=False):\\n # get dirs\\n xypath = sorted(glob.glob(datadir + 'xyv/'))[0]\\n KLpath = sorted(glob.glob(datadir + 'KL/'))[0]\\n print 'found KL dir : ', KLpath\\n # list files\\n xyfiles = sorted(glob.glob(xypath + '*.txt'))\\n KLfiles = sorted(glob.glob(KLpath + '*.txt'))\\n # load setup\\n xy0file = sorted(glob.glob(datadir + 'xy.txt'))[0]\\n xyv0file = sorted(glob.glob(datadir + 'xyv0.txt'))[0]\\n\\n # Note the inversion of the naming system below!\\n # xy file is mesh, here stored as the variable xy0\\n xy0 = np.loadtxt(xy0file, delimiter=',', usecols=(0, 1))\\n\\n # xyv0 file is initial condition, store as xy and v, etc\\n xy = np.loadtxt(xyv0file, delimiter=',', usecols=(0, 1))\\n try:\\n '''Data is 5D (x,y,theta,phi,psi)'''\\n theta, phi, vx, vy, vtheta, vphi, vpsi = \\\\\\n np.loadtxt(xyv0file, delimiter=',', usecols=(2, 3, 5, 6, 7, 8, 9), unpack=True)\\n dimension = 5\\n except:\\n try:\\n '''Data is 3D'''\\n v0 = np.loadtxt(xyv0file, delimiter=',', usecols=(3, 4))\\n dimension = 3\\n except:\\n '''Data is 2D'''\\n v0 = np.loadtxt(xyv0file, delimiter=',', usecols=(2, 3))\\n dimension = 2\\n\\n NLfile = sorted(glob.glob(datadir + 'NL.txt'))[0]\\n NL = np.loadtxt(NLfile, dtype='int', delimiter=',')\\n # hfile = sorted(glob.glob(datadir+'h.txt'))[0]\\n # h = np.loadtxt(hfile)\\n h = params['h']\\n\\n # Load masses, from file, or else from params, or else define it as unity\\n if os.path.exists(datadir + 'Mm.txt'):\\n Mfile = sorted(glob.glob(datadir + 'Mm.txt'))[0]\\n Mm = np.loadtxt(Mfile)\\n print 'Loaded mass list from txt file...'\\n else:\\n try:\\n Mm = params['Mm']\\n print 'Loaded mass list from params dict...'\\n except:\\n Mm = np.ones_like(xy0[:, 0])\\n print 'le: WARNING: Could not find mass array, defined as unity...'\\n\\n # Calculate or load initial setup --> assumes KL at h=0 is same as initial\\n KL = np.loadtxt(KLfiles[0], delimiter=',')\\n BL = NL2BL(NL, KL)\\n bo = bond_length_list(xy0, BL)\\n\\n kL = KL2kL(NL, KL, BL) * params['k']\\n nzcount = np.count_nonzero(KL)\\n NP = len(xy0[:, 0])\\n print('NP = ' + str(NP))\\n\\n fig = plt.figure(1)\\n plt.clf()\\n if dimension < 5:\\n ax = plt.subplot(2, 1, 1)\\n ax2 = plt.subplot(2, 1, 2)\\n else:\\n ax = plt.subplot(4, 1, 1)\\n ax2 = plt.subplot(4, 1, 2)\\n ax3 = plt.subplot(4, 1, 3)\\n ax4 = plt.subplot(4, 1, 4)\\n\\n # Calc and plot initial vals\\n bU = potential_energy(xy, BL, bo, kL)\\n if dimension < 5:\\n KE = kinetic_energy(v0, Mm)\\n totE = bU + KE\\n else:\\n KE, KEvec, KE_bulk, T1, T2, T3, T4 = \\\\\\n kinetic_energy_rigidbody(theta, phi, vx, vy, vtheta, vphi, vpsi, Mm, params)\\n print 'KE = ', KE\\n # Gravitational potential energy\\n gU_v = Mm * params['g'] * params['l'] * np.cos(theta)\\n gU = np.sum(gU_v)\\n totE = bU + KE + gU\\n ax4.plot(-h, gU, 'g.') # label='Gravitational')\\n # ax3.plot(-h,totE-np.sum(0.5*params['I3']*(vpsi+vphi*np.cos(theta))**2),'k.')\\n\\n ax.plot(-h, totE - T4, 'k.') # ,label='Total')\\n ax3.plot(-h, bU, 'b.') # ,label='Elastic')\\n ax2.plot(-h, KE - T4, 'r.') # ,label='Kinetic')\\n ax2.plot(-h, T3, 'rx') # ,label='Kinetic')\\n\\n if plotBIND:\\n if 'BIND' in params:\\n if len(params['BIND']) > 0:\\n BIND = params['BIND']\\n fig2 = plt.figure(2)\\n plt.clf()\\n ax21 = plt.subplot(4, 1, 1)\\n ax22 = plt.subplot(4, 1, 2)\\n ax23 = plt.subplot(4, 1, 3)\\n ax24 = plt.subplot(4, 1, 4)\\n # ax.plot(-h,bU,'b.',label='Bulk Potential')\\n bulkIND = np.setdiff1d(np.arange(len(xy[:, 0])), BIND)\\n gU_bulk = np.sum(gU_v[bulkIND])\\n print 'bulkIND = ', bulkIND\\n print 'gU_particle4 = ', gU_bulk\\n totE_bulk = KE_bulk + bU + gU_bulk\\n ax21.plot(-h, totE_bulk, 's', color=[0.3, .3, .3])\\n ax22.plot(-h, KE_bulk, 's', color=[1.0, .5, .5]) # ,label='Bulk Kinetic')\\n ax23.plot(-h, bU, 'bs')\\n ax24.plot(-h, gU_bulk, 's', color=[0.5, 1.0, .5], markeredgecolor='none')\\n\\n ax21.set_ylabel('Total')\\n ax24.set_xlabel('time')\\n ax22.set_ylabel('Kinetic')\\n ax23.set_ylabel('Elastic')\\n ax24.set_ylabel('Gravitational')\\n\\n # make list of indices to plot\\n doall = range(0, len(xyfiles))\\n\\n print('Plotting energy vs t...')\\n for i in doall:\\n KL = np.loadtxt(KLfiles[i], delimiter=',')\\n iterind = (xyfiles[i].split('_')[-1]).split('.')[0]\\n t = float(iterind) * h\\n\\n if dimension < 5:\\n xy = np.loadtxt(xyfiles[i], delimiter=',', usecols=(0, 1))\\n v = np.loadtxt(xyfiles[i], delimiter=',', usecols=(2, 3))\\n KE = kinetic_energy(v, Mm)\\n else:\\n x, y, theta, phi = np.loadtxt(xyfiles[i], delimiter=',', usecols=(0, 1, 2, 3), unpack=True)\\n vx, vy, vtheta, vphi, vpsi = np.loadtxt(xyfiles[i], delimiter=',', usecols=(5, 6, 7, 8, 9), unpack=True)\\n xy = np.dstack((x, y))[0]\\n KE, KEvec, KE_bulk, T1, T2, T3, T4 = kinetic_energy_rigidbody(theta, phi, vx, vy, vtheta, vphi, vpsi, Mm,\\n params)\\n # Gravitational potential energy\\n gU_v = Mm * params['g'] ** params['l'] * np.cos(theta)\\n gU = np.sum(gU_v)\\n\\n # redo calculations of BL, bo, kL if bonds were cut\\n if np.count_nonzero(KL) != nzcount:\\n BL = NL2BL(NL, KL)\\n bo = bond_length_list(xy0, BL)\\n kL = KL2kL(NL, KL, BL) * params['k']\\n nzcount = np.count_nonzero(KL)\\n\\n if 'shrinkrate' in params:\\n if 'prestrain' in params:\\n bU = potential_energy(xy, BL, bo * (1. - params['prestrain'] - params['shrinkrate'] * t), kL)\\n else:\\n bU = potential_energy(xy, BL, bo * (1. - params['shrinkrate'] * t), kL)\\n else:\\n bU = potential_energy(xy, BL, bo, kL)\\n\\n if dimension < 5:\\n totE = bU + KE\\n else:\\n totE = bU + KE + gU\\n ax4.plot(t, gU, 'g.')\\n # ax3.plot(t,totE-np.sum(0.5*params['I3']*(vpsi+vphi*np.cos(theta))**2),'k.')\\n # ax3.plot(t,totE-np.sum(0.5*params['I3']*params['w3']**2),'k.')\\n\\n ax.plot(t, totE - T4, 'k.')\\n ax2.plot(t, KE - T4, 'r.')\\n # ax2.plot(t,T1,'ro') #,label='Kinetic')\\n # ax2.plot(t,T2,'r^') #,label='Kinetic')\\n # ax2.plot(t,T3,'rx') #,label='Kinetic')\\n ax3.plot(t, bU, 'b.')\\n\\n if plotBIND:\\n if 'BIND' in params:\\n if len(params['BIND']) > 0:\\n # ax.plot(-h,bU,'b.',label='Bulk Potential')\\n ax22.plot(t, KE_bulk, 's', color=[1.0, .5, .5], markeredgecolor='none') # 'Bulk Kinetic'\\n gU_bulk = np.sum(gU_v[bulkIND])\\n totE_bulk = KE_bulk + bU + gU_bulk\\n ax24.plot(t, gU_bulk, 's', color=[0.5, 1.0, .5], markeredgecolor='none')\\n ax23.plot(t, bU, 'bs')\\n ax21.plot(t, totE_bulk, 's', color=[0.5, .3, .3], markeredgecolor='none') # 'Bulk Total'\\n\\n title = 'Energy Conservation'\\n ax.set_title(title)\\n ax.set_ylabel(r'Total - $\\\\frac{I_3 \\\\omega_3^2}{2} $')\\n ax3.set_xlabel('time')\\n ax2.set_ylabel(r'Kinetic - $\\\\frac{I_3 \\\\omega_3^2}{2}$')\\n ax3.set_ylabel('Elastic')\\n\\n ax.set_xlim([-h, t])\\n ax2.set_xlim([-h, t])\\n ax3.set_xlim([-h, t])\\n\\n if dimension == 5:\\n ax4.set_ylabel('Gravitational')\\n ax4.set_xlim([-h, t])\\n ax3.set_xlabel('')\\n ax4.set_xlabel('time')\\n ax3.set_xticks([])\\n\\n # ylimit of first axis is either the last total energy or a large number\\n if ylimmax != 'auto':\\n ax.set_ylim(0, NP * ylimmax) # np.nanmin((totE,NP*ylimmax)))\\n print('ylim_max = ' + str(np.nanmin((totE, NP * ylimmax))))\\n\\n ax.set_xticks([])\\n ax2.set_xticks([])\\n\\n outname = datadir + 'Energy_vs_t.png'\\n plt.figure(1)\\n plt.savefig(outname)\\n\\n if plotBIND:\\n if 'BIND' in params:\\n if len(params['BIND']) > 0:\\n plt.figure(2)\\n ax21.set_xlim([-h, t])\\n ax22.set_xlim([-h, t])\\n ax23.set_xlim([-h, t])\\n ax24.set_xlim([-h, t])\\n\\n ax21.set_xticks([])\\n ax22.set_xticks([])\\n ax23.set_xticks([])\\n\\n outname = datadir + 'Energy_vs_t_BIND.png'\\n plt.savefig(outname)\\n\\n # ax.set_xlim([-h,5])\\n # ax2.set_xlim([-h,5])\\n # ax3.set_xlim([-h,5])\\n # ax4.set_xlim([-h,5])\\n #\\n # ax.set_xticks([])\\n # ax2.set_xticks([])\\n #\\n # outname = datadir+'Energy_vs_t_zoom.png'\\n # #plt.show()\\n # plt.figure(1)\\n # plt.savefig(outname)\",\n \"def builtin_plot(self, **kwargs):\\n self.gp.plot(**kwargs)\\n return\",\n \"def plot_couplingmatrix(self,lmax,nwins,show=True,fname=None):\\n figsize = mpl.rcParams['figure.figsize']\\n figsize[0] = figsize[1]\\n fig = plt.figure(figsize=figsize)\\n ax = fig.add_subplot(111)\\n coupling_matrix = self.get_couplingmatrix(lmax,nwins)\\n ax.imshow(coupling_matrix)\\n ax.set_xlabel('output power')\\n ax.set_ylabel('input power')\\n fig.tight_layout(pad=0.1)\\n\\n if show: plt.show()\\n if fname is not None:\\n fig.savefig(fname)\",\n \"def show():\\n plt.show()\",\n \"def show():\\n plt.show()\",\n \"def show():\\n plt.show()\",\n \"def show(self):\\n lines, = pylab.plot(self.wavelengths, self.intensities)\\n return lines\",\n \"def plot_zoom(ax, xlims):\\n\\n xmin, xmax, ymin, ymax = get_y_lims(ax, xlims)\\n ax.set_xlim(xmin, xmax)\\n ax.set_ylim(ymin, ymax)\\n\\n return ax\",\n \"def plot(axes, axis, values, c='chartreuse'):\\n a = axes[axis]\\n a.set_xlabel('time (s)')\\n x = np.array(range(len(values))) / 1000\\n dim = 'x' if axis == 0 else 'y' if axis == 1 else 'z'\\n a.set_title('-'.join([dim, 'acceleration']))\\n a.plot(x, values / 1000, c=c)\",\n \"def plot(self): \\n\\t\\txandy = sep_xy(self.start, self.end)\\n\\t\\tplt.plot(xandy[0], xandy[1], 'k-', lw=1, color='blue')\",\n \"def plot(self):\\n pass\",\n \"def peek(self, **kwargs):\\n\\n plt.figure()\\n axes = plt.gca()\\n data_lab=self.meta['OBS-FREQ'][0:2] + ' ' + self.meta['OBS-FREQ'][2:5]\\n axes.plot(self.data.index,self.data,label=data_lab)\\n axes.set_yscale(\\\"log\\\")\\n axes.set_ylim(1e-4,1)\\n axes.set_title('Nobeyama Radioheliograph')\\n axes.set_xlabel('Start time: ' + self.data.index[0].strftime(TIME_FORMAT))\\n axes.set_ylabel('Correlation')\\n axes.legend()\\n plt.show()\",\n \"def plot_powerlaw(self, **kwargs):\\n\\n if self.gamma is None:\\n self.exponent()\\n p = powerlaw.plot(exponent=-self.gamma,\\n xmax=self.max_deg, xmin=self.k_min,\\n **kwargs\\n )\\n pylab.show()\\n return p\",\n \"def _plot(self):\\r\\n fig = plt.figure()\\r\\n\\r\\n # Take out second component of intensity if needed\\r\\n # if self._vna.isTwoComponents():\\r\\n # intensitySimplified = []\\r\\n # for i in range(len(self._intensity)):\\r\\n # tempSet = []\\r\\n # for j in range(len(self._intensity[i])):\\r\\n # if (j%2) == 0:\\r\\n # tempSet.append(self._intensity[i][j])\\r\\n # intensitySimplified.append(tempSet)\\r\\n # for i in range(len(self._frequency)):\\r\\n # plt.plot(self._frequency[i],intensitySimplified[i],label=('%sv' % self._voltages[i][0]))\\r\\n # else:\\r\\n for i in range(len(self._frequency)):\\r\\n plt.plot(self._frequency[i],self._intensity[i],label=('%sv' % self._voltages[i][0]))\\r\\n plt.legend(loc='upper left')\\r\\n fig.suptitle('Intensity-Frequency with non-Constant Voltage', fontsize=18)\\r\\n plt.xlabel('Frequency (Hz)', fontsize=18)\\r\\n plt.ylabel('Intensity (dBm)', fontsize=16)\\r\\n\\r\\n # Save plot\\r\\n self._saveFig()\",\n \"def plot(self, x, y, mX = 1, mY = 1):\\n x = self.xy[x]\\n y = self.xy[y]\\n\\n # Find pareto front:\\n xp, yp = self.pareto_frontier(x,y, mX, mY)\\n\\n plt.plot(x, y, 'o')\\n plt.plot(xp, yp, '-')\\n plt.tight_layout()\\n plt.show()\",\n \"def plot_track_rigidbody(params, datadir, pp=4, zoom=None):\\n h = params['h']\\n\\n # get dirs\\n xypath = sorted(glob.glob(datadir + 'xyv/'))[0]\\n # list files\\n xyfiles = sorted(glob.glob(xypath + '*.txt'))\\n\\n plt.clf()\\n ax1 = plt.subplot(5, 1, 1)\\n ax2 = plt.subplot(5, 1, 2)\\n ax3 = plt.subplot(5, 1, 3)\\n ax4 = plt.subplot(5, 1, 4)\\n ax5 = plt.subplot(5, 1, 5)\\n doall = range(0, len(xyfiles))\\n for i in doall:\\n iterind = (xyfiles[i].split('_')[-1]).split('.')[0]\\n t = float(iterind) * h\\n\\n x, y, theta, phi, psi = np.loadtxt(xyfiles[i], delimiter=',', usecols=(0, 1, 2, 3, 4), unpack=True)\\n # vX,vY,vtheta,vphi,vpsi = np.loadtxt(xyfiles[i],delimiter=',', usecols=(5,6,7,8,9), unpack=True)\\n\\n ax1.plot(t, x[pp], 'k.')\\n ax2.plot(t, y[pp], 'r.')\\n ax3.plot(t, theta[pp], 'r.')\\n ax4.plot(t, phi[pp], 'r.')\\n ax5.plot(t, psi[pp], 'g.')\\n\\n title = 'Tracking Single Gyro'\\n ax1.set_title(title)\\n ax5.set_xlabel('time')\\n ax1.set_ylabel('X')\\n ax2.set_ylabel('Y')\\n ax3.set_ylabel(r'$\\\\theta$')\\n ax4.set_ylabel(r'$\\\\phi$')\\n ax5.set_ylabel(r'$\\\\psi$')\\n\\n ax1.set_xlim([-h, t])\\n ax2.set_xlim([-h, t])\\n ax3.set_xlim([-h, t])\\n ax4.set_xlim([-h, t])\\n ax5.set_xlim([-h, t])\\n\\n ax1.set_xticks([])\\n ax2.set_xticks([])\\n ax3.set_xticks([])\\n ax4.set_xticks([])\\n\\n outname = datadir + 'Track.png'\\n plt.savefig(outname)\\n\\n if zoom != None:\\n ax1.set_xlim([-h, zoom])\\n ax2.set_xlim([-h, zoom])\\n ax3.set_xlim([-h, zoom])\\n ax4.set_xlim([-h, zoom])\\n ax5.set_xlim([-h, zoom])\\n\\n outname = datadir + 'Track_zoom.png'\\n plt.savefig(outname)\",\n \"def showPlot1(title, x_label, y_label):\\n num_robot_range = range(1, 11)\\n times1 = []\\n times2 = []\\n for num_robots in num_robot_range:\\n print \\\"Plotting\\\", num_robots, \\\"robots...\\\"\\n times1.append(runSimulation(num_robots, 1.0, 20, 20, 0.8, 20, StandardRobot))\\n times2.append(runSimulation(num_robots, 1.0, 20, 20, 0.8, 20, RandomWalkRobot))\\n pylab.plot(num_robot_range, times1)\\n pylab.plot(num_robot_range, times2)\\n pylab.title(title)\\n pylab.legend(('StandardRobot', 'RandomWalkRobot'))\\n pylab.xlabel(x_label)\\n pylab.ylabel(y_label)\\n pylab.show()\",\n \"def display1(*args):\\n #----------*----------* # unpack\\n twiss_func = args[0]\\n lat_plot = args[3]\\n #-------------------- beta x,y & dispersion x\\n s = [twiss_func(i,'s') for i in range(twiss_func.nbpoints)]\\n bx = [twiss_func(i,'bx') for i in range(twiss_func.nbpoints)]\\n by = [twiss_func(i,'by') for i in range(twiss_func.nbpoints)]\\n dx = [twiss_func(i,'dx') for i in range(twiss_func.nbpoints)]\\n #-------------------- lattice viseo\\n vzero = [0. for i in range(lat_plot.nbpoints)] # zero line\\n vis_abszisse = [lat_plot(i,'s') for i in range(lat_plot.nbpoints)]\\n vis_ordinate = [lat_plot(i,'viseo') for i in range(lat_plot.nbpoints)]\\n #-------------------- figure frame\\n width=14; height=7.6\\n plt.figure(num=0,figsize=(width,height),facecolor='#eaecef',tight_layout=False)\\n\\n #-------------------- transverse X\\n splot111=plt.subplot(111)\\n splot111.set_title('beta functions')\\n plt.plot(s,bx, label=r'$\\\\beta_x$ [m]', color='red', linestyle='-') # beta x\\n plt.plot(s,by, label=r'$\\\\beta_y$ [m]', color='blue', linestyle='-') # beta y\\n plt.plot(s,dx, label=r'$\\\\eta_x$ [m]' , color='green',linestyle='-') # dispersion x\\n vscale=splot111.axis()[3]*0.25\\n viseoz = [x*vscale for x in vis_ordinate]\\n plt.plot(vis_abszisse,viseoz,label='',color='black')\\n plt.plot(vis_abszisse,vzero,color='black')\\n plt.legend(loc='lower right',fontsize='x-small')\",\n \"def visualize_signal(self):\\n plt.figure()\\n plt.title('Accelerometer Signal')\\n plt.plot(range(len(self.data)), self.data[1])\",\n \"def raster_plot(nucleus, label=None, **kwargs):\\r\\n\\r\\n # Get fireds data\\r\\n fireds = nucleus.historique['fired']\\r\\n\\r\\n # Build x-axis and y-axis data by looping through fireds\\r\\n xdata, ydata = [], []\\r\\n for x, fires in fireds.items():\\r\\n for y in fires:\\r\\n xdata.append(x)\\r\\n ydata.append(y)\\r\\n\\r\\n # Matplotlib\\r\\n fig = plt.figure()\\r\\n plt.plot(xdata, ydata, '|', **kwargs)\\r\\n plt.ylabel('Neuron indexes')\\r\\n plt.xlabel('time')\\r\\n if label is None and nucleus.label is None:\\r\\n plt.title('Raster plot')\\r\\n elif label is not None and nucleus.label is None:\\r\\n plt.title('Raster plot (%s)' % label)\\r\\n elif label is None and nucleus.label is not None:\\r\\n plt.title('Raster plot of %s' % nucleus.label)\\r\\n else:\\r\\n plt.title('Raster plot of %s (%s)' % (nucleus.label, label))\\r\\n\\r\\n return fig\",\n \"def plot(self, A = None):\\r\\n if A is not None: self.A = A\\r\\n self.im.set_data(self.A)\\r\\n self.ax.draw_artist(self.im)\\r\\n self.fig.canvas.blit(self.ax.bbox)\",\n \"def plot_linear(x_range, w, b):\\n\\tplt.plot(x_range, x_range * w + b)\",\n \"def plot_motion(x, y):\\n plt.xlabel(\\\"X Position (m)\\\")\\n plt.ylabel(\\\"Y Position (m)\\\")\\n plt.plot(x, y)\\n plt.show()\",\n \"def plot_3d(self, ax_3d: Axes3D, lims_x: array_like = (-1, 1), lims_y: array_like = (-1, 1), **kwargs) -> None:\\n X, Y, Z = self.to_mesh(lims_x, lims_y)\\n\\n ax_3d.plot_surface(X, Y, Z, **kwargs)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.68588203","0.6669191","0.6541369","0.6513319","0.63761437","0.6271679","0.62557006","0.62491953","0.62296474","0.6115451","0.6069608","0.6046171","0.6036858","0.6034111","0.60327625","0.5983629","0.59748536","0.59711856","0.59539765","0.5939472","0.59292793","0.59288126","0.592524","0.5925189","0.59239113","0.5918411","0.59183955","0.591648","0.59015787","0.58993685","0.58949673","0.5838952","0.5816571","0.5801826","0.5786137","0.57838863","0.578334","0.5776295","0.57683706","0.5762522","0.57552737","0.57547635","0.57504326","0.5749873","0.574748","0.57416457","0.5740143","0.5731061","0.57290983","0.5728197","0.57239264","0.5701723","0.56924933","0.567838","0.5672556","0.56723005","0.56712496","0.567102","0.566578","0.56605333","0.5660507","0.565027","0.56494224","0.5631876","0.56298006","0.5628934","0.56279844","0.5622443","0.5613038","0.56091547","0.5605279","0.55987364","0.5596038","0.55803776","0.55793136","0.5566194","0.55651414","0.5563384","0.5560481","0.5551057","0.5549115","0.5549115","0.5549115","0.55474716","0.5545745","0.55401385","0.55368876","0.55340075","0.5533181","0.5530925","0.5524954","0.5523344","0.5522642","0.55219615","0.5516114","0.55121166","0.5503256","0.5500097","0.54887974","0.5487313","0.5484328"],"string":"[\n \"0.68588203\",\n \"0.6669191\",\n \"0.6541369\",\n \"0.6513319\",\n \"0.63761437\",\n \"0.6271679\",\n \"0.62557006\",\n \"0.62491953\",\n \"0.62296474\",\n \"0.6115451\",\n \"0.6069608\",\n \"0.6046171\",\n \"0.6036858\",\n \"0.6034111\",\n \"0.60327625\",\n \"0.5983629\",\n \"0.59748536\",\n \"0.59711856\",\n \"0.59539765\",\n \"0.5939472\",\n \"0.59292793\",\n \"0.59288126\",\n \"0.592524\",\n \"0.5925189\",\n \"0.59239113\",\n \"0.5918411\",\n \"0.59183955\",\n \"0.591648\",\n \"0.59015787\",\n \"0.58993685\",\n \"0.58949673\",\n \"0.5838952\",\n \"0.5816571\",\n \"0.5801826\",\n \"0.5786137\",\n \"0.57838863\",\n \"0.578334\",\n \"0.5776295\",\n \"0.57683706\",\n \"0.5762522\",\n \"0.57552737\",\n \"0.57547635\",\n \"0.57504326\",\n \"0.5749873\",\n \"0.574748\",\n \"0.57416457\",\n \"0.5740143\",\n \"0.5731061\",\n \"0.57290983\",\n \"0.5728197\",\n \"0.57239264\",\n \"0.5701723\",\n \"0.56924933\",\n \"0.567838\",\n \"0.5672556\",\n \"0.56723005\",\n \"0.56712496\",\n \"0.567102\",\n \"0.566578\",\n \"0.56605333\",\n \"0.5660507\",\n \"0.565027\",\n \"0.56494224\",\n \"0.5631876\",\n \"0.56298006\",\n \"0.5628934\",\n \"0.56279844\",\n \"0.5622443\",\n \"0.5613038\",\n \"0.56091547\",\n \"0.5605279\",\n \"0.55987364\",\n \"0.5596038\",\n \"0.55803776\",\n \"0.55793136\",\n \"0.5566194\",\n \"0.55651414\",\n \"0.5563384\",\n \"0.5560481\",\n \"0.5551057\",\n \"0.5549115\",\n \"0.5549115\",\n \"0.5549115\",\n \"0.55474716\",\n \"0.5545745\",\n \"0.55401385\",\n \"0.55368876\",\n \"0.55340075\",\n \"0.5533181\",\n \"0.5530925\",\n \"0.5524954\",\n \"0.5523344\",\n \"0.5522642\",\n \"0.55219615\",\n \"0.5516114\",\n \"0.55121166\",\n \"0.5503256\",\n \"0.5500097\",\n \"0.54887974\",\n \"0.5487313\",\n \"0.5484328\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":24990,"cells":{"query":{"kind":"string","value":"Plots an xy graph at a certain specified wavelength onto the current axes. Keyword arguments are passed on to matplotlib."},"document":{"kind":"string","value":"def plot_wavelength_slice(self, offset, **kwargs):\n cumul_cube_lengths = np.cumsum(np.array([c.shape[self.common_axis]\n for c in self.data]))\n sequence_index, cube_index = cu._convert_cube_like_index_to_sequence_indices(\n offset, cumul_cube_lengths)\n plot = self[sequence_index].plot_wavelength_slice(cube_index, **kwargs)\n return plot"},"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 liveplot(x, y, xlim, ylim, title):\n plt.plot(x,y,'b.')\n plt.xlim(xlim)\n plt.ylim(ylim)\n plt.xlabel('North-South Axis')\n plt.ylabel('East-West Axis')\n plt.title(title)\n plt.show()","def plot_xyz():\n plt.subplot(3,1,1) # for x axis\n plt.title('x value v.s. time')\n plt.grid(True)\n plt.ylabel('X')\n plt.xlabel('t')\n plt.plot(x, '-r')\n\n plt.subplot(3,1,2) # for y axis\n plt.title('y value v.s. time')\n plt.grid(True)\n plt.ylabel('Y')\n plt.xlabel('t')\n plt.plot(y, '-g')\n\n plt.subplot(3,1,3) # for z axis\n plt.title('z value v.s. time')\n plt.grid(True)\n plt.ylabel('Z')\n plt.xlabel('t')\n plt.plot(z, '-b')","def xyplot(x_vals,y_vals,name):\n # set the figure's size\n set_figsize(figsize=(5, 2.5))\n # detach() is used to get a variable from the current calculation graph\n # in which this variable is the not gradient tracking version\n plt.plot(x_vals.detach().numpy(), y_vals.detach().numpy())\n # set the constant x axis label\n plt.xlabel('x')\n # combine and set the y axis label\n plt.ylabel(name+'(x)')\n plt.show()","def plot_xy(x, y, ax=None, xlabel='Energy [keV]', **kwargs):\n\n if not ax:\n new_plot = True\n plt.figure()\n ax = plt.axes()\n else:\n new_plot = False\n\n plt.semilogy(x, y, axes=ax, drawstyle='steps-mid', **kwargs)\n\n if new_plot:\n plt.xlabel(xlabel)\n plt.ylabel('Counts')\n\n if 'label' in kwargs:\n plt.legend()\n plt.show()\n\n return ax","def plotWavelet(self):\n\n a = 0\n if(self.axQT is not None):\n self._bxPlot()\n a += 1\n if(self.bxQT is not None):\n self._cxPlot()\n a += 1\n\n if(a > 0):\n return\n\n self._setupPlot()\n self._axPlot()\n self._bxPlot()\n self._cxPlot()\n self._dxPlot()\n self._endingPlot()","def plot(self):\n plot_spectrum(self.data, self.fig, self.ax_e, self.ax_s, title = \"Solar spectrum\")","def plot_simulation_xz(\n sim: td.Simulation,\n x: float = 0.0,\n z: float = 0.0,\n wavelength: Optional[float] = 1.55,\n figsize: Float2 = (11, 4),\n):\n fig = plt.figure(figsize=figsize)\n gs = mpl.gridspec.GridSpec(1, 2, figure=fig, width_ratios=[1, 1.4])\n ax1 = fig.add_subplot(gs[0, 0])\n ax2 = fig.add_subplot(gs[0, 1])\n if wavelength:\n freq = td.constants.C_0 / wavelength\n sim.plot_eps(z=z, ax=ax1, freq=freq)\n sim.plot_eps(x=x, ax=ax2, freq=freq)\n else:\n sim.plot(z=z, ax=ax1)\n sim.plot(x=x, ax=ax2)\n plt.show()\n return fig","def plot(self, ax=..., *, name=..., **kwargs):\n ...","def show_plot() :\n logger.info(\"Show plot\")\n pylab.axis('equal')\n pylab.xlabel(\"Longitud\")\n pylab.ylabel(\"Latitud\")\n pylab.grid(True)\n pylab.title(\"Product tiles and product source\")\n pylab.show()","def plot_xy(self, xpts, ypts):\n self.plot(np.asarray((xpts, ypts)).T)","def plotSpectrum(inp,xrng=[],yrng=[],xlabel='',ylabel='',xlog=False,ylog=False,grid=False,\n legend=[],legend_location='upper right',fontscale=1,legend_fontscale=1,title='',\n color='k',colormap=None,linestyle='-',linewidth=1.5,alpha=1.,\n show_noise=True,color_noise='k',linestyle_noise='-',linewidth_noise=1.5,alpha_noise=0.5,\n comparison=None,color_comparison='grey',linestyle_comparison='-',linewidth_comparison=1.5,alpha_comparison=1,\n residual=False,color_residual='m',linestyle_residual='-',linewidth_residual=1.5,alpha_residual=0.5,\n telluric=False,color_telluric='grey',linestyle_telluric='-',linewidth_telluric=1.5,alpha_telluric=0.2,\n features=[],mdwarf=False,ldwarf=False,tdwarf=False,young=False,binary=False,nsamples=100,\n band=[],band_color='k',band_alpha=0.2,band_label='',band_label_position='bottom',band_width=0.1,\n show_zero=True,stack=0.,zeropoint=0.,color_zero='k',linestyle_zero=':',linewidth_zero=1.5,alpha_zero=0.3,\n inset=False,inset_xrange=[],inset_yrange=[],inset_position=[0.65,0.60,0.20,0.20],inset_features=False,\n output='',multiplot=False,multipage=False,layout=[1,1],figsize=[],tight=True,\n interactive=False,**kwargs):\n\n# keyword parameters (for backward compatability)\n for k in ['showZero','showzero']: show_zero=kwargs.get(k,show_zero)\n for k in ['showNoise','noise','uncertainty','shownoise','showuncertainty','show_uncertainty']: show_noise=kwargs.get(k,show_noise)\n\n for k in ['line_style','lineStyle','ls','linestyles','line_styles']: linestyle=kwargs.get(k,linestyle)\n for k in ['line_width','lineWidth','width','lw','linewidths','line_widths']: linewidth=kwargs.get(k,linewidth)\n for k in ['colors','colour','colours']: color=kwargs.get(k,color)\n for k in ['colorScheme','color_scheme','colorscheme','colorMap','color_map']: colormap=kwargs.get(k,colormap)\n\n for k in ['colornoise','colorNoise','colorUnc','coloruncertainty','color_uncertainty','colorUncertainty']: color_noise=kwargs.get(k,color_noise)\n for k in ['linestylenoise','line_style_noise','linestyleNoise']: linestyle_noise=kwargs.get(k,linestyle_noise)\n for k in ['linewidthnoise','linewidthNoise','line_width_noise']: linewidth_noise=kwargs.get(k,linewidth_noise)\n for k in ['alphanoise','alphaNoise']: alpha_noise=kwargs.get(k,alpha_noise)\n\n for k in ['colorzero','colorZero']: color_zero=kwargs.get(k,color_zero)\n for k in ['linestylezero','line_style_zero','linestyleZero']: linestyle_zero=kwargs.get(k,linestyle_zero)\n for k in ['linewidthzero','linewidthZero','line_width_zero']: linewidth_zero=kwargs.get(k,linewidth_zero)\n for k in ['alphazero','alphaZero']: alpha_zero=kwargs.get(k,alpha_zero)\n\n for k in ['colorcomparison','colorComparison']: color_comparison=kwargs.get(k,color_comparison)\n for k in ['linestyleComparison','line_style_comparison','linestylecomparison']: linestyle_comparison=kwargs.get(k,linestyle_comparison)\n for k in ['linewidthcomparison','linewidthComparison','line_width_comparison']: linewidth_comparison=kwargs.get(k,linewidth_comparison)\n for k in ['alphacomparison','alphaComparison']: alpha_comparison=kwargs.get(k,alpha_comparison)\n\n for k in ['colorresidual','colorResidual']: color_residual=kwargs.get(k,color_residual)\n for k in ['linestyleresidual','line_style_residual','linestyleResidual']: linestyle_residual=kwargs.get(k,linestyle_residual)\n for k in ['linewidthresidual','linewidthResidual','line_width_residual']: linewidth_residual=kwargs.get(k,linewidth_residual)\n for k in ['alpharesidual','alphaResidual']: alpha_residual=kwargs.get(k,alpha_residual)\n\n for k in ['bands']: band=kwargs.get(k,band)\n if len(band) == 2 and isinstance(band[0],list) == False: band = [band]\n for k in ['bandcolors','bandcolor','band_colors']: band_color=kwargs.get(k,band_color)\n for k in ['bandalphas','band_alphas','bandalpha']: band_alpha=kwargs.get(k,band_alpha)\n for k in ['band_labels','bandlabel','bandlabels']: band_label=kwargs.get(k,band_label)\n for k in ['band_label_positions','bandlabelposition','bandlabelpositions']: band_label_position=kwargs.get(k,band_label_position)\n for k in ['bandwidth','bandwidths','band_widths']: band_width=kwargs.get(k,band_width)\n for par in [band_color,band_alpha,band_label,band_label_position,band_width]:\n if not isinstance(par,list): par = [par]*len(band)\n if len(par) < len(band): par.extend([par[-1] for x in range(len(band)-len(par))])\n\n for k in ['legends','label','labels']: legend=kwargs.get(k,legend)\n if not isinstance(legend,list): legend = [legend]\n for k in ['legendfontscale','legendFontscale']: legend_fontscale=kwargs.get(k,legend_fontscale)\n legend_fontscale=legend_fontscale*fontscale\n for k in ['legendLocation','legendlocation','labelLocation','labellocation','label_location']: legend_location=kwargs.get(k,legend_location)\n\n for k in ['xrange','x_range','wave_range','wrange','wrng']: xrng=kwargs.get(k,xrng)\n if not isinstance(xrng,list): xrng = [xrng]\n for k in ['yrange','y_range','flux_range','frange','frng']: yrng=kwargs.get(k,yrng)\n if not isinstance(yrng,list): yrng = [yrng]\n\n for k in ['multilayout','multiLayout','multi_layout']: layout=kwargs.get(k,layout)\n for k in ['file','filename']: output=kwargs.get(k,output)\n if not isinstance(output,str): output=''\n filetype = '.pdf'\n if output!='': filetype=output.split('.')[-1]\n\n if comparison != None and isinstance(comparison,splat.Spectrum) == False and isinstance(comparison,list) == False: \n print('plotSpectrum() Warning: comparison spectrum should be a splat Spectrum object, you passed {}'.format(comparison))\n comparison = None\n\n# some plotting constants\n xlabel_default = 'Wavelength'\n ylabel_deafult = 'Flux'\n\n# telluric bands in micron\n telluric_bands = [[1.1,1.2]*u.micron,[1.3,1.5]*u.micron,[1.75,2.0]*u.micron]\n\n# assign features by group\n if not isinstance(features,list): features = [features]\n if ldwarf==True or mdwarf==True: features.extend(['k','na','feh','tio','co','h2o','h2'])\n if tdwarf==True: features.extend(['k','ch4','h2o','h2'])\n if young==True: features.extend(['vo'])\n if binary==True: features.extend(['sb'])\n\n# clean repeats in features while maintaining order - set does not do this\n if len(features)>0:\n fea = []\n for i in features:\n if i not in fea: fea.append(i)\n features = fea\n\n\n# if a list is passed, use this list\n splist = copy.deepcopy(inp)\n if isinstance(splist,list) == False: splist = [splist]\n \n# set up for multiplot\n if len(splist) == 1: multiplot = False\n \n# array of lists => force multiplot\n elif len(splist) > 1 and isinstance(splist[0],list) == True: multiplot = True\n else: pass\n\n# reformat array of spectra of multiplot is used (i.e., user forgot to set)\n if multiplot == True and isinstance(splist[0],splat.Spectrum):\n splist = [[s] for s in splist]\n\n elif multiplot == False and isinstance(splist[0],splat.Spectrum):\n splist = [splist]\n \n# flatten array if multiplot is not set\n elif multiplot == False and isinstance(splist[0],list) and len(splist) > 1:\n splist = [[item for sublist in splist for item in sublist]] # flatten\n else: pass\n\n# total number of spectra - use to assign default legends\n allsps = [item for sublist in splist for item in sublist] # Total number of spectra\n if len(legend) == 0: legend=[sp.name for sp in allsps]\n if len(legend) < len(allsps):\n legend.extend([allsps[i].name for i in range(len(legend),len(allsps)-len(legend))])\n \n\n# now run a loop through the input subarrays\n plt.close('all')\n\n# set up here for multiple file output\n nplot = 1\n if multipage == True or multiplot == True:\n nplot = layout[0]*layout[1]\n numpages = int(len(splist) / nplot) + 1\n if (len(splist) % nplot == 0):\n numpages -= 1\n fig = []\n \n if multipage == True and filetype.lower() == 'pdf':\n pdf_pages = PdfPages(output)\n \n if multipage == False:\n if len(splist) > 1:\n filebase = output.replace('.{}'.format(filetype),'')\n files = [filebase+'{}.'.format(i+1)+filetype for i in numpy.arange(len(splist))]\n else:\n files = [output]\n\n pg_n = 0 # page counter\n plt_n = 0 # plot per page counter\n lg_n = 0 # legend per plot counter\n\n for plts,sp in enumerate(splist):\n# set specific plot parameters\n if not isinstance(sp[0],splat.Spectrum):\n raise ValueError('\\nInput to plotSpectrum has wrong format:\\n\\n{}\\n\\n'.format(sp[0]))\n\n# set up plotting defaults for the list of spectra - REPLACE THIS\n if not isinstance(zeropoint,list): zeropoint = [zeropoint]*len(sp)\n if len(zeropoint) < len(sp): zeropoint.extend([zeropoint[-1] for x in range(len(sp)-len(zeropoint))])\n if not isinstance(color,list): color = [color]*len(sp)\n if len(color) < len(sp): color.extend([color[-1] for x in range(len(sp)-len(color))])\n if not isinstance(linestyle,list): linestyle = [linestyle]*len(sp)\n if len(linestyle) < len(sp): linestyle.extend([linestyle[-1] for x in range(len(sp)-len(linestyle))])\n if not isinstance(linewidth,list): linewidth = [linewidth]*len(sp)\n if len(linewidth) < len(sp): linewidth.extend([linewidth[-1] for x in range(len(sp)-len(linewidth))])\n if not isinstance(alpha,list): alpha = [alpha]*len(sp)\n if len(alpha) < len(sp): alpha.extend([alpha[-1] for x in range(len(sp)-len(alpha))])\n if not isinstance(color_noise,list): color_noise = [color_noise]*len(sp)\n if len(color_noise) < len(sp): color_noise.extend([color_noise[-1] for x in range(len(sp)-len(color_noise))])\n if not isinstance(linestyle_noise,list): linestyle_noise = [linestyle_noise]*len(sp)\n if len(linestyle_noise) < len(sp): linestyle_noise.extend([linestyle_noise[-1] for x in range(len(sp)-len(linestyle_noise))])\n if not isinstance(linewidth_noise,list): linewidth_noise = [linewidth_noise]*len(sp)\n if len(linewidth_noise) < len(sp): linewidth_noise.extend([linewidth_noise[-1] for x in range(len(sp)-len(linewidth_noise))])\n if not isinstance(alpha_noise,list): alpha_noise = [alpha_noise]*len(sp)\n if len(alpha_noise) < len(sp): alpha_noise.extend([alpha_noise[-1] for x in range(len(sp)-len(color_noise))])\n if not isinstance(color_comparison,list): color_comparison = [color_comparison]*len(sp)\n if len(color_comparison) < len(sp): color_comparison.extend([color_comparison[-1] for x in range(len(sp)-len(color_comparison))])\n if not isinstance(linestyle_comparison,list): linestyle_comparison = [linestyle_comparison]*len(sp)\n if len(linestyle_comparison) < len(sp): linestyle_comparison.extend([linestyle_comparison[-1] for x in range(len(sp)-len(linestyle_comparison))])\n if not isinstance(linewidth_comparison,list): linewidth_comparison = [linewidth_comparison]*len(sp)\n if len(linewidth_comparison) < len(sp): linewidth_comparison.extend([linewidth_comparison[-1] for x in range(len(sp)-len(linewidth_comparison))])\n if not isinstance(alpha_comparison,list): alpha_comparison = [alpha_comparison]*len(sp)\n if len(alpha_comparison) < len(sp): alpha_comparison.extend([alpha_comparison[-1] for x in range(len(sp)-len(alpha_comparison))])\n\n# settings that work if the spectrum was read in as legitmate Spectrum object\n try:\n xlabel = kwargs.get('xlabel','{} ({})'.format(sp[0].wave_label,sp[0].wave.unit))\n ylabel = kwargs.get('ylabel','{} ({})'.format(sp[0].flux_label,sp[0].flux.unit))\n except:\n xlabel = kwargs.get('xlabel',xlabel_default)\n ylabel = kwargs.get('ylabel',ylabel_default)\n# initial plot range\n bound = [numpy.nanmin(sp[0].wave.value),numpy.nanmax(sp[0].wave.value)]\n ymax = [numpy.nanquantile(s.flux.value,0.98) for s in sp]\n bound.extend(numpy.array([-0.02,1.3])*numpy.nanmax(ymax)+\\\n numpy.array([numpy.nanmin(zeropoint),numpy.nanmax(zeropoint)+stack*(len(sp)-1)]))\n\n# set colormap if provided\n if colormap != None:\n values = numpy.arange(len(sp))\n color_map = plt.get_cmap(colormap)\n norm = colmap.Normalize(vmin=0, vmax=1.0*values[-1])\n scalarMap = cm.ScalarMappable(norm=norm, cmap=color_map)\n for i in range(len(sp)): color[i] = scalarMap.to_rgba(values[i])\n\n# GENERATE PLOTS\n if multiplot == True or multipage == True:\n plt_n = plts % nplot\n if (plt_n == 0):\n fig.append(plt.figure())\n pg_n += 1\n ax = fig[pg_n-1].add_subplot(layout[0], layout[1], plt_n+1)\n \n# plotting a single plot with all spectra\n else:\n plt.close('all')\n plt_n = 0\n fig = []\n if len(figsize)>0: fig.append(plt.figure(figsize=figsize))\n else: fig.append(plt.figure())\n ax = fig[0].add_subplot(111)\n \n for ii, a in enumerate(sp):\n# zeropoint and stack\n flx = [i+zeropoint[ii] for i in a.flux.value]\n if stack > 0: flx = [f + (len(sp)-ii-1)*stack for f in flx]\n ax.plot(a.wave.value,flx,color=color[ii],linestyle=linestyle[ii], lw=linewidth[ii], alpha=alpha[ii], zorder = 10, label = legend[lg_n]) \n\n# add comparison\n if comparison != None:\n# zeropoint and stack\n cflx = [i+zeropoint[ii] for i in comparison.flux.value]\n if stack > 0: cflx = [f + (len(sp)-ii-1)*stack for f in cflx]\n ax.plot(comparison.wave.value,cflx,color=color_comparison[ii],linestyle=linestyle_comparison[ii], lw=linewidth_comparison[ii], alpha=alpha_comparison[ii], zorder = 10)\n \n# add residual\n if residual == True and len(sp) == 2:\n # Save flux values from first spectrum\n if ii == 0:\n flx0 = [f - (len(sp)-ii-1)*stack for f in flx]\n \n # Subtract fluxes and plot\n elif ii == 1:\n res = [flx0[f_n] - f for f_n, f in enumerate(flx)]\n ax.plot(a.wave.value, res, alpha = alpha_residual[ii], color = color_residual[ii], linsetyle=linestyle_residual[ii], lw=linewidth_residual[ii])\n \n # Fix bound[2] if residual goes below 0\n if numpy.nanmin(res) < bound[2]:\n b0 = numpy.argmin(a.wave.value[a.wave.value > bound[0]])\n b1 = numpy.argmax(a.wave.value[a.wave.value < bound[1]])\n bound[2] = numpy.nanmin(res[b0:b1])\n\n# noise\n if show_noise == True:\n ns = [i+zeropoint[ii] for i in a.noise.value]\n ax.plot(a.wave.value,ns,color=color_noise[ii],linestyle=linestyle_noise[ii],alpha=alpha_noise[ii], lw=linewidth_noise[ii], zorder = 10)\n\n# zeropoint\n if show_zero == True:\n ze = numpy.ones(len(a.flux))*zeropoint[ii]\n ax.plot(a.wave.value,ze,color=color[ii],linestyle=linestyle_zero,alpha=alpha_zero,lw=linewidth_zero, zorder = 10)\n\n# save maximum flux among all spectra for plotting\n# THIS IS VERY SLOW AND IT WOULD BE BETTER TO FIND AN ALTERNATE APPROACH\n if len(features)>0:\n f = interp1d(a.wave,flx,bounds_error=False,fill_value=0.)\n if ii == 0: \n wvmax = numpy.linspace(bound[0],bound[1],nsamples)\n flxmax = numpy.array(f(wvmax))\n else: flxmax = numpy.maximum(flxmax,numpy.array(f(wvmax)))\n\n# legend counter\n lg_n = lg_n + 1 # Increment legend\n\n\n# label features\n# THIS NEEDS TO BE FIXED WITH GRETEL'S STUFF\n if len(features) > 0:\n yoff = 0.02*(bound[3]-bound[2]) # label offset\n fontsize = int((10-numpy.nanmin([(layout[0]*layout[1]-1),6]))*fontscale)\n for ftr in features:\n ftr = ftr.lower()\n if ftr in FEATURE_LABELS:\n ftrc = checkDict(ftr,FEATURE_LABELS)\n if ftrc != False:\n for ii,waveRng in enumerate(FEATURE_LABELS[ftrc]['wavelengths']):\n wRng = waveRng.to(sp[0].wave.unit).value\n# features must be contained in plot range (may change this)\n if numpy.nanmin(wRng) > bound[0] and numpy.nanmax(wRng) < bound[1]:\n wfeature = numpy.where(numpy.logical_and(wvmax >= numpy.nanmin(wRng),wvmax <= numpy.nanmax(wRng)))\n if len(wvmax[wfeature]) == 0: wfeature = numpy.argmax(numpy.absolute(wvmax-numpy.nanmedian(wRng)))\n y = numpy.nanmax(flxmax[wfeature])+yoff\n flxmax[wfeature] = flxmax[wfeature]+3.*yoff\n\n if FEATURE_LABELS[ftrc]['type'] == 'band':\n ax.plot(wRng,[y+yoff]*2,color='k',linestyle='-')\n ax.plot([wRng[0]]*2,[y,y+yoff],color='k',linestyle='-')\n ax.text(numpy.mean(wRng),y+1.5*yoff,FEATURE_LABELS[ftrc]['label'],horizontalalignment='center',fontsize=fontsize)\n else:\n for w in wRng: ax.plot([w]*2,[y,y+yoff],color='k',linestyle='-')\n ax.text(numpy.mean(wRng),y+1.5*yoff,FEATURE_LABELS[ftrc]['label'],horizontalalignment='center',fontsize=fontsize)\n bound[3] = numpy.nanmax([numpy.nanmax(flxmax)+2.*yoff,bound[3]])\n\n# add grid\n if grid == True: ax.grid() \n\n# axis labels \n fontsize = (numpy.round(numpy.max([13./((layout[0]*layout[1])**0.33),5]))) * fontscale\n legend_fontsize = (13-numpy.min([(layout[0]*layout[1]-1),8])) * legend_fontscale\n ax.set_xlabel(xlabel, fontsize = fontsize)\n ax.set_ylabel(ylabel, fontsize = fontsize)\n ax.tick_params(axis='x', labelsize=fontsize)\n ax.tick_params(axis='y', labelsize=fontsize)\n\n# add title\n if title!='': ax.set_title(title)\n\n# log scale?\n if kwargs.get('xlog',False): ax.set_xscale('log',nonposx='clip')\n if kwargs.get('ylog',False): ax.set_yscale('log',nonposy='clip')\n\n# place legend\n if len(legend) > 0:\n if legend_location == 'outside':\n box = ax.get_position()\n ax.set_position([box.x0, box.y0 + box.height * 0.15, box.width * 0.7, box.height * 0.7])\n ax.legend(loc='center left', bbox_to_anchor=(1, 0.5), prop={'size':legend_fontsize})\n else:\n ax.legend(loc=legend_location, prop={'size':legend_fontsize})\n bound[3] = bound[3]+0.1*(bound[3]-bound[2]) # extend axis for in-plot legends\n\n# overplot telluric absorption\n if telluric == True:\n yoff = 0.02*(bound[3]-bound[2]) # label offset\n for waveRng in telluric_bands:\n wR = waveRng.to(sp[0].wave.unit).value\n rect = patches.Rectangle((wR[0],bound[2]),wR[1]-wR[0],bound[3]-bound[2],facecolor=color_telluric,alpha=alpha_telluric,color=color_telluric)\n ax.add_patch(rect)\n ax.text(numpy.mean(wR),bound[2]+3*yoff,r'$\\oplus$',horizontalalignment='center',fontsize=fontsize)\n\n# overplot color swaths for pre-specified bands\n if len(band) > 0:\n for i,b in enumerate(band):\n if not isinstance(b,list): \n try: b = [float(b)-0.5*band_width,float(b)+0.5*band_width]\n except:\n print('\\nWarning: plotSpectrum bands variables should be array of 2-element arrays; you passed {}'.format(band))\n b = [0.,0.]\n rect = patches.Rectangle((b[0],bound[2]),b[1]-b[0],bound[3]-bound[2],facecolor=band_color[i],color=band_color[i],alpha=band_alpha[i])\n ax.add_patch(rect)\n if band_label_position[i].lower() == 'top':\n ax.text(numpy.mean(b),bound[3]-3*yoff,band_label[i],horizontalalignment='center',fontsize=fontsize)\n elif band_label_position[i].lower() == 'middle':\n ax.text(numpy.mean(b),0.5*(bound[2]+bound[3]),band_label[i],horizontalalignment='center',fontsize=fontsize)\n else:\n ax.text(numpy.mean(b),bound[2]+3*yoff,band_label[i],horizontalalignment='center',fontsize=fontsize)\n\n# place inset - RIGHT NOW ONLY SETTING LIMITS WITH FIRST SPECTRUM IN LIST\n if inset == True and len(inset_xrange) == 2:\n ax_inset = fig[pg_n-1].add_axes(inset_position) #, axisbg='white')\n bound2 = inset_xrange\n if len(inset_yrange) == 0:\n b0 = numpy.argmax(sp[0].wave.value > bound2[0])\n b1 = numpy.argmin(sp[0].wave.value < bound2[1])\n inset_yrange = [numpy.nanmin(sp[0].flux.value[b0:b1]),numpy.nanmax(sp[0].flux.value[b0:b1])]\n bound2.extend(inset_yrange)\n db = (bound2[3]-bound2[2])\n bound2[2] = bound2[2]-0.05*db\n bound2[3] = bound2[3]+0.05*db\n ax_inset.axis(bound2)\n inset_fontsize = fontsize*0.7\n\n for ii,a in enumerate(sp):\n flx = [i+zeropoint[ii] for i in a.flux.value]\n ax_inset.plot(a.wave.value,flx,color=colors[ii],linestyle=linestyle[ii],linewidth=linewidth[ii],alpha=alpha[ii]) \n ax_inset.set_xlabel('')\n ax_inset.set_ylabel('')\n ax_inset.tick_params(axis='x', labelsize=inset_fontsize)\n ax_inset.tick_params(axis='y', labelsize=inset_fontsize)\n# ax_inset.legend()\n\n# inset feature labels\n if len(inset_features) > 0:\n yoff = 0.05*(bound2[3]-bound2[2])\n for ftr in inset_features:\n ftrc = checkDict(ftr,FEATURE_LABELS)\n if ftrc != False:\n for ii,waveRng in enumerate(FEATURE_LABELS[ftrc]['wavelengths']):\n wRng = waveRng.to(sp[0].wave.unit).value\n if (numpy.min(wRng) > bound2[0] and numpy.max(wRng) < bound2[1]):\n wfeature = numpy.where(numpy.logical_and(wvmax >= numpy.nanmin(wRng),wvmax <= numpy.nanmax(wRng)))\n if len(wvmax[wfeature]) == 0: wfeature = numpy.argmax(numpy.absolute(wvmax-numpy.nanmedian(wRng)))\n y = numpy.nanmax(flxmax[wfeature])+yoff\n flxmax[wfeature] = flxmax[wfeature]+3.*yoff\n \n if FEATURE_LABELS[ftrc]['type'] == 'band':\n ax_inset.plot(wR,[y+yoff]*2,color='k',linestyle='-')\n ax_inset.plot([wR[0]]*2,[y,y+yoff],color='k',linestyle='-')\n ax_inset.text(numpy.mean(wR),y+2*yoff,FEATURE_LABELS[ftrc]['label'],horizontalalignment='center',fontsize=inset_fontsize)\n else:\n for w in waveRng:\n ax_inset.plot([w]*2,[y,y+yoff],color='k',linestyle='-')\n ax_inset.text(numpy.mean(wR),y+2*yoff,FEATURE_LABELS[ftrc]['label'],horizontalalignment='center',fontsize=inset_fontsize)\n waveRng = [wR[0]-0.02,wR[1]+0.02] # for overlap\n \n# update offset\n if len(inset_features) > 0: bound2[3] = numpy.nanmax([bound2[3],numpy.nanmax(flxmax)+5.*yoff])\n ax_inset.axis(bound2)\n\n# finalize bounding\n if len(xrng) > 0: bound[0:2] = xrng\n if len(yrng) > 0: bound[2:4] = yrng\n if isUnit(bound[0]): bound = [x.value for x in bound]\n ax.axis(bound)\n \n# save to file or display\n# ERROR HERE - CHECK WHAT FILES\n if multipage == False:\n if files[plts] != '' and (plts % nplot == 3 or plts == len(splist)-1):\n if kwargs.get('tight',True) == True: \n plt.savefig(files[plts], bbox_inches='tight')\n else:\n plt.savefig(files[plts])\n if output == '' and not kwargs.get('web',False):\n plt.show()\n if (kwargs.get('interactive',False) != False): plt.ion()\n else: plt.ioff()\n\n\n# save figures in multipage format and write off pdf file\n if multipage == True: \n for pg_n in numpy.arange(numpages):\n# fig[pg_n].text(0.5, 0.04, xlabel, ha = 'center', va = 'center')\n# fig[pg_n].text(0.06, 0.5, ylabel, ha = 'center', va = 'center', rotation = 'vertical')\n fig[pg_n].tight_layout\n fig[pg_n].suptitle(title, fontsize = int(14*fontsize), fontweight = 'bold')\n pdf_pages.savefig(fig[pg_n])\n if filetype.lower() == 'pdf':\n pdf_pages.close()\n\n plt.clf()\n return fig","def plot(self,include_rho=True,show=True,nx=129):\n xs = np.linspace(0.0,1.0,nx)\n plt.plot(xs,self.f0(xs),'b-')\n plt.plot([self.rho_max,self.rho_max],[0.0,1.0],'b:')\n plt.plot(xs,self.f1(xs),'r-')\n plt.plot([self.rho_min,self.rho_min],[0.0,1.0],'r:')\n plt.plot([0.0,1.0],[0.0,1.0],'k--')\n if include_rho:\n plt.plot([self.rho,self.rho],[0.0,1.0],'g:')\n plt.xlim(0.0,1.0)\n plt.ylim(0.0,1.0)\n plt.axes().set_aspect(1.0)\n if show:\n plt.show()","def plot(self):\n\t\tself.plotOfXray().plot()","def plot(self, **kwargs):\n if self.order != None:\n name = str(_constructModelName(self.teff, self.logg, \n self.metal, self.en, self.order, self.path))\n output = kwargs.get('output', str(name) + '.pdf')\n ylim = kwargs.get('yrange', [min(self.flux)-.2, max(self.flux)+.2])\n title = kwargs.get('title')\n save = kwargs.get('save', False)\n \n plt.figure(figsize=(16,6))\n plt.plot(self.wave, self.flux, color='k', \n alpha=.8, linewidth=1, label=name)\n plt.legend(loc='upper right', fontsize=12)\n plt.ylim(ylim) \n \n minor_locator = AutoMinorLocator(5)\n #ax.xaxis.set_minor_locator(minor_locator)\n # plt.grid(which='minor') \n \n plt.xlabel(r'$\\lambda$ [$\\mathring{A}$]', fontsize=18)\n plt.ylabel(r'$Flux$', fontsize=18)\n #plt.ylabel(r'$F_{\\lambda}$ [$erg/s \\cdot cm^{2}$]', fontsize=18)\n if title != None:\n plt.title(title, fontsize=20)\n plt.tight_layout()\n\n if save == True:\n plt.savefig(output)\n plt.show()\n plt.close()\n\n else:\n output = kwargs.get('output'+ '.pdf')\n ylim = kwargs.get('yrange', [min(self.flux)-.2, max(self.flux)+.2])\n title = kwargs.get('title')\n save = kwargs.get('save', False)\n \n plt.figure(figsize=(16,6))\n plt.plot(self.wave, self.flux, color='k', alpha=.8, linewidth=1)\n plt.legend(loc='upper right', fontsize=12)\n plt.ylim(ylim)\n \n minor_locator = AutoMinorLocator(5)\n #ax.xaxis.set_minor_locator(minor_locator)\n # plt.grid(which='minor') \n \n plt.xlabel(r'$\\lambda$ [$\\mathring{A}$]', fontsize=18)\n plt.ylabel(r'$Flux$', fontsize=18)\n #plt.ylabel(r'$F_{\\lambda}$ [$erg/s \\cdot cm^{2}$]', fontsize=18)\n if title != None:\n plt.title(title, fontsize=20)\n plt.tight_layout()\n\n if save == True:\n plt.savefig(output)\n plt.show()\n plt.close()","def plotSpectrum(self, spectrum=None):\n if spectrum is None:\n spectrum = self.spectrometer.getSpectrum()\n\n if len(self.axes.lines) == 0:\n self.axes.plot(self.spectrometer.wavelength, spectrum, 'k')\n self.axes.set_xlabel(\"Wavelength [nm]\")\n self.axes.set_ylabel(\"Intensity [arb.u]\")\n else:\n self.axes.lines[0].set_data( self.spectrometer.wavelength, spectrum) # set plot data\n self.axes.relim()","def plot(self, *args, **kwargs):\n pass","def graphplot(self):\n if self.binned:\n self.line.set_ydata(self.fft_bins_y)\n else:\n self.line.set_ydata(self.spec_y)\n self.line2.set_ydata(self.wave_y)\n self.ax1.draw_artist(self.ax1.patch)\n self.ax2.draw_artist(self.ax2.patch)\n self.ax1.draw_artist(self.line)\n self.ax2.draw_artist(self.line2)\n self.fig.canvas.update()\n self.fig.canvas.flush_events()","def plot(self,x,y):\r\n scalex,scaley = self.getScale()\r\n x = x*self.samplerate\r\n x = (x-scalex[0])/(scalex[1]-scalex[0])*self.w\r\n y = (y-scaley[0])/(scaley[1]-scaley[0])*self.h\r\n return (x,y)","def plot_data(x, y, Amp, freq, filename):\n plb.plot(x, y, 'b', linestyle = ':')\n y_fit = Amp * np.sin(freq * x)\n plb.plot(x, y_fit, 'r')\n plb.savefig(filename)","def plotXY(xName,xDataRaw,yName, yDataRaw):\n scanFileHolder = getScanFileHolderXY(xName,xDataRaw,yName, yDataRaw) \n scanFileHolder.plot(xName, yName)\n return scanFileHolder","def plot_xy(xy: np.ndarray, *args: Optional, **kwargs: Optional):\n trj = traja.from_xy(xy)\n trj.traja.plot(*args, **kwargs)","def plot_spectrum(spec, ax=None, **kwargs):\n\n if not spec.data.size or not spec.energy.size or np.all(spec.energy == 0):\n raise ValueError('Spectrum must be loaded and calibrated')\n\n ax = plot_xy(spec.energy, spec.data, ax=ax, **kwargs)\n\n return ax","def plot_spectrum(freqs, fluxes, min_lambda=3700, max_lambda=8000):\n plt.plot(freqs, fluxes)\n plt.xlim((min_lambda, max_lambda))\n plt.xlabel(r'$\\lambda\\, (\\AA)$', size=16)\n plt.ylabel(r'$Flux$', size=16)\n #plt.axes().minorticks_on()","def visualisation(self):\n plt.plot(self.x, self.y, 'o', label = 'Example data')\n plt.plot(self.x, np.dot(self.w, self.X), label = 'Model')\n plt.xlim([-1,1])\n plt.ylim([-1,1])","def plot(self, show=True):\n xs, ys = zip(*[(float(ix)/self.sample_rate, val)\n for ix, val in enumerate(self.samples)])\n plt.plot(xs, ys)\n if show:\n plt.show()","def plot(self, **kwargs):\n\n from ..plot import Plot\n\n p = Plot(1, 1, 1, **kwargs)\n\n p.axes[0].plot(self.dispersion.value, self.flux.value,\n drawstyle='steps-mid')\n\n if self.flux.uncertainty is not None:\n p.axes[0].plot(self.dispersion.value, self.flux.uncertainty.value,\n drawstyle='steps-mid')\n\n p.tidy()\n p.display()","def plot():\n pass","def plot(data,fig,figure_number = 1,xlabel='',ylabel='',title=''):\n fig.add_subplot(1,2,figure_number)\n plt.title(title)\n plt.xlabel(xlabel)\n # only plot the y label if ipython is True, else the plot looks to cramped\n if is_ipython:\n plt.ylabel(ylabel)\n plt.plot(np.array(data),'orange')\n plt.ylim((0,1))\n if not is_ipython:\n plt.pause(0.000001) # pause a bit so that plots are updated","def plot_solution(self, identlist, aperture_lst, plot_ax1=False, **kwargs):\n coeff = kwargs.pop('coeff')\n k = kwargs.pop('k')\n offset = kwargs.pop('offset')\n npixel = kwargs.pop('npixel')\n std = kwargs.pop('std')\n nuse = kwargs.pop('nuse')\n ntot = kwargs.pop('ntot')\n xorder = kwargs.pop('xorder')\n yorder = kwargs.pop('yorder')\n clipping = kwargs.pop('clipping')\n maxiter = kwargs.pop('maxiter')\n\n label_size = 13 # fontsize for x, y labels\n tick_size = 12 # fontsize for x, y ticks\n\n #wave_scale = 'linear'\n wave_scale = 'reciprocal'\n\n #colors = 'rgbcmyk'\n\n self._ax2.cla()\n self._ax3.cla()\n\n if plot_ax1:\n self._ax1.cla()\n x = np.linspace(0, npixel-1, 100, dtype=np.float64)\n\n # find the maximum and minimum wavelength\n wl_min, wl_max = 1e9,0\n allwave_lst = {}\n for aperture in aperture_lst:\n order = k*aperture + offset\n wave = get_wavelength(coeff, npixel, x, np.repeat(order, x.size))\n allwave_lst[aperture] = wave\n wl_max = max(wl_max, wave.max())\n wl_min = min(wl_min, wave.min())\n # plot maximum and minimum wavelength, to determine the display\n # range of this axes, and the tick positions\n self._ax1.plot([0, 0],[wl_min, wl_max], color='none')\n yticks = self._ax1.get_yticks()\n self._ax1.cla()\n\n\n for aperture in aperture_lst:\n order = k*aperture + offset\n color = 'C{}'.format(order%10)\n\n # plot pixel vs. wavelength\n if plot_ax1:\n wave = allwave_lst[aperture]\n if wave_scale=='reciprocal':\n self._ax1.plot(x, 1/wave,\n color=color, ls='-', alpha=0.8, lw=0.8)\n else:\n self._ax1.plot(x, wave,\n color=color, ls='-', alpha=0.8, lw=0.8)\n\n # plot identified lines\n if aperture in identlist:\n list1 = identlist[aperture]\n pix_lst = list1['pixel']\n wav_lst = list1['wavelength']\n mask = list1['mask'].astype(bool)\n res_lst = list1['residual']\n\n if plot_ax1:\n if wave_scale=='reciprocal':\n self._ax1.scatter(pix_lst[mask], 1/wav_lst[mask],\n c=color, s=20, lw=0, alpha=0.8)\n self._ax1.scatter(pix_lst[~mask], 1/wav_lst[~mask],\n c='w', s=16, lw=0.7, alpha=0.8,\n edgecolor=color)\n else:\n self._ax1.scatter(pix_lst[mask], wav_lst[mask],\n c=color, s=20, lw=0, alpha=0.8)\n self._ax1.scatter(pix_lst[~mask], wav_lst[~mask],\n c='w', s=16, lw=0.7, alpha=0.8,\n edgecolor=color)\n\n repeat_aper_lst = np.repeat(aperture, pix_lst.size)\n self._ax2.scatter(repeat_aper_lst[mask], res_lst[mask],\n c=color, s=20, lw=0, alpha=0.8)\n self._ax2.scatter(repeat_aper_lst[~mask], res_lst[~mask],\n c='w', s=16, lw=0.7, alpha=0.8, ec=color)\n self._ax3.scatter(pix_lst[mask], res_lst[mask],\n c=color, s=20, lw=0, alpha=0.8)\n self._ax3.scatter(pix_lst[~mask], res_lst[~mask],\n c='w', s=16, lw=0.7, alpha=0.8, ec=color)\n\n # refresh texts in the residual panels\n text = 'R.M.S. = {:.5f}, N = {}/{}'.format(std, nuse, ntot)\n self._ax3._residual_text.set_text(text)\n text = u'Xorder = {}, Yorder = {}, clipping = \\xb1{:g}, Niter = {}'.format(\n xorder, yorder, clipping, maxiter)\n self._ax2._fitpar_text.set_text(text)\n\n # adjust layout for ax1\n if plot_ax1:\n self._ax1.set_xlim(0, npixel-1)\n if wave_scale == 'reciprocal':\n _y11, _y22 = self._ax1.get_ylim()\n newtick_lst, newticklabel_lst = [], []\n for tick in yticks:\n if _y11 < 1/tick < _y22:\n newtick_lst.append(1/tick)\n newticklabel_lst.append(tick)\n self._ax1.set_yticks(newtick_lst)\n self._ax1.set_yticklabels(newticklabel_lst)\n self._ax1.set_ylim(_y22, _y11)\n self._ax1.set_xlabel('Pixel', fontsize=label_size)\n self._ax1.set_ylabel(u'\\u03bb (\\xc5)', fontsize=label_size)\n self._ax1.grid(True, ls=':', color='gray', alpha=1, lw=0.5)\n self._ax1.set_axisbelow(True)\n self._ax1._aperture_text.set_text('')\n for tick in self._ax1.xaxis.get_major_ticks():\n tick.label1.set_fontsize(tick_size)\n for tick in self._ax1.yaxis.get_major_ticks():\n tick.label1.set_fontsize(tick_size)\n\n # adjust axis layout for ax2 (residual on aperture space)\n self._ax2.axhline(y=0, color='k', ls='--', lw=0.5)\n for i in np.arange(-3,3+0.1):\n self._ax2.axhline(y=i*std, color='k', ls=':', lw=0.5)\n x1, x2 = self._ax2.get_xlim()\n x1 = max(x1,aperture_lst.min())\n x2 = min(x2,aperture_lst.max())\n self._ax2.set_xlim(x1, x2)\n self._ax2.set_ylim(-6*std, 6*std)\n self._ax2.set_xlabel('Aperture', fontsize=label_size)\n self._ax2.set_ylabel(u'Residual on \\u03bb (\\xc5)', fontsize=label_size)\n for tick in self._ax2.xaxis.get_major_ticks():\n tick.label1.set_fontsize(tick_size)\n for tick in self._ax2.yaxis.get_major_ticks():\n tick.label1.set_fontsize(tick_size)\n\n ## adjust axis layout for ax3 (residual on pixel space)\n self._ax3.axhline(y=0, color='k', ls='--', lw=0.5)\n for i in np.arange(-3,3+0.1):\n self._ax3.axhline(y=i*std, color='k', ls=':', lw=0.5)\n self._ax3.set_xlim(0, npixel-1)\n self._ax3.set_ylim(-6*std, 6*std)\n self._ax3.set_xlabel('Pixel', fontsize=label_size)\n self._ax3.set_ylabel(u'Residual on \\u03bb (\\xc5)', fontsize=label_size)\n for tick in self._ax3.xaxis.get_major_ticks():\n tick.label1.set_fontsize(tick_size)\n for tick in self._ax3.yaxis.get_major_ticks():\n tick.label1.set_fontsize(tick_size)","def plot(self):\n\t\tself.plotOfLoopVoltage()","def show_waveform(self, peaks=[]):\n if peaks is None:\n peaks = []\n data = self.amplitude\n x_axis = range(0, len(data))\n x_axis = [x / self.fs for x in x_axis]\n plt.plot(x_axis, data)\n plt.axhline(self.height)\n for p in peaks:\n plt.axvline(p / self.fs, color=\"red\", alpha=0.2)\n plt.ylabel(\"Amplitude\")\n plt.xlabel(\"Time (seconds)\")\n plt.title(\"Waveform\")\n plt.show()","def plot_simulation_yz(\n sim: td.Simulation,\n z: float = 0.0,\n y: float = 0.0,\n wavelength: Optional[float] = 1.55,\n figsize: Float2 = (11, 4),\n):\n fig = plt.figure(figsize=figsize)\n if sim.size[2] > 0.1 and sim.size[1] > 0.1:\n gs = mpl.gridspec.GridSpec(1, 2, figure=fig, width_ratios=[1, 1.4])\n ax1 = fig.add_subplot(gs[0, 0])\n ax2 = fig.add_subplot(gs[0, 1])\n if wavelength:\n freq = td.constants.C_0 / wavelength\n sim.plot_eps(z=z, ax=ax1, freq=freq)\n sim.plot_eps(y=y, ax=ax2, freq=freq)\n else:\n sim.plot(z=z, ax=ax1)\n sim.plot(y=y, ax=ax2)\n elif sim.size[2] > 0.1: # 2D grating sim_size_y = 0\n gs = mpl.gridspec.GridSpec(1, 1, figure=fig, width_ratios=[1])\n ax1 = fig.add_subplot(gs[0, 0])\n if wavelength:\n freq = td.constants.C_0 / wavelength\n sim.plot_eps(y=y, ax=ax1, freq=freq)\n else:\n sim.plot(y=y, ax=ax1)\n\n else: # 2D planar component size_z = 0\n gs = mpl.gridspec.GridSpec(1, 1, figure=fig, width_ratios=[1])\n ax1 = fig.add_subplot(gs[0, 0])\n if wavelength:\n freq = td.constants.C_0 / wavelength\n sim.plot_eps(z=z, ax=ax1, freq=freq)\n else:\n sim.plot(z=z, ax=ax1)\n\n plt.show()\n return fig","def draw_plot(self):\n # X axis is auto follow.\n XLEN = 100\n xmax = max(len(self.daq.data0), XLEN)\n xmin = xmax - XLEN\n\n # The Y value will lie between 0.0 and 5.0 volts\n ymax = 5.0\n ymin = 0.0\n\n self.main_plot.set_xbound(lower=xmin, upper=xmax)\n self.main_plot.set_ybound(lower=ymin, upper=ymax)\n\n # Add the grid. Grid looks cool and is actually very helpful.\n self.main_plot.grid(True, color='gray')\n\n pylab.setp(self.main_plot.get_xticklabels(), \n visible=True)\n \n self.plot_data.set_xdata(arange(len(self.daq.data0)))\n self.plot_data.set_ydata(array(self.daq.data0))\n \n self.canvas.draw()","def plot_xy(nc,params,tms,lev=None):\n \n import matplotlib.pyplot as plt\n import ggWRFutils as gW\n from datetime import datetime\n import numpy as np\n wvar={}\n for p in params:\n if p != 'Times':\n if p=='WS10':\n wvar[p]=np.sqrt(nc.variables['U10'][:]**2+nc.variables['U10'][:]**2)\n elif p=='UV10': \n wvar['U10']=nc.variables['U10'][:,:,:] \n wvar['V10']=nc.variables['V10'][:,:,:] \n elif p=='UV':\n wvar['U']=nc.variables['U'][:,lev,:,:] \n wvar['V']=nc.variables['V'][:,lev,:,:] \n elif len(nc.variables[p].shape) > 3:\n wvar[p]=nc.variables[p][:,lev,:,:] \n else: \n wvar[p]=nc.variables[p][:] \n Nx,Ny,Nz,lon,lat,dx,dy=gW.getDimensions(nc)\n for p in params:\n if params[p]=='pcolor':\n plt.pcolor(lon,lat,wvar[p][tms,:,:],shading='flat')\n plt.colorbar()\n if params[p]=='contourf':\n plt.contourf(lon,lat,wvar[p][tms,:,:],50)\n plt.colorbar()\n if params[p]=='contour':\n plt.contourf(lon,lat,wvar[p][tms,:,:])\n plt.colorbar()\n if params[p]=='quiver':\n if p=='UV10':\n plt.quiver(lon[::10,::10],lat[::10,::10],wvar['U10'][tms,::10,::10],wvar['V10'][tms,::10,::10],units='width')\n elif p=='UV':\n plt.quiver(lon,lat,wvar['U'][tms,:,:],wvar['V'][tms,:,:])\n plt.hold(True)\n plt.xlim(lon.min(),lon.max())\n plt.ylim(lat.min(),lat.max())\n fig=plt.gcf()\n return fig","def plot(self, *, ax=..., n_cols=..., line_kw=..., contour_kw=...):\n ...","def plots(x_bef,y_bef,z_bef):\r\n # Makes a 3-D plot of the x, y and z axes representing the ball's total trajectory\r\n plt.figure(3)\r\n plot3 = plt.axes(projection=\"3d\")\r\n plot3.plot3D(x_bef,y_bef,z_bef,'blue')\r\n plot3.set_xlabel('x (ft)')\r\n plot3.set_ylabel('y (ft)')\r\n plot3.set_zlabel('z (ft)')\r\n plot3.set_title('Total Trajectory')\r\n \r\n # Makes a 2-D plot of the x, and z axes representing the ball's total 2-D trajectory\r\n plt.figure(4)\r\n plt.plot(x_bef,z_bef)\r\n plt.xlabel('x (ft)')\r\n plt.ylabel('z (ft)')\r\n plt.title('z (ft) vs x (ft)')\r\n plt.show()","def plot(self):\n\t\tself.plotOfSpect().plot()","def plot(self, num_levels=5):\n Schrodinger1D.plot(self, num_levels)\n xlabel('Electron height, z (nm)')\n ylabel('Energy (GHz)')\n mine = amin(self.energies(num_levels))\n maxe = amax(self.energies(num_levels))\n ylim(mine - (maxe - mine) * .5, maxe + (maxe - mine) * .5)","def plot(self, fig=None, ax=None):\n\n self._plot_setup(fig, ax)\n\n if self.stokes == 'v':\n self.cmap = plt.cm.coolwarm\n\n absmax = max(self.data.max(), self.data.min(), key=abs)\n rms = np.sqrt(np.mean(np.square(self.data)))\n\n logger.debug(f\"Max flux in cutout: {absmax:.2f} mJy.\")\n logger.debug(f\"RMS flux in cutout: {rms:.2f} mJy.\")\n\n self.im = self.ax.imshow(self.data, cmap=self.cmap, norm=self.norm)\n\n if self.options.get('bar', True):\n try:\n self.fig.colorbar(self.im, label=r'Flux Density (mJy beam$^{-1}$)', ax=self.ax)\n except UnboundLocalError:\n logger.error(\"Colorbar failed. Upgrade to recent version of astropy \")\n\n if self.options.get('psf'):\n self.add_psf()\n\n self.add_source_ellipse()","def plot(x, y, z):\n pylab.plot(x, y)\n pylab.plot(x, z)\n pylab.show()","def _xy_plot(cube, x_coord=None, reg_line=False, **plot_kwargs):\n plot_kwargs = deepcopy(plot_kwargs)\n if reg_line:\n if plot_kwargs.get('linestyle', '-') == '-':\n plot_kwargs.setdefault('marker', 'o')\n else:\n plot_kwargs.setdefault('marker', 's')\n plot_kwargs['linestyle'] = 'none'\n plot_kwargs.setdefault('markersize', 3)\n if x_coord is None:\n iris.plot.plot(cube, **plot_kwargs)\n if cube.coords(dim_coords=True):\n coord = cube.coord(dim_coords=True)\n x_data = coord.points\n else:\n coord = None\n x_data = np.arange(cube.shape[0])\n else:\n coord = cube.coord(x_coord)\n iris.plot.plot(coord, cube, **plot_kwargs)\n x_data = coord.points\n if not reg_line:\n return\n plot_kwargs['linestyle'] = '-'\n plot_kwargs['marker'] = None\n plot_kwargs.pop('label', None)\n y_data = cube.data\n reg = linregress(x_data, y_data)\n y_reg = reg.slope * x_data + reg.intercept\n plt.plot(x_data, y_reg, **plot_kwargs)","def __plot(name, x, y):\n import matplotlib.pyplot as plt\n\n plt.plot(x, y)\n plt.xlabel('elements')\n plt.ylabel('time (seconds)')\n plt.savefig(\"{}\".format(name))","def plot(self):\n\t\tself.plotOfSpect()","def plot(self, x_unit='ft', y_unit='psi'):\n\n #Find the grid centers (where the solution exists)\n x_pos = np.cumsum(self.dx_arr) - self.dx_arr[0] / 2.0\n\n #Loop over all stored solutions and plot stair-step line (because\n #pressure is constant over grid block). We skip the first stored values\n #because they are just the initialization values.\n plt.figure()\n for P in self.P_plot:\n plt.plot(x_pos, P)\n\n #Labels, etc.\n plt.xlabel('Reservoir position (' + x_unit + ')')\n plt.ylabel('Pressure (' + y_unit + ')')\n plt.xlim([0, self.res_length])\n plt.show()","def plot_xy(self, subplot = None, center_of_gravity = False, marker = \"b-\"):\n if subplot is None:\n plot = plt.subplot(111)\n\n for mass in self.flatten():\n x,y = mass.geometry.project_xy.plot_coordinates\n subplot.plot(x, y, marker)\n\n if center_of_gravity:\n x, y, _ = mass.center_of_gravity_global.as_tuple()\n subplot.plot(x, y,\"*\")\n\n x, y, _ = self.center_of_gravity_global.as_tuple()\n subplot.plot(x, y, \"o\")\n\n return subplot","def plotSpectrum(self,wavelengths,intensities = 1.0):\n\n fieldAngle,spectralOutput = self.getIntensitySpectum(wavelengths,intensities)\n\n # Do the actual plot\n plot(np.degrees(fieldAngle),spectralOutput)\n grid()\n title(\"Spectral plot\")\n xlabel(\"Angle in degrees\")\n ylabel(\"Intensty\")","def show():\n\tplt.show()","def show_plot(segment_times, sample_freqs, spec, wave, wav_data, vad_feat):\n plt.subplot(3, 1, 1)\n plt.pcolormesh(segment_times, sample_freqs, 10*np.log10(spec), cmap='jet')\n plt.ylabel('Frequency [Hz]')\n plt.xlabel('Time [sec]')\n\n plt.subplot(3,1,2)\n axes = plt.gca()\n axes.set_xlim([0, wave.duration])\n tmp_axis = np.linspace(0, wave.duration, wav_data.shape[0])\n plt.plot(tmp_axis, wav_data/np.abs(np.max(wav_data)))\n plt.xlabel('Time [sec]')\n\n plt.subplot(3,1,3)\n axes = plt.gca()\n axes.set_xlim([0, wave.duration])\n tmp_axis = np.linspace(0, wave.duration, vad_feat.shape[0])\n plt.plot(tmp_axis, vad_feat)\n plt.xlabel('Time [sec]')\n\n plt.savefig('test', bbox_inches='tight')","def make_plot(x,y):","def generate_plot(self):\r\n\t\tx, y = zip(*[p.p for p in self.universe])\r\n\t\tself.ax.cla()\r\n\t\tself.ax.plot(x, y, '.')\r\n\t\tself.ax.set_title('Universe at time: %d' % self.universe.time)\r\n\t\tself.ax.set_xlim([P_MU-4*P_STD, P_MU+4*P_STD])\r\n\t\tself.ax.set_ylim([P_MU-4*P_STD, P_MU+4*P_STD])","def show_graphs ():\n plt.ylim = (0, 300)\n plt.xlim = (0, 300)\n #Set up lidar plot to figure 1\n lidar_plot = plt.figure (1)\n #Assign title\n plt.title ('Lidar data')\n #Assign data\n plt.imshow (lidar_clean)\n #Set up radar plot to figure 2\n radar_plot = plt.figure (2)\n #Assign title\n plt.title ('Radar data')\n #Assign data\n plt.imshow (radar_clean)\n #Show plots\n plt.show ()","def plot_x(t, x):\n plt.figure()\n plt.plot(t, x)\n plt.title(\"Vertical position of the skydiver as a function of time\")\n plt.xlabel(\"Time t [s]\")\n plt.ylabel(\"Height [m]\")\n plt.savefig('Parachute_position.png')","def plot(self, *args, **kwargs):\n raise NotImplementedError","def show_plot(self):\r\n\t\tself.generate_plot()\r\n\t\tplt.show()","def show():\n setup()\n plt.show()","def view(self, lo_en: Quantity = Quantity(0.0, \"keV\"), hi_en: Quantity = Quantity(30.0, \"keV\"),\n figsize: Tuple = (8, 6)):\n if lo_en > hi_en:\n raise ValueError(\"hi_en cannot be greater than lo_en\")\n else:\n lo_en = lo_en.to(\"keV\").value\n hi_en = hi_en.to(\"keV\").value\n\n if len(self._plot_data.keys()) != 0:\n # Create figure object\n plt.figure(figsize=figsize)\n\n # Set the plot up to look nice and professional.\n ax = plt.gca()\n ax.minorticks_on()\n ax.tick_params(axis='both', direction='in', which='both', top=True, right=True)\n\n # Set the title with all relevant information about the spectrum object in it\n plt.title(\"{n} - {o}{i} Spectrum\".format(n=self.src_name, o=self.obs_id, i=self.instrument.upper()))\n for mod_ind, mod in enumerate(self._plot_data):\n x = self._plot_data[mod][\"x\"]\n # If the defaults are left, just update them to the min and max of the dataset\n # to avoid unsightly gaps at the sides of the plot\n if lo_en == 0.:\n lo_en = x.min()\n if hi_en == 30.0:\n hi_en = x.max()\n\n # Cut the x dataset to just the energy range we want\n plot_x = x[(x > lo_en) & (x < hi_en)]\n\n if mod_ind == 0:\n # Read out the data just for line length reasons\n # Make the cuts based on energy values supplied to the view method\n plot_y = self._plot_data[mod][\"y\"][(x > lo_en) & (x < hi_en)]\n plot_xerr = self._plot_data[mod][\"x_err\"][(x > lo_en) & (x < hi_en)]\n plot_yerr = self._plot_data[mod][\"y_err\"][(x > lo_en) & (x < hi_en)]\n plot_mod = self._plot_data[mod][\"model\"][(x > lo_en) & (x < hi_en)]\n\n plt.errorbar(plot_x, plot_y, xerr=plot_xerr, yerr=plot_yerr, fmt=\"k+\", label=\"data\", zorder=1)\n else:\n # Don't want to re-plot data points as they should be identical, so if there is another model\n # only it will be plotted\n plot_mod = self._plot_data[mod][\"model\"][(x > lo_en) & (x < hi_en)]\n\n # The model line is put on\n plt.plot(plot_x, plot_mod, label=mod, linewidth=1.5)\n\n # Generate the legend for the data and model(s)\n plt.legend(loc=\"best\")\n\n # Ensure axis is limited to the chosen energy range\n plt.xlim(lo_en, hi_en)\n\n plt.xlabel(\"Energy [keV]\")\n plt.ylabel(\"Normalised Counts s$^{-1}$ keV$^{-1}$\")\n\n ax.set_xscale(\"log\")\n ax.xaxis.set_major_formatter(ScalarFormatter())\n ax.xaxis.set_minor_formatter(FuncFormatter(lambda inp, _: '{:g}'.format(inp)))\n ax.xaxis.set_major_formatter(FuncFormatter(lambda inp, _: '{:g}'.format(inp)))\n\n plt.tight_layout()\n # Display the spectrum\n plt.show()\n\n # Wipe the figure\n plt.close(\"all\")\n\n else:\n warnings.warn(\"There are no XSPEC fits associated with this Spectrum, you can't view it.\")","def plot(self, param):\n # process param to be lowercase and without spaces\n param = str(param).lower().replace(\" \", \"\")\n plt.ion() # enable interactive mode\n\n # making plot according to param\n if param == \"illuminantenergy\": # energy of illuminant\n self.illuminant.plot(\"energy\")\n elif param == \"illuminantphotons\": # photons of illuminant\n self.illuminant.plot(\"photons\")\n elif param == \"srgb\": # srgb image of the scene\n plt.imshow(self.srgb)\n plt.show()\n else:\n raise(ValueError, \"Unknown parameter\")","def plot(self, num_levels=10,**kwargs):\n Schrodinger1D.plot(self, num_levels,**kwargs)\n xlabel('$\\delta/2\\pi$')\n ylabel('E/h (GHz)')\n ylim(min(self.fluxonium_potential()),min(2*self.energies(num_levels)[-1],max(self.fluxonium_potential())))\n title('(Ej=%.2f , El=%.2f , Ec=%.2f)GHz , ($\\Phi_J=%.2f $,$\\Phi_L=%.2f \\,) \\Phi_0$ ' % (self.Ej, self.El, self.Ec, self.phi,self.phiL))","def plot(self, xminorticks = 250, yminorticks = 0.1,\n show_lims = False, small = False, cumulative = False, return_figure=False,\n *args, **kwargs):\n\n ## Check if there is something in the class to plot\n if hasattr(self, \"wavelength\") and hasattr(self, \"throughput\"):\n\n utils.setup_plot_defaults()\n if hasattr(self._wavelength_units, \"format\"):\n if \"latex\" in self._wavelength_units.format:\n xaxis_label_string = r'$\\textnormal{Wavelength, ' + self._wavelength_units.name + ' (}' + self._wavelength_units._format['latex'] +')$'\n else:\n xaxis_label_string = r'$\\textnormal{Wavelength, ' + self._wavelength_units.name + '}$'\n\n plot_label_string = r'$\\textnormal{' + self.filter_name.replace('_', '\\\\_') + '}$'\n\n yminorLocator = MultipleLocator(yminorticks)\n xminorLocator = MultipleLocator(xminorticks)\n\n if not small:\n fig = plt.figure(figsize=[8, 4])\n else:\n fig = plt.figure(figsize=[4, 2])\n plt.rcParams['font.size'] = 10\n\n fig.subplots_adjust(left = 0.09, bottom = 0.13, top = 0.99,\n right = 0.99, hspace=0, wspace = 0)\n\n ax1 = fig.add_subplot(111)\n\n if cumulative:\n throughput = np.cumsum(self.throughput)/np.sum(self.throughput)\n yaxis_label_string = r'$\\textnormal{Cumulative Throughput}$'\n\n else:\n throughput = self.throughput\n yaxis_label_string = r'$\\textnormal{Fractional Throughput}$'\n\n\n if hasattr(self, \"_plot_colour\"):\n ax1.plot(self.wavelength, throughput, color = self._plot_colour,\n lw = 2, label = plot_label_string)\n else:\n ax1.plot(self.wavelength, throughput, lw = 2, label = plot_label_string)\n\n if show_lims:\n try:\n ax1.plot([self._upper_edge, self._upper_edge], [0,1] ,\n lw = 1.5, alpha = 0.5, ls = ':',\n color = colours.hex['batman'], zorder = 0, )\n ax1.plot([self._lower_edge, self._lower_edge], [0,1] ,\n lw = 1.5, alpha = 0.5, ls = ':',\n color = colours.hex['batman'], zorder = 0, )\n except:\n print(\"Failed\")\n\n ax1.spines['top'].set_visible(True)\n\n ax1.set_xlabel(xaxis_label_string)\n ax1.set_ylabel(yaxis_label_string)\n\n ax1.yaxis.set_minor_locator(yminorLocator)\n ax1.xaxis.set_minor_locator(xminorLocator)\n\n ax1.legend(loc = 0)\n\n if return_figure:\n return fig\n\n plt.show()\n pass\n else:\n warnings.warn(\"Doesn't look like you have loaded a filter into the object\")","def plot(self, inline=True, fname=None, show_colorbar=False):\n color_norm = matplotlib.colors.Normalize(\n vmin=self.decibel_limits[0], vmax=self.decibel_limits[1]\n )\n\n plt.imshow(self.spectrogram[::-1], cmap=\"Greys\", norm=color_norm)\n\n # pick values to show on time and frequency axes\n yvals = self.frequencies.round(-2).astype(int)\n xvals = self.times.round(2)\n y_idx = [int(ti) for ti in np.linspace(0, len(yvals), 8)]\n y_idx[-1] -= 1\n plt.yticks(len(yvals) - np.array(y_idx), yvals[y_idx])\n x_idx = [int(ti) for ti in np.linspace(0, len(xvals), 6)]\n x_idx[-1] -= 1\n plt.xticks(x_idx, xvals[x_idx])\n\n # add axes labels\n plt.ylabel(\"frequency (Hz): mel scale\")\n plt.xlabel(\"time (sec)\")\n\n if show_colorbar:\n plt.colorbar()\n\n # if fname is not None, save to file path fname\n if fname:\n plt.savefig(fname)\n\n # if not saving to file, check if a matplotlib backend is available\n if inline:\n if os.environ.get(\"MPLBACKEND\") is None:\n warnings.warn(\"MPLBACKEND is 'None' in os.environ. Skipping plot.\")\n else:\n plt.show()","def plotPowerSpectrum(self,l_edges,show_angle=True,angle_unit=u.arcmin,fig=None,ax=None,**kwargs):\n\n\t\tif not matplotlib:\n\t\t\traise ImportError(\"matplotlib is not installed, cannot plot the power spectrum!\")\n\n\t\t#Instantiate figure\n\t\tif (fig is None) or (ax is None):\n\t\t\t\n\t\t\tself.fig,self.ax = plt.subplots()\n\n\t\telse:\n\n\t\t\tself.fig = fig\n\t\t\tself.ax = ax\n\n\t\t#Calculate the power spectrum\n\t\tl,Pl = self.powerSpectrum(l_edges)\n\n\t\t#Plot\n\t\tself.ax.plot(l,l*(l+1.)*Pl/(2*np.pi),**kwargs)\n\t\tself.ax.set_xscale(\"log\")\n\t\tself.ax.set_yscale(\"log\")\n\n\t\t#Upper scale shows the angle\n\t\tif show_angle:\n\t\t\tax_top = self.ax.twiny()\n\t\t\tax_top.set_xticks(self.ax.get_xticks())\n\t\t\tax_top.set_xlim(self.ax.get_xlim())\n\t\t\tax_top.set_xticklabels([\"{0:.2f}\".format(((2*np.pi/ell)*u.rad).to(angle_unit).value) for ell in self.ax.get_xticks()])\n\t\t\tax_top.set_xlabel(r\"$\\theta$({0})\".format(angle_unit.to_string()),fontsize=22)\n\n\t\t#Labels\n\t\tself.ax.set_xlabel(r\"$\\ell$\",fontsize=22)\n\t\tself.ax.set_ylabel(r\"$\\ell(\\ell+1)P_\\ell^{\\kappa\\kappa}/2\\pi$\",fontsize=22)","def plot(self, num_levels=10,**kwargs):\n Schrodinger1D.plot(self, num_levels,**kwargs)\n xlabel('$\\delta/2\\pi$')\n ylabel('E/h (GHz)')\n ylim(min(self.flux_qubit_potential()),min(2*self.energies(num_levels)[-1],max(self.flux_qubit_potential())))\n title('Ej=%.2f GHz, El=%.2f GHz, Ec=%.2f GHz, $\\Phi=%.2f \\, \\Phi_0$' % (self.Ej, self.El, self.Ec, self.phi))","def plot_flux( source, ctr_freq, bandwidth, nchan, format1 = False, show = False, **kwargs ):\n\n freqs = psr_u.chan_to_freq( ctr_freq, bandwidth, nchan )\n fluxes = []\n for f in freqs:\n flux = getFlux( f, source, format1 )\n fluxes.append( flux )\n\n if show:\n # Set up figure and axes\n fig = plt.figure()\n ax = fig.add_subplot( 111, facecolor = 'w' )\n\n xText = ax.set_xlabel( r\"Frequency (GHz)\" )\n yText = ax.set_ylabel( r\"Flux (Jy)\" )\n title = ax.set_title( r\"The change in flux (Jy) as a function of frequency (GHz)\" )\n ax.plot( freqs, fluxes, **kwargs )\n plt.show()\n return ax\n else:\n return fluxes","def plot_spectrum(self, sp1d, title=None, color='k'):\n if title is not None:\n self.set_title(title)\n self.set_axis_label(''.join(['Wavelength [', sp1d.wunit.name, ']']),\n 'x')\n self.set_axis_label('Counts', 'y')\n self.axplot.plot(sp1d.wlen, sp1d.counts, color)\n self.axplot.axis('tight')\n self.fig.canvas.draw()\n return","def plot(self, num_levels=10):\n if num_levels == -1:\n num_levels = len(self.energies())\n print(self.energies(num_levels))\n figure(figsize=(20, 5))\n subplot(1, num_levels + 1, 1)\n self.plot_potential()\n #xlabel('$\\phi$')\n for ii, psi2D in enumerate(self.get_2Dpsis(num_levels)):\n subplot(1, num_levels + 1, ii + 2)\n #imshow(psi2D.real,extent=(self.x[0],self.x[-1],self.y[0],self.y[-1]),interpolation=\"None\",aspect='auto')\n imshow(psi2D.real, interpolation=\"None\", aspect='auto')\n xlabel(ii)","def plot(self, ax, x_coord):\n self._plot_band(ax, x_coord)\n self._plot_label(ax, x_coord)","def _plot_robot(self):\n try:\n x = 200\n y = 200\n self.ax1.plot(x, y, marker='o', markersize=10, linestyle='None')\n except Exception as err:\n rospy.loginfo(err)","def set_up(self):\n self.h, = self.ax.plot(self.x, lw=2)\n self.ax.set_ylim(0,100)\n self.ax.set_xlim(0,100)\n self.ax.title.set_text(self.config[\"title\"])\n self.ax.set_xlabel(self.config[\"x_label\"])\n self.ax.set_ylabel(self.config[\"y_label\"])","def view(filename):\n n, data, data_dB,sr,ch=inputwav(filename)\n t=np.linspace(0,n/sr,n)\n py.close()\n fig, (ax1) = py.subplots(nrows=1) \n ax1.plot(t[0:n:100],data[0:n:100],'k-',linewidth=1,label=filename)\n ax1.legend(loc=1)\n ax1.set_ylabel('Amplitude (Rel. Bit)')\n ax1.set_xlabel('Time (s)')","def plot(self):\n self.plotsite()\n self.plotbond()\n plt.show()","def our_plot(ax, event, plot_args, scale=1, limits=None):\n _x = plot_args['x']\n _y = plot_args['y']\n ax.cla()\n ax.plot(_x, _y, zorder=0, color='k', alpha=0.5)\n ax.plot(_x + 200, _y, zorder=0, color='r', alpha=0.5)\n if hasattr(event, 'xdata') and event is not None:\n xmin, xmax, ymin, ymax = limits\n deltax, deltay = xmax - xmin, ymax - ymin\n\n if event.xdata is not None and event.ydata is not None:\n print(event.xdata, event.ydata, xmin, xmax, ymin, ymax, scale)\n ax.set(xlim=[event.xdata - scale * deltax,\n event.xdata + scale * deltax],\n ylim=[event.ydata - scale * deltay,\n event.ydata + scale * deltay])\n ax.set_xticklabels([])\n ax.set_yticklabels([])\n ax.plot([event.xdata], [event.ydata], marker='+', color='k',\n ms=20, alpha=0.25)\n else:\n ax.set(title='Press \"r\" to reset, \"z\" to undo last point')\n\n # plot coords\n for it in range(len(newcoords)):\n ax.scatter(*newcoords[it],\n marker=r\"$ {} $\".format(it),\n color='red', zorder=10)\n for it in range(len(oldcoords)):\n ax.scatter(*oldcoords[it],\n marker=r\"$ {} $\".format(it),\n color='black', zorder=10)","def plot(\n self,\n color_map={\n \"ex\": (1, 0.2, 0.2),\n \"ey\": (1, 0.5, 0),\n \"hx\": (0, 0.5, 1),\n \"hy\": (0.5, 0.2, 1),\n \"hz\": (0.2, 1, 1),\n },\n channel_order=None,\n ):\n\n if channel_order is not None:\n ch_list = channel_order()\n else:\n ch_list = self.channels\n\n n_channels = len(self.channels)\n\n fig = plt.figure()\n fig.subplots_adjust(hspace=0)\n ax_list = []\n for ii, comp in enumerate(ch_list, 1):\n try:\n color = color_map[comp]\n except KeyError:\n color = (0, 0.4, 0.8)\n if ii == 1:\n ax = plt.subplot(n_channels, 1, ii)\n else:\n ax = plt.subplot(n_channels, 1, ii, sharex=ax_list[0])\n self.dataset[comp].plot.line(ax=ax, color=color)\n ax.grid(which=\"major\", color=(0.65, 0.65, 0.65), ls=\"--\", lw=0.75)\n ax.grid(which=\"minor\", color=(0.85, 0.85, 0.85), ls=\"--\", lw=0.5)\n ax.set_axisbelow(True)\n if ii != len(ch_list):\n plt.setp(ax.get_xticklabels(), visible=False)\n\n ax_list.append(ax)","def plot_skyline_5578(fig_size,\n flux_5578,\n flux_5578_medfilt, show_plot=False):\n fig, ax = plt.subplots(figsize=(fig_size, fig_size / 2.5))\n ax.plot(flux_5578, alpha=0.5)\n ax.plot(flux_5578_medfilt, alpha=1.0)\n ax.set_ylabel(r\"Integrated flux of skyline 5578 $\\AA$\")\n ax.set_xlabel(\"Fibre\")\n p01 = np.nanpercentile(flux_5578, 1)\n p99 = np.nanpercentile(flux_5578, 99)\n ax.set_ylim(p01, p99)\n ax.set_title(r\"Checking throughput correction using skyline 5578 $\\AA$\")\n ax.tick_params(axis='both', which='minor')\n if show_plot:\n plt.show()\n\n return fig","def plot_sine_evaluation(real_samples, fake_samples, idx, identifier):\n ### frequency\n seq_length = len(real_samples[0]) # assumes samples are all the same length\n frate = seq_length\n freqs_hz = np.fft.rfftfreq(seq_length)*frate # this is for labelling the plot\n # TODO, just taking axis 0 for now...\n w_real = np.mean(np.abs(np.fft.rfft(real_samples[:, :, 0])), axis=0)\n w_fake = np.mean(np.abs(np.fft.rfft(fake_samples[:, :, 0])), axis=0)\n ### amplitude\n A_real = np.max(np.abs(real_samples[:, :, 0]), axis=1)\n A_fake = np.max(np.abs(fake_samples[:, :, 0]), axis=1)\n ### now plot\n nrow = 2\n ncol = 2\n fig, axarr = plt.subplots(nrow, ncol, sharex='col', figsize=(6, 6))\n # freq\n axarr[0, 0].vlines(freqs_hz, ymin=np.minimum(np.zeros_like(w_real), w_real), ymax=np.maximum(np.zeros_like(w_real), w_real), color='#30ba50')\n axarr[0, 0].set_title(\"frequency\", fontsize=16)\n axarr[0, 0].set_ylabel(\"real\", fontsize=16)\n axarr[1, 0].vlines(freqs_hz, ymin=np.minimum(np.zeros_like(w_fake), w_fake), ymax=np.maximum(np.zeros_like(w_fake), w_fake), color='#ba4730')\n axarr[1, 0].set_ylabel(\"generated\", fontsize=16)\n # amplitude\n axarr[0, 1].hist(A_real, normed=True, color='#30ba50', bins=30)\n axarr[0, 1].set_title(\"amplitude\", fontsize=16)\n axarr[1, 1].hist(A_fake, normed=True, color='#ba4730', bins=30)\n\n fig.savefig('./experiments/plots/' + identifier + '_eval' + str(idx).zfill(4) +'.png')\n plt.clf()\n plt.close()\n return True","def plot_waveforms(data, name, title, directory_name):\n plt.figure(figsize=(20, 10))\n plt.plot(data)\n plt.title(title)\n plt.savefig('./' + directory_name + '/' + name)\n pass","def mplot(m, xlabel='', ylabel='', title='', custom=(7,7)):\n lag = ps.lag_spatial(m.w, m.z)\n fit = ps.spreg.OLS(m.z[:, None], lag[:,None])\n\n # Customize plot\n fig = plt.figure(figsize=custom)\n ax = fig.add_subplot(111)\n\n ax.set_xlabel(xlabel)\n ax.set_ylabel(ylabel)\n fig.suptitle(title)\n\n ax.scatter(m.z, lag, s=60, color='k', alpha=.6)\n ax.plot(lag, fit.predy, color='r')\n\n ax.axvline(0, alpha=0.5)\n ax.axhline(0, alpha=0.5)\n\n return fig","def plot(self, *args, ax=None,\n cmap_name='seismic', if_show=False, **kwargs):\n import matplotlib.pylab as plt\n\n if ax is None:\n ax = plt.gca()\n plt.sca(ax)\n\n plt.imshow(\n self, *args, cmap=plt.get_cmap(cmap_name),\n extent=self.extent, **kwargs\n )\n\n if if_show:\n plt.colorbar(orientation='horizontal')\n plt.show()","def data2energy_plot(params, datadir, ylimmax='auto', plotBIND=False):\n # get dirs\n xypath = sorted(glob.glob(datadir + 'xyv/'))[0]\n KLpath = sorted(glob.glob(datadir + 'KL/'))[0]\n print 'found KL dir : ', KLpath\n # list files\n xyfiles = sorted(glob.glob(xypath + '*.txt'))\n KLfiles = sorted(glob.glob(KLpath + '*.txt'))\n # load setup\n xy0file = sorted(glob.glob(datadir + 'xy.txt'))[0]\n xyv0file = sorted(glob.glob(datadir + 'xyv0.txt'))[0]\n\n # Note the inversion of the naming system below!\n # xy file is mesh, here stored as the variable xy0\n xy0 = np.loadtxt(xy0file, delimiter=',', usecols=(0, 1))\n\n # xyv0 file is initial condition, store as xy and v, etc\n xy = np.loadtxt(xyv0file, delimiter=',', usecols=(0, 1))\n try:\n '''Data is 5D (x,y,theta,phi,psi)'''\n theta, phi, vx, vy, vtheta, vphi, vpsi = \\\n np.loadtxt(xyv0file, delimiter=',', usecols=(2, 3, 5, 6, 7, 8, 9), unpack=True)\n dimension = 5\n except:\n try:\n '''Data is 3D'''\n v0 = np.loadtxt(xyv0file, delimiter=',', usecols=(3, 4))\n dimension = 3\n except:\n '''Data is 2D'''\n v0 = np.loadtxt(xyv0file, delimiter=',', usecols=(2, 3))\n dimension = 2\n\n NLfile = sorted(glob.glob(datadir + 'NL.txt'))[0]\n NL = np.loadtxt(NLfile, dtype='int', delimiter=',')\n # hfile = sorted(glob.glob(datadir+'h.txt'))[0]\n # h = np.loadtxt(hfile)\n h = params['h']\n\n # Load masses, from file, or else from params, or else define it as unity\n if os.path.exists(datadir + 'Mm.txt'):\n Mfile = sorted(glob.glob(datadir + 'Mm.txt'))[0]\n Mm = np.loadtxt(Mfile)\n print 'Loaded mass list from txt file...'\n else:\n try:\n Mm = params['Mm']\n print 'Loaded mass list from params dict...'\n except:\n Mm = np.ones_like(xy0[:, 0])\n print 'le: WARNING: Could not find mass array, defined as unity...'\n\n # Calculate or load initial setup --> assumes KL at h=0 is same as initial\n KL = np.loadtxt(KLfiles[0], delimiter=',')\n BL = NL2BL(NL, KL)\n bo = bond_length_list(xy0, BL)\n\n kL = KL2kL(NL, KL, BL) * params['k']\n nzcount = np.count_nonzero(KL)\n NP = len(xy0[:, 0])\n print('NP = ' + str(NP))\n\n fig = plt.figure(1)\n plt.clf()\n if dimension < 5:\n ax = plt.subplot(2, 1, 1)\n ax2 = plt.subplot(2, 1, 2)\n else:\n ax = plt.subplot(4, 1, 1)\n ax2 = plt.subplot(4, 1, 2)\n ax3 = plt.subplot(4, 1, 3)\n ax4 = plt.subplot(4, 1, 4)\n\n # Calc and plot initial vals\n bU = potential_energy(xy, BL, bo, kL)\n if dimension < 5:\n KE = kinetic_energy(v0, Mm)\n totE = bU + KE\n else:\n KE, KEvec, KE_bulk, T1, T2, T3, T4 = \\\n kinetic_energy_rigidbody(theta, phi, vx, vy, vtheta, vphi, vpsi, Mm, params)\n print 'KE = ', KE\n # Gravitational potential energy\n gU_v = Mm * params['g'] * params['l'] * np.cos(theta)\n gU = np.sum(gU_v)\n totE = bU + KE + gU\n ax4.plot(-h, gU, 'g.') # label='Gravitational')\n # ax3.plot(-h,totE-np.sum(0.5*params['I3']*(vpsi+vphi*np.cos(theta))**2),'k.')\n\n ax.plot(-h, totE - T4, 'k.') # ,label='Total')\n ax3.plot(-h, bU, 'b.') # ,label='Elastic')\n ax2.plot(-h, KE - T4, 'r.') # ,label='Kinetic')\n ax2.plot(-h, T3, 'rx') # ,label='Kinetic')\n\n if plotBIND:\n if 'BIND' in params:\n if len(params['BIND']) > 0:\n BIND = params['BIND']\n fig2 = plt.figure(2)\n plt.clf()\n ax21 = plt.subplot(4, 1, 1)\n ax22 = plt.subplot(4, 1, 2)\n ax23 = plt.subplot(4, 1, 3)\n ax24 = plt.subplot(4, 1, 4)\n # ax.plot(-h,bU,'b.',label='Bulk Potential')\n bulkIND = np.setdiff1d(np.arange(len(xy[:, 0])), BIND)\n gU_bulk = np.sum(gU_v[bulkIND])\n print 'bulkIND = ', bulkIND\n print 'gU_particle4 = ', gU_bulk\n totE_bulk = KE_bulk + bU + gU_bulk\n ax21.plot(-h, totE_bulk, 's', color=[0.3, .3, .3])\n ax22.plot(-h, KE_bulk, 's', color=[1.0, .5, .5]) # ,label='Bulk Kinetic')\n ax23.plot(-h, bU, 'bs')\n ax24.plot(-h, gU_bulk, 's', color=[0.5, 1.0, .5], markeredgecolor='none')\n\n ax21.set_ylabel('Total')\n ax24.set_xlabel('time')\n ax22.set_ylabel('Kinetic')\n ax23.set_ylabel('Elastic')\n ax24.set_ylabel('Gravitational')\n\n # make list of indices to plot\n doall = range(0, len(xyfiles))\n\n print('Plotting energy vs t...')\n for i in doall:\n KL = np.loadtxt(KLfiles[i], delimiter=',')\n iterind = (xyfiles[i].split('_')[-1]).split('.')[0]\n t = float(iterind) * h\n\n if dimension < 5:\n xy = np.loadtxt(xyfiles[i], delimiter=',', usecols=(0, 1))\n v = np.loadtxt(xyfiles[i], delimiter=',', usecols=(2, 3))\n KE = kinetic_energy(v, Mm)\n else:\n x, y, theta, phi = np.loadtxt(xyfiles[i], delimiter=',', usecols=(0, 1, 2, 3), unpack=True)\n vx, vy, vtheta, vphi, vpsi = np.loadtxt(xyfiles[i], delimiter=',', usecols=(5, 6, 7, 8, 9), unpack=True)\n xy = np.dstack((x, y))[0]\n KE, KEvec, KE_bulk, T1, T2, T3, T4 = kinetic_energy_rigidbody(theta, phi, vx, vy, vtheta, vphi, vpsi, Mm,\n params)\n # Gravitational potential energy\n gU_v = Mm * params['g'] ** params['l'] * np.cos(theta)\n gU = np.sum(gU_v)\n\n # redo calculations of BL, bo, kL if bonds were cut\n if np.count_nonzero(KL) != nzcount:\n BL = NL2BL(NL, KL)\n bo = bond_length_list(xy0, BL)\n kL = KL2kL(NL, KL, BL) * params['k']\n nzcount = np.count_nonzero(KL)\n\n if 'shrinkrate' in params:\n if 'prestrain' in params:\n bU = potential_energy(xy, BL, bo * (1. - params['prestrain'] - params['shrinkrate'] * t), kL)\n else:\n bU = potential_energy(xy, BL, bo * (1. - params['shrinkrate'] * t), kL)\n else:\n bU = potential_energy(xy, BL, bo, kL)\n\n if dimension < 5:\n totE = bU + KE\n else:\n totE = bU + KE + gU\n ax4.plot(t, gU, 'g.')\n # ax3.plot(t,totE-np.sum(0.5*params['I3']*(vpsi+vphi*np.cos(theta))**2),'k.')\n # ax3.plot(t,totE-np.sum(0.5*params['I3']*params['w3']**2),'k.')\n\n ax.plot(t, totE - T4, 'k.')\n ax2.plot(t, KE - T4, 'r.')\n # ax2.plot(t,T1,'ro') #,label='Kinetic')\n # ax2.plot(t,T2,'r^') #,label='Kinetic')\n # ax2.plot(t,T3,'rx') #,label='Kinetic')\n ax3.plot(t, bU, 'b.')\n\n if plotBIND:\n if 'BIND' in params:\n if len(params['BIND']) > 0:\n # ax.plot(-h,bU,'b.',label='Bulk Potential')\n ax22.plot(t, KE_bulk, 's', color=[1.0, .5, .5], markeredgecolor='none') # 'Bulk Kinetic'\n gU_bulk = np.sum(gU_v[bulkIND])\n totE_bulk = KE_bulk + bU + gU_bulk\n ax24.plot(t, gU_bulk, 's', color=[0.5, 1.0, .5], markeredgecolor='none')\n ax23.plot(t, bU, 'bs')\n ax21.plot(t, totE_bulk, 's', color=[0.5, .3, .3], markeredgecolor='none') # 'Bulk Total'\n\n title = 'Energy Conservation'\n ax.set_title(title)\n ax.set_ylabel(r'Total - $\\frac{I_3 \\omega_3^2}{2} $')\n ax3.set_xlabel('time')\n ax2.set_ylabel(r'Kinetic - $\\frac{I_3 \\omega_3^2}{2}$')\n ax3.set_ylabel('Elastic')\n\n ax.set_xlim([-h, t])\n ax2.set_xlim([-h, t])\n ax3.set_xlim([-h, t])\n\n if dimension == 5:\n ax4.set_ylabel('Gravitational')\n ax4.set_xlim([-h, t])\n ax3.set_xlabel('')\n ax4.set_xlabel('time')\n ax3.set_xticks([])\n\n # ylimit of first axis is either the last total energy or a large number\n if ylimmax != 'auto':\n ax.set_ylim(0, NP * ylimmax) # np.nanmin((totE,NP*ylimmax)))\n print('ylim_max = ' + str(np.nanmin((totE, NP * ylimmax))))\n\n ax.set_xticks([])\n ax2.set_xticks([])\n\n outname = datadir + 'Energy_vs_t.png'\n plt.figure(1)\n plt.savefig(outname)\n\n if plotBIND:\n if 'BIND' in params:\n if len(params['BIND']) > 0:\n plt.figure(2)\n ax21.set_xlim([-h, t])\n ax22.set_xlim([-h, t])\n ax23.set_xlim([-h, t])\n ax24.set_xlim([-h, t])\n\n ax21.set_xticks([])\n ax22.set_xticks([])\n ax23.set_xticks([])\n\n outname = datadir + 'Energy_vs_t_BIND.png'\n plt.savefig(outname)\n\n # ax.set_xlim([-h,5])\n # ax2.set_xlim([-h,5])\n # ax3.set_xlim([-h,5])\n # ax4.set_xlim([-h,5])\n #\n # ax.set_xticks([])\n # ax2.set_xticks([])\n #\n # outname = datadir+'Energy_vs_t_zoom.png'\n # #plt.show()\n # plt.figure(1)\n # plt.savefig(outname)","def builtin_plot(self, **kwargs):\n self.gp.plot(**kwargs)\n return","def plot_couplingmatrix(self,lmax,nwins,show=True,fname=None):\n figsize = mpl.rcParams['figure.figsize']\n figsize[0] = figsize[1]\n fig = plt.figure(figsize=figsize)\n ax = fig.add_subplot(111)\n coupling_matrix = self.get_couplingmatrix(lmax,nwins)\n ax.imshow(coupling_matrix)\n ax.set_xlabel('output power')\n ax.set_ylabel('input power')\n fig.tight_layout(pad=0.1)\n\n if show: plt.show()\n if fname is not None:\n fig.savefig(fname)","def show(self):\n lines, = pylab.plot(self.wavelengths, self.intensities)\n return lines","def show():\n plt.show()","def show():\n plt.show()","def show():\n plt.show()","def plot_zoom(ax, xlims):\n\n xmin, xmax, ymin, ymax = get_y_lims(ax, xlims)\n ax.set_xlim(xmin, xmax)\n ax.set_ylim(ymin, ymax)\n\n return ax","def plot(axes, axis, values, c='chartreuse'):\n a = axes[axis]\n a.set_xlabel('time (s)')\n x = np.array(range(len(values))) / 1000\n dim = 'x' if axis == 0 else 'y' if axis == 1 else 'z'\n a.set_title('-'.join([dim, 'acceleration']))\n a.plot(x, values / 1000, c=c)","def plot(self): \n\t\txandy = sep_xy(self.start, self.end)\n\t\tplt.plot(xandy[0], xandy[1], 'k-', lw=1, color='blue')","def plot(self):\n pass","def peek(self, **kwargs):\n\n plt.figure()\n axes = plt.gca()\n data_lab=self.meta['OBS-FREQ'][0:2] + ' ' + self.meta['OBS-FREQ'][2:5]\n axes.plot(self.data.index,self.data,label=data_lab)\n axes.set_yscale(\"log\")\n axes.set_ylim(1e-4,1)\n axes.set_title('Nobeyama Radioheliograph')\n axes.set_xlabel('Start time: ' + self.data.index[0].strftime(TIME_FORMAT))\n axes.set_ylabel('Correlation')\n axes.legend()\n plt.show()","def plot_powerlaw(self, **kwargs):\n\n if self.gamma is None:\n self.exponent()\n p = powerlaw.plot(exponent=-self.gamma,\n xmax=self.max_deg, xmin=self.k_min,\n **kwargs\n )\n pylab.show()\n return p","def _plot(self):\r\n fig = plt.figure()\r\n\r\n # Take out second component of intensity if needed\r\n # if self._vna.isTwoComponents():\r\n # intensitySimplified = []\r\n # for i in range(len(self._intensity)):\r\n # tempSet = []\r\n # for j in range(len(self._intensity[i])):\r\n # if (j%2) == 0:\r\n # tempSet.append(self._intensity[i][j])\r\n # intensitySimplified.append(tempSet)\r\n # for i in range(len(self._frequency)):\r\n # plt.plot(self._frequency[i],intensitySimplified[i],label=('%sv' % self._voltages[i][0]))\r\n # else:\r\n for i in range(len(self._frequency)):\r\n plt.plot(self._frequency[i],self._intensity[i],label=('%sv' % self._voltages[i][0]))\r\n plt.legend(loc='upper left')\r\n fig.suptitle('Intensity-Frequency with non-Constant Voltage', fontsize=18)\r\n plt.xlabel('Frequency (Hz)', fontsize=18)\r\n plt.ylabel('Intensity (dBm)', fontsize=16)\r\n\r\n # Save plot\r\n self._saveFig()","def plot(self, x, y, mX = 1, mY = 1):\n x = self.xy[x]\n y = self.xy[y]\n\n # Find pareto front:\n xp, yp = self.pareto_frontier(x,y, mX, mY)\n\n plt.plot(x, y, 'o')\n plt.plot(xp, yp, '-')\n plt.tight_layout()\n plt.show()","def showPlot1(title, x_label, y_label):\n num_robot_range = range(1, 11)\n times1 = []\n times2 = []\n for num_robots in num_robot_range:\n print \"Plotting\", num_robots, \"robots...\"\n times1.append(runSimulation(num_robots, 1.0, 20, 20, 0.8, 20, StandardRobot))\n times2.append(runSimulation(num_robots, 1.0, 20, 20, 0.8, 20, RandomWalkRobot))\n pylab.plot(num_robot_range, times1)\n pylab.plot(num_robot_range, times2)\n pylab.title(title)\n pylab.legend(('StandardRobot', 'RandomWalkRobot'))\n pylab.xlabel(x_label)\n pylab.ylabel(y_label)\n pylab.show()","def plot_track_rigidbody(params, datadir, pp=4, zoom=None):\n h = params['h']\n\n # get dirs\n xypath = sorted(glob.glob(datadir + 'xyv/'))[0]\n # list files\n xyfiles = sorted(glob.glob(xypath + '*.txt'))\n\n plt.clf()\n ax1 = plt.subplot(5, 1, 1)\n ax2 = plt.subplot(5, 1, 2)\n ax3 = plt.subplot(5, 1, 3)\n ax4 = plt.subplot(5, 1, 4)\n ax5 = plt.subplot(5, 1, 5)\n doall = range(0, len(xyfiles))\n for i in doall:\n iterind = (xyfiles[i].split('_')[-1]).split('.')[0]\n t = float(iterind) * h\n\n x, y, theta, phi, psi = np.loadtxt(xyfiles[i], delimiter=',', usecols=(0, 1, 2, 3, 4), unpack=True)\n # vX,vY,vtheta,vphi,vpsi = np.loadtxt(xyfiles[i],delimiter=',', usecols=(5,6,7,8,9), unpack=True)\n\n ax1.plot(t, x[pp], 'k.')\n ax2.plot(t, y[pp], 'r.')\n ax3.plot(t, theta[pp], 'r.')\n ax4.plot(t, phi[pp], 'r.')\n ax5.plot(t, psi[pp], 'g.')\n\n title = 'Tracking Single Gyro'\n ax1.set_title(title)\n ax5.set_xlabel('time')\n ax1.set_ylabel('X')\n ax2.set_ylabel('Y')\n ax3.set_ylabel(r'$\\theta$')\n ax4.set_ylabel(r'$\\phi$')\n ax5.set_ylabel(r'$\\psi$')\n\n ax1.set_xlim([-h, t])\n ax2.set_xlim([-h, t])\n ax3.set_xlim([-h, t])\n ax4.set_xlim([-h, t])\n ax5.set_xlim([-h, t])\n\n ax1.set_xticks([])\n ax2.set_xticks([])\n ax3.set_xticks([])\n ax4.set_xticks([])\n\n outname = datadir + 'Track.png'\n plt.savefig(outname)\n\n if zoom != None:\n ax1.set_xlim([-h, zoom])\n ax2.set_xlim([-h, zoom])\n ax3.set_xlim([-h, zoom])\n ax4.set_xlim([-h, zoom])\n ax5.set_xlim([-h, zoom])\n\n outname = datadir + 'Track_zoom.png'\n plt.savefig(outname)","def display1(*args):\n #----------*----------* # unpack\n twiss_func = args[0]\n lat_plot = args[3]\n #-------------------- beta x,y & dispersion x\n s = [twiss_func(i,'s') for i in range(twiss_func.nbpoints)]\n bx = [twiss_func(i,'bx') for i in range(twiss_func.nbpoints)]\n by = [twiss_func(i,'by') for i in range(twiss_func.nbpoints)]\n dx = [twiss_func(i,'dx') for i in range(twiss_func.nbpoints)]\n #-------------------- lattice viseo\n vzero = [0. for i in range(lat_plot.nbpoints)] # zero line\n vis_abszisse = [lat_plot(i,'s') for i in range(lat_plot.nbpoints)]\n vis_ordinate = [lat_plot(i,'viseo') for i in range(lat_plot.nbpoints)]\n #-------------------- figure frame\n width=14; height=7.6\n plt.figure(num=0,figsize=(width,height),facecolor='#eaecef',tight_layout=False)\n\n #-------------------- transverse X\n splot111=plt.subplot(111)\n splot111.set_title('beta functions')\n plt.plot(s,bx, label=r'$\\beta_x$ [m]', color='red', linestyle='-') # beta x\n plt.plot(s,by, label=r'$\\beta_y$ [m]', color='blue', linestyle='-') # beta y\n plt.plot(s,dx, label=r'$\\eta_x$ [m]' , color='green',linestyle='-') # dispersion x\n vscale=splot111.axis()[3]*0.25\n viseoz = [x*vscale for x in vis_ordinate]\n plt.plot(vis_abszisse,viseoz,label='',color='black')\n plt.plot(vis_abszisse,vzero,color='black')\n plt.legend(loc='lower right',fontsize='x-small')","def visualize_signal(self):\n plt.figure()\n plt.title('Accelerometer Signal')\n plt.plot(range(len(self.data)), self.data[1])","def raster_plot(nucleus, label=None, **kwargs):\r\n\r\n # Get fireds data\r\n fireds = nucleus.historique['fired']\r\n\r\n # Build x-axis and y-axis data by looping through fireds\r\n xdata, ydata = [], []\r\n for x, fires in fireds.items():\r\n for y in fires:\r\n xdata.append(x)\r\n ydata.append(y)\r\n\r\n # Matplotlib\r\n fig = plt.figure()\r\n plt.plot(xdata, ydata, '|', **kwargs)\r\n plt.ylabel('Neuron indexes')\r\n plt.xlabel('time')\r\n if label is None and nucleus.label is None:\r\n plt.title('Raster plot')\r\n elif label is not None and nucleus.label is None:\r\n plt.title('Raster plot (%s)' % label)\r\n elif label is None and nucleus.label is not None:\r\n plt.title('Raster plot of %s' % nucleus.label)\r\n else:\r\n plt.title('Raster plot of %s (%s)' % (nucleus.label, label))\r\n\r\n return fig","def plot(self, A = None):\r\n if A is not None: self.A = A\r\n self.im.set_data(self.A)\r\n self.ax.draw_artist(self.im)\r\n self.fig.canvas.blit(self.ax.bbox)","def plot_linear(x_range, w, b):\n\tplt.plot(x_range, x_range * w + b)","def plot_motion(x, y):\n plt.xlabel(\"X Position (m)\")\n plt.ylabel(\"Y Position (m)\")\n plt.plot(x, y)\n plt.show()","def plot_3d(self, ax_3d: Axes3D, lims_x: array_like = (-1, 1), lims_y: array_like = (-1, 1), **kwargs) -> None:\n X, Y, Z = self.to_mesh(lims_x, lims_y)\n\n ax_3d.plot_surface(X, Y, Z, **kwargs)"],"string":"[\n \"def liveplot(x, y, xlim, ylim, title):\\n plt.plot(x,y,'b.')\\n plt.xlim(xlim)\\n plt.ylim(ylim)\\n plt.xlabel('North-South Axis')\\n plt.ylabel('East-West Axis')\\n plt.title(title)\\n plt.show()\",\n \"def plot_xyz():\\n plt.subplot(3,1,1) # for x axis\\n plt.title('x value v.s. time')\\n plt.grid(True)\\n plt.ylabel('X')\\n plt.xlabel('t')\\n plt.plot(x, '-r')\\n\\n plt.subplot(3,1,2) # for y axis\\n plt.title('y value v.s. time')\\n plt.grid(True)\\n plt.ylabel('Y')\\n plt.xlabel('t')\\n plt.plot(y, '-g')\\n\\n plt.subplot(3,1,3) # for z axis\\n plt.title('z value v.s. time')\\n plt.grid(True)\\n plt.ylabel('Z')\\n plt.xlabel('t')\\n plt.plot(z, '-b')\",\n \"def xyplot(x_vals,y_vals,name):\\n # set the figure's size\\n set_figsize(figsize=(5, 2.5))\\n # detach() is used to get a variable from the current calculation graph\\n # in which this variable is the not gradient tracking version\\n plt.plot(x_vals.detach().numpy(), y_vals.detach().numpy())\\n # set the constant x axis label\\n plt.xlabel('x')\\n # combine and set the y axis label\\n plt.ylabel(name+'(x)')\\n plt.show()\",\n \"def plot_xy(x, y, ax=None, xlabel='Energy [keV]', **kwargs):\\n\\n if not ax:\\n new_plot = True\\n plt.figure()\\n ax = plt.axes()\\n else:\\n new_plot = False\\n\\n plt.semilogy(x, y, axes=ax, drawstyle='steps-mid', **kwargs)\\n\\n if new_plot:\\n plt.xlabel(xlabel)\\n plt.ylabel('Counts')\\n\\n if 'label' in kwargs:\\n plt.legend()\\n plt.show()\\n\\n return ax\",\n \"def plotWavelet(self):\\n\\n a = 0\\n if(self.axQT is not None):\\n self._bxPlot()\\n a += 1\\n if(self.bxQT is not None):\\n self._cxPlot()\\n a += 1\\n\\n if(a > 0):\\n return\\n\\n self._setupPlot()\\n self._axPlot()\\n self._bxPlot()\\n self._cxPlot()\\n self._dxPlot()\\n self._endingPlot()\",\n \"def plot(self):\\n plot_spectrum(self.data, self.fig, self.ax_e, self.ax_s, title = \\\"Solar spectrum\\\")\",\n \"def plot_simulation_xz(\\n sim: td.Simulation,\\n x: float = 0.0,\\n z: float = 0.0,\\n wavelength: Optional[float] = 1.55,\\n figsize: Float2 = (11, 4),\\n):\\n fig = plt.figure(figsize=figsize)\\n gs = mpl.gridspec.GridSpec(1, 2, figure=fig, width_ratios=[1, 1.4])\\n ax1 = fig.add_subplot(gs[0, 0])\\n ax2 = fig.add_subplot(gs[0, 1])\\n if wavelength:\\n freq = td.constants.C_0 / wavelength\\n sim.plot_eps(z=z, ax=ax1, freq=freq)\\n sim.plot_eps(x=x, ax=ax2, freq=freq)\\n else:\\n sim.plot(z=z, ax=ax1)\\n sim.plot(x=x, ax=ax2)\\n plt.show()\\n return fig\",\n \"def plot(self, ax=..., *, name=..., **kwargs):\\n ...\",\n \"def show_plot() :\\n logger.info(\\\"Show plot\\\")\\n pylab.axis('equal')\\n pylab.xlabel(\\\"Longitud\\\")\\n pylab.ylabel(\\\"Latitud\\\")\\n pylab.grid(True)\\n pylab.title(\\\"Product tiles and product source\\\")\\n pylab.show()\",\n \"def plot_xy(self, xpts, ypts):\\n self.plot(np.asarray((xpts, ypts)).T)\",\n \"def plotSpectrum(inp,xrng=[],yrng=[],xlabel='',ylabel='',xlog=False,ylog=False,grid=False,\\n legend=[],legend_location='upper right',fontscale=1,legend_fontscale=1,title='',\\n color='k',colormap=None,linestyle='-',linewidth=1.5,alpha=1.,\\n show_noise=True,color_noise='k',linestyle_noise='-',linewidth_noise=1.5,alpha_noise=0.5,\\n comparison=None,color_comparison='grey',linestyle_comparison='-',linewidth_comparison=1.5,alpha_comparison=1,\\n residual=False,color_residual='m',linestyle_residual='-',linewidth_residual=1.5,alpha_residual=0.5,\\n telluric=False,color_telluric='grey',linestyle_telluric='-',linewidth_telluric=1.5,alpha_telluric=0.2,\\n features=[],mdwarf=False,ldwarf=False,tdwarf=False,young=False,binary=False,nsamples=100,\\n band=[],band_color='k',band_alpha=0.2,band_label='',band_label_position='bottom',band_width=0.1,\\n show_zero=True,stack=0.,zeropoint=0.,color_zero='k',linestyle_zero=':',linewidth_zero=1.5,alpha_zero=0.3,\\n inset=False,inset_xrange=[],inset_yrange=[],inset_position=[0.65,0.60,0.20,0.20],inset_features=False,\\n output='',multiplot=False,multipage=False,layout=[1,1],figsize=[],tight=True,\\n interactive=False,**kwargs):\\n\\n# keyword parameters (for backward compatability)\\n for k in ['showZero','showzero']: show_zero=kwargs.get(k,show_zero)\\n for k in ['showNoise','noise','uncertainty','shownoise','showuncertainty','show_uncertainty']: show_noise=kwargs.get(k,show_noise)\\n\\n for k in ['line_style','lineStyle','ls','linestyles','line_styles']: linestyle=kwargs.get(k,linestyle)\\n for k in ['line_width','lineWidth','width','lw','linewidths','line_widths']: linewidth=kwargs.get(k,linewidth)\\n for k in ['colors','colour','colours']: color=kwargs.get(k,color)\\n for k in ['colorScheme','color_scheme','colorscheme','colorMap','color_map']: colormap=kwargs.get(k,colormap)\\n\\n for k in ['colornoise','colorNoise','colorUnc','coloruncertainty','color_uncertainty','colorUncertainty']: color_noise=kwargs.get(k,color_noise)\\n for k in ['linestylenoise','line_style_noise','linestyleNoise']: linestyle_noise=kwargs.get(k,linestyle_noise)\\n for k in ['linewidthnoise','linewidthNoise','line_width_noise']: linewidth_noise=kwargs.get(k,linewidth_noise)\\n for k in ['alphanoise','alphaNoise']: alpha_noise=kwargs.get(k,alpha_noise)\\n\\n for k in ['colorzero','colorZero']: color_zero=kwargs.get(k,color_zero)\\n for k in ['linestylezero','line_style_zero','linestyleZero']: linestyle_zero=kwargs.get(k,linestyle_zero)\\n for k in ['linewidthzero','linewidthZero','line_width_zero']: linewidth_zero=kwargs.get(k,linewidth_zero)\\n for k in ['alphazero','alphaZero']: alpha_zero=kwargs.get(k,alpha_zero)\\n\\n for k in ['colorcomparison','colorComparison']: color_comparison=kwargs.get(k,color_comparison)\\n for k in ['linestyleComparison','line_style_comparison','linestylecomparison']: linestyle_comparison=kwargs.get(k,linestyle_comparison)\\n for k in ['linewidthcomparison','linewidthComparison','line_width_comparison']: linewidth_comparison=kwargs.get(k,linewidth_comparison)\\n for k in ['alphacomparison','alphaComparison']: alpha_comparison=kwargs.get(k,alpha_comparison)\\n\\n for k in ['colorresidual','colorResidual']: color_residual=kwargs.get(k,color_residual)\\n for k in ['linestyleresidual','line_style_residual','linestyleResidual']: linestyle_residual=kwargs.get(k,linestyle_residual)\\n for k in ['linewidthresidual','linewidthResidual','line_width_residual']: linewidth_residual=kwargs.get(k,linewidth_residual)\\n for k in ['alpharesidual','alphaResidual']: alpha_residual=kwargs.get(k,alpha_residual)\\n\\n for k in ['bands']: band=kwargs.get(k,band)\\n if len(band) == 2 and isinstance(band[0],list) == False: band = [band]\\n for k in ['bandcolors','bandcolor','band_colors']: band_color=kwargs.get(k,band_color)\\n for k in ['bandalphas','band_alphas','bandalpha']: band_alpha=kwargs.get(k,band_alpha)\\n for k in ['band_labels','bandlabel','bandlabels']: band_label=kwargs.get(k,band_label)\\n for k in ['band_label_positions','bandlabelposition','bandlabelpositions']: band_label_position=kwargs.get(k,band_label_position)\\n for k in ['bandwidth','bandwidths','band_widths']: band_width=kwargs.get(k,band_width)\\n for par in [band_color,band_alpha,band_label,band_label_position,band_width]:\\n if not isinstance(par,list): par = [par]*len(band)\\n if len(par) < len(band): par.extend([par[-1] for x in range(len(band)-len(par))])\\n\\n for k in ['legends','label','labels']: legend=kwargs.get(k,legend)\\n if not isinstance(legend,list): legend = [legend]\\n for k in ['legendfontscale','legendFontscale']: legend_fontscale=kwargs.get(k,legend_fontscale)\\n legend_fontscale=legend_fontscale*fontscale\\n for k in ['legendLocation','legendlocation','labelLocation','labellocation','label_location']: legend_location=kwargs.get(k,legend_location)\\n\\n for k in ['xrange','x_range','wave_range','wrange','wrng']: xrng=kwargs.get(k,xrng)\\n if not isinstance(xrng,list): xrng = [xrng]\\n for k in ['yrange','y_range','flux_range','frange','frng']: yrng=kwargs.get(k,yrng)\\n if not isinstance(yrng,list): yrng = [yrng]\\n\\n for k in ['multilayout','multiLayout','multi_layout']: layout=kwargs.get(k,layout)\\n for k in ['file','filename']: output=kwargs.get(k,output)\\n if not isinstance(output,str): output=''\\n filetype = '.pdf'\\n if output!='': filetype=output.split('.')[-1]\\n\\n if comparison != None and isinstance(comparison,splat.Spectrum) == False and isinstance(comparison,list) == False: \\n print('plotSpectrum() Warning: comparison spectrum should be a splat Spectrum object, you passed {}'.format(comparison))\\n comparison = None\\n\\n# some plotting constants\\n xlabel_default = 'Wavelength'\\n ylabel_deafult = 'Flux'\\n\\n# telluric bands in micron\\n telluric_bands = [[1.1,1.2]*u.micron,[1.3,1.5]*u.micron,[1.75,2.0]*u.micron]\\n\\n# assign features by group\\n if not isinstance(features,list): features = [features]\\n if ldwarf==True or mdwarf==True: features.extend(['k','na','feh','tio','co','h2o','h2'])\\n if tdwarf==True: features.extend(['k','ch4','h2o','h2'])\\n if young==True: features.extend(['vo'])\\n if binary==True: features.extend(['sb'])\\n\\n# clean repeats in features while maintaining order - set does not do this\\n if len(features)>0:\\n fea = []\\n for i in features:\\n if i not in fea: fea.append(i)\\n features = fea\\n\\n\\n# if a list is passed, use this list\\n splist = copy.deepcopy(inp)\\n if isinstance(splist,list) == False: splist = [splist]\\n \\n# set up for multiplot\\n if len(splist) == 1: multiplot = False\\n \\n# array of lists => force multiplot\\n elif len(splist) > 1 and isinstance(splist[0],list) == True: multiplot = True\\n else: pass\\n\\n# reformat array of spectra of multiplot is used (i.e., user forgot to set)\\n if multiplot == True and isinstance(splist[0],splat.Spectrum):\\n splist = [[s] for s in splist]\\n\\n elif multiplot == False and isinstance(splist[0],splat.Spectrum):\\n splist = [splist]\\n \\n# flatten array if multiplot is not set\\n elif multiplot == False and isinstance(splist[0],list) and len(splist) > 1:\\n splist = [[item for sublist in splist for item in sublist]] # flatten\\n else: pass\\n\\n# total number of spectra - use to assign default legends\\n allsps = [item for sublist in splist for item in sublist] # Total number of spectra\\n if len(legend) == 0: legend=[sp.name for sp in allsps]\\n if len(legend) < len(allsps):\\n legend.extend([allsps[i].name for i in range(len(legend),len(allsps)-len(legend))])\\n \\n\\n# now run a loop through the input subarrays\\n plt.close('all')\\n\\n# set up here for multiple file output\\n nplot = 1\\n if multipage == True or multiplot == True:\\n nplot = layout[0]*layout[1]\\n numpages = int(len(splist) / nplot) + 1\\n if (len(splist) % nplot == 0):\\n numpages -= 1\\n fig = []\\n \\n if multipage == True and filetype.lower() == 'pdf':\\n pdf_pages = PdfPages(output)\\n \\n if multipage == False:\\n if len(splist) > 1:\\n filebase = output.replace('.{}'.format(filetype),'')\\n files = [filebase+'{}.'.format(i+1)+filetype for i in numpy.arange(len(splist))]\\n else:\\n files = [output]\\n\\n pg_n = 0 # page counter\\n plt_n = 0 # plot per page counter\\n lg_n = 0 # legend per plot counter\\n\\n for plts,sp in enumerate(splist):\\n# set specific plot parameters\\n if not isinstance(sp[0],splat.Spectrum):\\n raise ValueError('\\\\nInput to plotSpectrum has wrong format:\\\\n\\\\n{}\\\\n\\\\n'.format(sp[0]))\\n\\n# set up plotting defaults for the list of spectra - REPLACE THIS\\n if not isinstance(zeropoint,list): zeropoint = [zeropoint]*len(sp)\\n if len(zeropoint) < len(sp): zeropoint.extend([zeropoint[-1] for x in range(len(sp)-len(zeropoint))])\\n if not isinstance(color,list): color = [color]*len(sp)\\n if len(color) < len(sp): color.extend([color[-1] for x in range(len(sp)-len(color))])\\n if not isinstance(linestyle,list): linestyle = [linestyle]*len(sp)\\n if len(linestyle) < len(sp): linestyle.extend([linestyle[-1] for x in range(len(sp)-len(linestyle))])\\n if not isinstance(linewidth,list): linewidth = [linewidth]*len(sp)\\n if len(linewidth) < len(sp): linewidth.extend([linewidth[-1] for x in range(len(sp)-len(linewidth))])\\n if not isinstance(alpha,list): alpha = [alpha]*len(sp)\\n if len(alpha) < len(sp): alpha.extend([alpha[-1] for x in range(len(sp)-len(alpha))])\\n if not isinstance(color_noise,list): color_noise = [color_noise]*len(sp)\\n if len(color_noise) < len(sp): color_noise.extend([color_noise[-1] for x in range(len(sp)-len(color_noise))])\\n if not isinstance(linestyle_noise,list): linestyle_noise = [linestyle_noise]*len(sp)\\n if len(linestyle_noise) < len(sp): linestyle_noise.extend([linestyle_noise[-1] for x in range(len(sp)-len(linestyle_noise))])\\n if not isinstance(linewidth_noise,list): linewidth_noise = [linewidth_noise]*len(sp)\\n if len(linewidth_noise) < len(sp): linewidth_noise.extend([linewidth_noise[-1] for x in range(len(sp)-len(linewidth_noise))])\\n if not isinstance(alpha_noise,list): alpha_noise = [alpha_noise]*len(sp)\\n if len(alpha_noise) < len(sp): alpha_noise.extend([alpha_noise[-1] for x in range(len(sp)-len(color_noise))])\\n if not isinstance(color_comparison,list): color_comparison = [color_comparison]*len(sp)\\n if len(color_comparison) < len(sp): color_comparison.extend([color_comparison[-1] for x in range(len(sp)-len(color_comparison))])\\n if not isinstance(linestyle_comparison,list): linestyle_comparison = [linestyle_comparison]*len(sp)\\n if len(linestyle_comparison) < len(sp): linestyle_comparison.extend([linestyle_comparison[-1] for x in range(len(sp)-len(linestyle_comparison))])\\n if not isinstance(linewidth_comparison,list): linewidth_comparison = [linewidth_comparison]*len(sp)\\n if len(linewidth_comparison) < len(sp): linewidth_comparison.extend([linewidth_comparison[-1] for x in range(len(sp)-len(linewidth_comparison))])\\n if not isinstance(alpha_comparison,list): alpha_comparison = [alpha_comparison]*len(sp)\\n if len(alpha_comparison) < len(sp): alpha_comparison.extend([alpha_comparison[-1] for x in range(len(sp)-len(alpha_comparison))])\\n\\n# settings that work if the spectrum was read in as legitmate Spectrum object\\n try:\\n xlabel = kwargs.get('xlabel','{} ({})'.format(sp[0].wave_label,sp[0].wave.unit))\\n ylabel = kwargs.get('ylabel','{} ({})'.format(sp[0].flux_label,sp[0].flux.unit))\\n except:\\n xlabel = kwargs.get('xlabel',xlabel_default)\\n ylabel = kwargs.get('ylabel',ylabel_default)\\n# initial plot range\\n bound = [numpy.nanmin(sp[0].wave.value),numpy.nanmax(sp[0].wave.value)]\\n ymax = [numpy.nanquantile(s.flux.value,0.98) for s in sp]\\n bound.extend(numpy.array([-0.02,1.3])*numpy.nanmax(ymax)+\\\\\\n numpy.array([numpy.nanmin(zeropoint),numpy.nanmax(zeropoint)+stack*(len(sp)-1)]))\\n\\n# set colormap if provided\\n if colormap != None:\\n values = numpy.arange(len(sp))\\n color_map = plt.get_cmap(colormap)\\n norm = colmap.Normalize(vmin=0, vmax=1.0*values[-1])\\n scalarMap = cm.ScalarMappable(norm=norm, cmap=color_map)\\n for i in range(len(sp)): color[i] = scalarMap.to_rgba(values[i])\\n\\n# GENERATE PLOTS\\n if multiplot == True or multipage == True:\\n plt_n = plts % nplot\\n if (plt_n == 0):\\n fig.append(plt.figure())\\n pg_n += 1\\n ax = fig[pg_n-1].add_subplot(layout[0], layout[1], plt_n+1)\\n \\n# plotting a single plot with all spectra\\n else:\\n plt.close('all')\\n plt_n = 0\\n fig = []\\n if len(figsize)>0: fig.append(plt.figure(figsize=figsize))\\n else: fig.append(plt.figure())\\n ax = fig[0].add_subplot(111)\\n \\n for ii, a in enumerate(sp):\\n# zeropoint and stack\\n flx = [i+zeropoint[ii] for i in a.flux.value]\\n if stack > 0: flx = [f + (len(sp)-ii-1)*stack for f in flx]\\n ax.plot(a.wave.value,flx,color=color[ii],linestyle=linestyle[ii], lw=linewidth[ii], alpha=alpha[ii], zorder = 10, label = legend[lg_n]) \\n\\n# add comparison\\n if comparison != None:\\n# zeropoint and stack\\n cflx = [i+zeropoint[ii] for i in comparison.flux.value]\\n if stack > 0: cflx = [f + (len(sp)-ii-1)*stack for f in cflx]\\n ax.plot(comparison.wave.value,cflx,color=color_comparison[ii],linestyle=linestyle_comparison[ii], lw=linewidth_comparison[ii], alpha=alpha_comparison[ii], zorder = 10)\\n \\n# add residual\\n if residual == True and len(sp) == 2:\\n # Save flux values from first spectrum\\n if ii == 0:\\n flx0 = [f - (len(sp)-ii-1)*stack for f in flx]\\n \\n # Subtract fluxes and plot\\n elif ii == 1:\\n res = [flx0[f_n] - f for f_n, f in enumerate(flx)]\\n ax.plot(a.wave.value, res, alpha = alpha_residual[ii], color = color_residual[ii], linsetyle=linestyle_residual[ii], lw=linewidth_residual[ii])\\n \\n # Fix bound[2] if residual goes below 0\\n if numpy.nanmin(res) < bound[2]:\\n b0 = numpy.argmin(a.wave.value[a.wave.value > bound[0]])\\n b1 = numpy.argmax(a.wave.value[a.wave.value < bound[1]])\\n bound[2] = numpy.nanmin(res[b0:b1])\\n\\n# noise\\n if show_noise == True:\\n ns = [i+zeropoint[ii] for i in a.noise.value]\\n ax.plot(a.wave.value,ns,color=color_noise[ii],linestyle=linestyle_noise[ii],alpha=alpha_noise[ii], lw=linewidth_noise[ii], zorder = 10)\\n\\n# zeropoint\\n if show_zero == True:\\n ze = numpy.ones(len(a.flux))*zeropoint[ii]\\n ax.plot(a.wave.value,ze,color=color[ii],linestyle=linestyle_zero,alpha=alpha_zero,lw=linewidth_zero, zorder = 10)\\n\\n# save maximum flux among all spectra for plotting\\n# THIS IS VERY SLOW AND IT WOULD BE BETTER TO FIND AN ALTERNATE APPROACH\\n if len(features)>0:\\n f = interp1d(a.wave,flx,bounds_error=False,fill_value=0.)\\n if ii == 0: \\n wvmax = numpy.linspace(bound[0],bound[1],nsamples)\\n flxmax = numpy.array(f(wvmax))\\n else: flxmax = numpy.maximum(flxmax,numpy.array(f(wvmax)))\\n\\n# legend counter\\n lg_n = lg_n + 1 # Increment legend\\n\\n\\n# label features\\n# THIS NEEDS TO BE FIXED WITH GRETEL'S STUFF\\n if len(features) > 0:\\n yoff = 0.02*(bound[3]-bound[2]) # label offset\\n fontsize = int((10-numpy.nanmin([(layout[0]*layout[1]-1),6]))*fontscale)\\n for ftr in features:\\n ftr = ftr.lower()\\n if ftr in FEATURE_LABELS:\\n ftrc = checkDict(ftr,FEATURE_LABELS)\\n if ftrc != False:\\n for ii,waveRng in enumerate(FEATURE_LABELS[ftrc]['wavelengths']):\\n wRng = waveRng.to(sp[0].wave.unit).value\\n# features must be contained in plot range (may change this)\\n if numpy.nanmin(wRng) > bound[0] and numpy.nanmax(wRng) < bound[1]:\\n wfeature = numpy.where(numpy.logical_and(wvmax >= numpy.nanmin(wRng),wvmax <= numpy.nanmax(wRng)))\\n if len(wvmax[wfeature]) == 0: wfeature = numpy.argmax(numpy.absolute(wvmax-numpy.nanmedian(wRng)))\\n y = numpy.nanmax(flxmax[wfeature])+yoff\\n flxmax[wfeature] = flxmax[wfeature]+3.*yoff\\n\\n if FEATURE_LABELS[ftrc]['type'] == 'band':\\n ax.plot(wRng,[y+yoff]*2,color='k',linestyle='-')\\n ax.plot([wRng[0]]*2,[y,y+yoff],color='k',linestyle='-')\\n ax.text(numpy.mean(wRng),y+1.5*yoff,FEATURE_LABELS[ftrc]['label'],horizontalalignment='center',fontsize=fontsize)\\n else:\\n for w in wRng: ax.plot([w]*2,[y,y+yoff],color='k',linestyle='-')\\n ax.text(numpy.mean(wRng),y+1.5*yoff,FEATURE_LABELS[ftrc]['label'],horizontalalignment='center',fontsize=fontsize)\\n bound[3] = numpy.nanmax([numpy.nanmax(flxmax)+2.*yoff,bound[3]])\\n\\n# add grid\\n if grid == True: ax.grid() \\n\\n# axis labels \\n fontsize = (numpy.round(numpy.max([13./((layout[0]*layout[1])**0.33),5]))) * fontscale\\n legend_fontsize = (13-numpy.min([(layout[0]*layout[1]-1),8])) * legend_fontscale\\n ax.set_xlabel(xlabel, fontsize = fontsize)\\n ax.set_ylabel(ylabel, fontsize = fontsize)\\n ax.tick_params(axis='x', labelsize=fontsize)\\n ax.tick_params(axis='y', labelsize=fontsize)\\n\\n# add title\\n if title!='': ax.set_title(title)\\n\\n# log scale?\\n if kwargs.get('xlog',False): ax.set_xscale('log',nonposx='clip')\\n if kwargs.get('ylog',False): ax.set_yscale('log',nonposy='clip')\\n\\n# place legend\\n if len(legend) > 0:\\n if legend_location == 'outside':\\n box = ax.get_position()\\n ax.set_position([box.x0, box.y0 + box.height * 0.15, box.width * 0.7, box.height * 0.7])\\n ax.legend(loc='center left', bbox_to_anchor=(1, 0.5), prop={'size':legend_fontsize})\\n else:\\n ax.legend(loc=legend_location, prop={'size':legend_fontsize})\\n bound[3] = bound[3]+0.1*(bound[3]-bound[2]) # extend axis for in-plot legends\\n\\n# overplot telluric absorption\\n if telluric == True:\\n yoff = 0.02*(bound[3]-bound[2]) # label offset\\n for waveRng in telluric_bands:\\n wR = waveRng.to(sp[0].wave.unit).value\\n rect = patches.Rectangle((wR[0],bound[2]),wR[1]-wR[0],bound[3]-bound[2],facecolor=color_telluric,alpha=alpha_telluric,color=color_telluric)\\n ax.add_patch(rect)\\n ax.text(numpy.mean(wR),bound[2]+3*yoff,r'$\\\\oplus$',horizontalalignment='center',fontsize=fontsize)\\n\\n# overplot color swaths for pre-specified bands\\n if len(band) > 0:\\n for i,b in enumerate(band):\\n if not isinstance(b,list): \\n try: b = [float(b)-0.5*band_width,float(b)+0.5*band_width]\\n except:\\n print('\\\\nWarning: plotSpectrum bands variables should be array of 2-element arrays; you passed {}'.format(band))\\n b = [0.,0.]\\n rect = patches.Rectangle((b[0],bound[2]),b[1]-b[0],bound[3]-bound[2],facecolor=band_color[i],color=band_color[i],alpha=band_alpha[i])\\n ax.add_patch(rect)\\n if band_label_position[i].lower() == 'top':\\n ax.text(numpy.mean(b),bound[3]-3*yoff,band_label[i],horizontalalignment='center',fontsize=fontsize)\\n elif band_label_position[i].lower() == 'middle':\\n ax.text(numpy.mean(b),0.5*(bound[2]+bound[3]),band_label[i],horizontalalignment='center',fontsize=fontsize)\\n else:\\n ax.text(numpy.mean(b),bound[2]+3*yoff,band_label[i],horizontalalignment='center',fontsize=fontsize)\\n\\n# place inset - RIGHT NOW ONLY SETTING LIMITS WITH FIRST SPECTRUM IN LIST\\n if inset == True and len(inset_xrange) == 2:\\n ax_inset = fig[pg_n-1].add_axes(inset_position) #, axisbg='white')\\n bound2 = inset_xrange\\n if len(inset_yrange) == 0:\\n b0 = numpy.argmax(sp[0].wave.value > bound2[0])\\n b1 = numpy.argmin(sp[0].wave.value < bound2[1])\\n inset_yrange = [numpy.nanmin(sp[0].flux.value[b0:b1]),numpy.nanmax(sp[0].flux.value[b0:b1])]\\n bound2.extend(inset_yrange)\\n db = (bound2[3]-bound2[2])\\n bound2[2] = bound2[2]-0.05*db\\n bound2[3] = bound2[3]+0.05*db\\n ax_inset.axis(bound2)\\n inset_fontsize = fontsize*0.7\\n\\n for ii,a in enumerate(sp):\\n flx = [i+zeropoint[ii] for i in a.flux.value]\\n ax_inset.plot(a.wave.value,flx,color=colors[ii],linestyle=linestyle[ii],linewidth=linewidth[ii],alpha=alpha[ii]) \\n ax_inset.set_xlabel('')\\n ax_inset.set_ylabel('')\\n ax_inset.tick_params(axis='x', labelsize=inset_fontsize)\\n ax_inset.tick_params(axis='y', labelsize=inset_fontsize)\\n# ax_inset.legend()\\n\\n# inset feature labels\\n if len(inset_features) > 0:\\n yoff = 0.05*(bound2[3]-bound2[2])\\n for ftr in inset_features:\\n ftrc = checkDict(ftr,FEATURE_LABELS)\\n if ftrc != False:\\n for ii,waveRng in enumerate(FEATURE_LABELS[ftrc]['wavelengths']):\\n wRng = waveRng.to(sp[0].wave.unit).value\\n if (numpy.min(wRng) > bound2[0] and numpy.max(wRng) < bound2[1]):\\n wfeature = numpy.where(numpy.logical_and(wvmax >= numpy.nanmin(wRng),wvmax <= numpy.nanmax(wRng)))\\n if len(wvmax[wfeature]) == 0: wfeature = numpy.argmax(numpy.absolute(wvmax-numpy.nanmedian(wRng)))\\n y = numpy.nanmax(flxmax[wfeature])+yoff\\n flxmax[wfeature] = flxmax[wfeature]+3.*yoff\\n \\n if FEATURE_LABELS[ftrc]['type'] == 'band':\\n ax_inset.plot(wR,[y+yoff]*2,color='k',linestyle='-')\\n ax_inset.plot([wR[0]]*2,[y,y+yoff],color='k',linestyle='-')\\n ax_inset.text(numpy.mean(wR),y+2*yoff,FEATURE_LABELS[ftrc]['label'],horizontalalignment='center',fontsize=inset_fontsize)\\n else:\\n for w in waveRng:\\n ax_inset.plot([w]*2,[y,y+yoff],color='k',linestyle='-')\\n ax_inset.text(numpy.mean(wR),y+2*yoff,FEATURE_LABELS[ftrc]['label'],horizontalalignment='center',fontsize=inset_fontsize)\\n waveRng = [wR[0]-0.02,wR[1]+0.02] # for overlap\\n \\n# update offset\\n if len(inset_features) > 0: bound2[3] = numpy.nanmax([bound2[3],numpy.nanmax(flxmax)+5.*yoff])\\n ax_inset.axis(bound2)\\n\\n# finalize bounding\\n if len(xrng) > 0: bound[0:2] = xrng\\n if len(yrng) > 0: bound[2:4] = yrng\\n if isUnit(bound[0]): bound = [x.value for x in bound]\\n ax.axis(bound)\\n \\n# save to file or display\\n# ERROR HERE - CHECK WHAT FILES\\n if multipage == False:\\n if files[plts] != '' and (plts % nplot == 3 or plts == len(splist)-1):\\n if kwargs.get('tight',True) == True: \\n plt.savefig(files[plts], bbox_inches='tight')\\n else:\\n plt.savefig(files[plts])\\n if output == '' and not kwargs.get('web',False):\\n plt.show()\\n if (kwargs.get('interactive',False) != False): plt.ion()\\n else: plt.ioff()\\n\\n\\n# save figures in multipage format and write off pdf file\\n if multipage == True: \\n for pg_n in numpy.arange(numpages):\\n# fig[pg_n].text(0.5, 0.04, xlabel, ha = 'center', va = 'center')\\n# fig[pg_n].text(0.06, 0.5, ylabel, ha = 'center', va = 'center', rotation = 'vertical')\\n fig[pg_n].tight_layout\\n fig[pg_n].suptitle(title, fontsize = int(14*fontsize), fontweight = 'bold')\\n pdf_pages.savefig(fig[pg_n])\\n if filetype.lower() == 'pdf':\\n pdf_pages.close()\\n\\n plt.clf()\\n return fig\",\n \"def plot(self,include_rho=True,show=True,nx=129):\\n xs = np.linspace(0.0,1.0,nx)\\n plt.plot(xs,self.f0(xs),'b-')\\n plt.plot([self.rho_max,self.rho_max],[0.0,1.0],'b:')\\n plt.plot(xs,self.f1(xs),'r-')\\n plt.plot([self.rho_min,self.rho_min],[0.0,1.0],'r:')\\n plt.plot([0.0,1.0],[0.0,1.0],'k--')\\n if include_rho:\\n plt.plot([self.rho,self.rho],[0.0,1.0],'g:')\\n plt.xlim(0.0,1.0)\\n plt.ylim(0.0,1.0)\\n plt.axes().set_aspect(1.0)\\n if show:\\n plt.show()\",\n \"def plot(self):\\n\\t\\tself.plotOfXray().plot()\",\n \"def plot(self, **kwargs):\\n if self.order != None:\\n name = str(_constructModelName(self.teff, self.logg, \\n self.metal, self.en, self.order, self.path))\\n output = kwargs.get('output', str(name) + '.pdf')\\n ylim = kwargs.get('yrange', [min(self.flux)-.2, max(self.flux)+.2])\\n title = kwargs.get('title')\\n save = kwargs.get('save', False)\\n \\n plt.figure(figsize=(16,6))\\n plt.plot(self.wave, self.flux, color='k', \\n alpha=.8, linewidth=1, label=name)\\n plt.legend(loc='upper right', fontsize=12)\\n plt.ylim(ylim) \\n \\n minor_locator = AutoMinorLocator(5)\\n #ax.xaxis.set_minor_locator(minor_locator)\\n # plt.grid(which='minor') \\n \\n plt.xlabel(r'$\\\\lambda$ [$\\\\mathring{A}$]', fontsize=18)\\n plt.ylabel(r'$Flux$', fontsize=18)\\n #plt.ylabel(r'$F_{\\\\lambda}$ [$erg/s \\\\cdot cm^{2}$]', fontsize=18)\\n if title != None:\\n plt.title(title, fontsize=20)\\n plt.tight_layout()\\n\\n if save == True:\\n plt.savefig(output)\\n plt.show()\\n plt.close()\\n\\n else:\\n output = kwargs.get('output'+ '.pdf')\\n ylim = kwargs.get('yrange', [min(self.flux)-.2, max(self.flux)+.2])\\n title = kwargs.get('title')\\n save = kwargs.get('save', False)\\n \\n plt.figure(figsize=(16,6))\\n plt.plot(self.wave, self.flux, color='k', alpha=.8, linewidth=1)\\n plt.legend(loc='upper right', fontsize=12)\\n plt.ylim(ylim)\\n \\n minor_locator = AutoMinorLocator(5)\\n #ax.xaxis.set_minor_locator(minor_locator)\\n # plt.grid(which='minor') \\n \\n plt.xlabel(r'$\\\\lambda$ [$\\\\mathring{A}$]', fontsize=18)\\n plt.ylabel(r'$Flux$', fontsize=18)\\n #plt.ylabel(r'$F_{\\\\lambda}$ [$erg/s \\\\cdot cm^{2}$]', fontsize=18)\\n if title != None:\\n plt.title(title, fontsize=20)\\n plt.tight_layout()\\n\\n if save == True:\\n plt.savefig(output)\\n plt.show()\\n plt.close()\",\n \"def plotSpectrum(self, spectrum=None):\\n if spectrum is None:\\n spectrum = self.spectrometer.getSpectrum()\\n\\n if len(self.axes.lines) == 0:\\n self.axes.plot(self.spectrometer.wavelength, spectrum, 'k')\\n self.axes.set_xlabel(\\\"Wavelength [nm]\\\")\\n self.axes.set_ylabel(\\\"Intensity [arb.u]\\\")\\n else:\\n self.axes.lines[0].set_data( self.spectrometer.wavelength, spectrum) # set plot data\\n self.axes.relim()\",\n \"def plot(self, *args, **kwargs):\\n pass\",\n \"def graphplot(self):\\n if self.binned:\\n self.line.set_ydata(self.fft_bins_y)\\n else:\\n self.line.set_ydata(self.spec_y)\\n self.line2.set_ydata(self.wave_y)\\n self.ax1.draw_artist(self.ax1.patch)\\n self.ax2.draw_artist(self.ax2.patch)\\n self.ax1.draw_artist(self.line)\\n self.ax2.draw_artist(self.line2)\\n self.fig.canvas.update()\\n self.fig.canvas.flush_events()\",\n \"def plot(self,x,y):\\r\\n scalex,scaley = self.getScale()\\r\\n x = x*self.samplerate\\r\\n x = (x-scalex[0])/(scalex[1]-scalex[0])*self.w\\r\\n y = (y-scaley[0])/(scaley[1]-scaley[0])*self.h\\r\\n return (x,y)\",\n \"def plot_data(x, y, Amp, freq, filename):\\n plb.plot(x, y, 'b', linestyle = ':')\\n y_fit = Amp * np.sin(freq * x)\\n plb.plot(x, y_fit, 'r')\\n plb.savefig(filename)\",\n \"def plotXY(xName,xDataRaw,yName, yDataRaw):\\n scanFileHolder = getScanFileHolderXY(xName,xDataRaw,yName, yDataRaw) \\n scanFileHolder.plot(xName, yName)\\n return scanFileHolder\",\n \"def plot_xy(xy: np.ndarray, *args: Optional, **kwargs: Optional):\\n trj = traja.from_xy(xy)\\n trj.traja.plot(*args, **kwargs)\",\n \"def plot_spectrum(spec, ax=None, **kwargs):\\n\\n if not spec.data.size or not spec.energy.size or np.all(spec.energy == 0):\\n raise ValueError('Spectrum must be loaded and calibrated')\\n\\n ax = plot_xy(spec.energy, spec.data, ax=ax, **kwargs)\\n\\n return ax\",\n \"def plot_spectrum(freqs, fluxes, min_lambda=3700, max_lambda=8000):\\n plt.plot(freqs, fluxes)\\n plt.xlim((min_lambda, max_lambda))\\n plt.xlabel(r'$\\\\lambda\\\\, (\\\\AA)$', size=16)\\n plt.ylabel(r'$Flux$', size=16)\\n #plt.axes().minorticks_on()\",\n \"def visualisation(self):\\n plt.plot(self.x, self.y, 'o', label = 'Example data')\\n plt.plot(self.x, np.dot(self.w, self.X), label = 'Model')\\n plt.xlim([-1,1])\\n plt.ylim([-1,1])\",\n \"def plot(self, show=True):\\n xs, ys = zip(*[(float(ix)/self.sample_rate, val)\\n for ix, val in enumerate(self.samples)])\\n plt.plot(xs, ys)\\n if show:\\n plt.show()\",\n \"def plot(self, **kwargs):\\n\\n from ..plot import Plot\\n\\n p = Plot(1, 1, 1, **kwargs)\\n\\n p.axes[0].plot(self.dispersion.value, self.flux.value,\\n drawstyle='steps-mid')\\n\\n if self.flux.uncertainty is not None:\\n p.axes[0].plot(self.dispersion.value, self.flux.uncertainty.value,\\n drawstyle='steps-mid')\\n\\n p.tidy()\\n p.display()\",\n \"def plot():\\n pass\",\n \"def plot(data,fig,figure_number = 1,xlabel='',ylabel='',title=''):\\n fig.add_subplot(1,2,figure_number)\\n plt.title(title)\\n plt.xlabel(xlabel)\\n # only plot the y label if ipython is True, else the plot looks to cramped\\n if is_ipython:\\n plt.ylabel(ylabel)\\n plt.plot(np.array(data),'orange')\\n plt.ylim((0,1))\\n if not is_ipython:\\n plt.pause(0.000001) # pause a bit so that plots are updated\",\n \"def plot_solution(self, identlist, aperture_lst, plot_ax1=False, **kwargs):\\n coeff = kwargs.pop('coeff')\\n k = kwargs.pop('k')\\n offset = kwargs.pop('offset')\\n npixel = kwargs.pop('npixel')\\n std = kwargs.pop('std')\\n nuse = kwargs.pop('nuse')\\n ntot = kwargs.pop('ntot')\\n xorder = kwargs.pop('xorder')\\n yorder = kwargs.pop('yorder')\\n clipping = kwargs.pop('clipping')\\n maxiter = kwargs.pop('maxiter')\\n\\n label_size = 13 # fontsize for x, y labels\\n tick_size = 12 # fontsize for x, y ticks\\n\\n #wave_scale = 'linear'\\n wave_scale = 'reciprocal'\\n\\n #colors = 'rgbcmyk'\\n\\n self._ax2.cla()\\n self._ax3.cla()\\n\\n if plot_ax1:\\n self._ax1.cla()\\n x = np.linspace(0, npixel-1, 100, dtype=np.float64)\\n\\n # find the maximum and minimum wavelength\\n wl_min, wl_max = 1e9,0\\n allwave_lst = {}\\n for aperture in aperture_lst:\\n order = k*aperture + offset\\n wave = get_wavelength(coeff, npixel, x, np.repeat(order, x.size))\\n allwave_lst[aperture] = wave\\n wl_max = max(wl_max, wave.max())\\n wl_min = min(wl_min, wave.min())\\n # plot maximum and minimum wavelength, to determine the display\\n # range of this axes, and the tick positions\\n self._ax1.plot([0, 0],[wl_min, wl_max], color='none')\\n yticks = self._ax1.get_yticks()\\n self._ax1.cla()\\n\\n\\n for aperture in aperture_lst:\\n order = k*aperture + offset\\n color = 'C{}'.format(order%10)\\n\\n # plot pixel vs. wavelength\\n if plot_ax1:\\n wave = allwave_lst[aperture]\\n if wave_scale=='reciprocal':\\n self._ax1.plot(x, 1/wave,\\n color=color, ls='-', alpha=0.8, lw=0.8)\\n else:\\n self._ax1.plot(x, wave,\\n color=color, ls='-', alpha=0.8, lw=0.8)\\n\\n # plot identified lines\\n if aperture in identlist:\\n list1 = identlist[aperture]\\n pix_lst = list1['pixel']\\n wav_lst = list1['wavelength']\\n mask = list1['mask'].astype(bool)\\n res_lst = list1['residual']\\n\\n if plot_ax1:\\n if wave_scale=='reciprocal':\\n self._ax1.scatter(pix_lst[mask], 1/wav_lst[mask],\\n c=color, s=20, lw=0, alpha=0.8)\\n self._ax1.scatter(pix_lst[~mask], 1/wav_lst[~mask],\\n c='w', s=16, lw=0.7, alpha=0.8,\\n edgecolor=color)\\n else:\\n self._ax1.scatter(pix_lst[mask], wav_lst[mask],\\n c=color, s=20, lw=0, alpha=0.8)\\n self._ax1.scatter(pix_lst[~mask], wav_lst[~mask],\\n c='w', s=16, lw=0.7, alpha=0.8,\\n edgecolor=color)\\n\\n repeat_aper_lst = np.repeat(aperture, pix_lst.size)\\n self._ax2.scatter(repeat_aper_lst[mask], res_lst[mask],\\n c=color, s=20, lw=0, alpha=0.8)\\n self._ax2.scatter(repeat_aper_lst[~mask], res_lst[~mask],\\n c='w', s=16, lw=0.7, alpha=0.8, ec=color)\\n self._ax3.scatter(pix_lst[mask], res_lst[mask],\\n c=color, s=20, lw=0, alpha=0.8)\\n self._ax3.scatter(pix_lst[~mask], res_lst[~mask],\\n c='w', s=16, lw=0.7, alpha=0.8, ec=color)\\n\\n # refresh texts in the residual panels\\n text = 'R.M.S. = {:.5f}, N = {}/{}'.format(std, nuse, ntot)\\n self._ax3._residual_text.set_text(text)\\n text = u'Xorder = {}, Yorder = {}, clipping = \\\\xb1{:g}, Niter = {}'.format(\\n xorder, yorder, clipping, maxiter)\\n self._ax2._fitpar_text.set_text(text)\\n\\n # adjust layout for ax1\\n if plot_ax1:\\n self._ax1.set_xlim(0, npixel-1)\\n if wave_scale == 'reciprocal':\\n _y11, _y22 = self._ax1.get_ylim()\\n newtick_lst, newticklabel_lst = [], []\\n for tick in yticks:\\n if _y11 < 1/tick < _y22:\\n newtick_lst.append(1/tick)\\n newticklabel_lst.append(tick)\\n self._ax1.set_yticks(newtick_lst)\\n self._ax1.set_yticklabels(newticklabel_lst)\\n self._ax1.set_ylim(_y22, _y11)\\n self._ax1.set_xlabel('Pixel', fontsize=label_size)\\n self._ax1.set_ylabel(u'\\\\u03bb (\\\\xc5)', fontsize=label_size)\\n self._ax1.grid(True, ls=':', color='gray', alpha=1, lw=0.5)\\n self._ax1.set_axisbelow(True)\\n self._ax1._aperture_text.set_text('')\\n for tick in self._ax1.xaxis.get_major_ticks():\\n tick.label1.set_fontsize(tick_size)\\n for tick in self._ax1.yaxis.get_major_ticks():\\n tick.label1.set_fontsize(tick_size)\\n\\n # adjust axis layout for ax2 (residual on aperture space)\\n self._ax2.axhline(y=0, color='k', ls='--', lw=0.5)\\n for i in np.arange(-3,3+0.1):\\n self._ax2.axhline(y=i*std, color='k', ls=':', lw=0.5)\\n x1, x2 = self._ax2.get_xlim()\\n x1 = max(x1,aperture_lst.min())\\n x2 = min(x2,aperture_lst.max())\\n self._ax2.set_xlim(x1, x2)\\n self._ax2.set_ylim(-6*std, 6*std)\\n self._ax2.set_xlabel('Aperture', fontsize=label_size)\\n self._ax2.set_ylabel(u'Residual on \\\\u03bb (\\\\xc5)', fontsize=label_size)\\n for tick in self._ax2.xaxis.get_major_ticks():\\n tick.label1.set_fontsize(tick_size)\\n for tick in self._ax2.yaxis.get_major_ticks():\\n tick.label1.set_fontsize(tick_size)\\n\\n ## adjust axis layout for ax3 (residual on pixel space)\\n self._ax3.axhline(y=0, color='k', ls='--', lw=0.5)\\n for i in np.arange(-3,3+0.1):\\n self._ax3.axhline(y=i*std, color='k', ls=':', lw=0.5)\\n self._ax3.set_xlim(0, npixel-1)\\n self._ax3.set_ylim(-6*std, 6*std)\\n self._ax3.set_xlabel('Pixel', fontsize=label_size)\\n self._ax3.set_ylabel(u'Residual on \\\\u03bb (\\\\xc5)', fontsize=label_size)\\n for tick in self._ax3.xaxis.get_major_ticks():\\n tick.label1.set_fontsize(tick_size)\\n for tick in self._ax3.yaxis.get_major_ticks():\\n tick.label1.set_fontsize(tick_size)\",\n \"def plot(self):\\n\\t\\tself.plotOfLoopVoltage()\",\n \"def show_waveform(self, peaks=[]):\\n if peaks is None:\\n peaks = []\\n data = self.amplitude\\n x_axis = range(0, len(data))\\n x_axis = [x / self.fs for x in x_axis]\\n plt.plot(x_axis, data)\\n plt.axhline(self.height)\\n for p in peaks:\\n plt.axvline(p / self.fs, color=\\\"red\\\", alpha=0.2)\\n plt.ylabel(\\\"Amplitude\\\")\\n plt.xlabel(\\\"Time (seconds)\\\")\\n plt.title(\\\"Waveform\\\")\\n plt.show()\",\n \"def plot_simulation_yz(\\n sim: td.Simulation,\\n z: float = 0.0,\\n y: float = 0.0,\\n wavelength: Optional[float] = 1.55,\\n figsize: Float2 = (11, 4),\\n):\\n fig = plt.figure(figsize=figsize)\\n if sim.size[2] > 0.1 and sim.size[1] > 0.1:\\n gs = mpl.gridspec.GridSpec(1, 2, figure=fig, width_ratios=[1, 1.4])\\n ax1 = fig.add_subplot(gs[0, 0])\\n ax2 = fig.add_subplot(gs[0, 1])\\n if wavelength:\\n freq = td.constants.C_0 / wavelength\\n sim.plot_eps(z=z, ax=ax1, freq=freq)\\n sim.plot_eps(y=y, ax=ax2, freq=freq)\\n else:\\n sim.plot(z=z, ax=ax1)\\n sim.plot(y=y, ax=ax2)\\n elif sim.size[2] > 0.1: # 2D grating sim_size_y = 0\\n gs = mpl.gridspec.GridSpec(1, 1, figure=fig, width_ratios=[1])\\n ax1 = fig.add_subplot(gs[0, 0])\\n if wavelength:\\n freq = td.constants.C_0 / wavelength\\n sim.plot_eps(y=y, ax=ax1, freq=freq)\\n else:\\n sim.plot(y=y, ax=ax1)\\n\\n else: # 2D planar component size_z = 0\\n gs = mpl.gridspec.GridSpec(1, 1, figure=fig, width_ratios=[1])\\n ax1 = fig.add_subplot(gs[0, 0])\\n if wavelength:\\n freq = td.constants.C_0 / wavelength\\n sim.plot_eps(z=z, ax=ax1, freq=freq)\\n else:\\n sim.plot(z=z, ax=ax1)\\n\\n plt.show()\\n return fig\",\n \"def draw_plot(self):\\n # X axis is auto follow.\\n XLEN = 100\\n xmax = max(len(self.daq.data0), XLEN)\\n xmin = xmax - XLEN\\n\\n # The Y value will lie between 0.0 and 5.0 volts\\n ymax = 5.0\\n ymin = 0.0\\n\\n self.main_plot.set_xbound(lower=xmin, upper=xmax)\\n self.main_plot.set_ybound(lower=ymin, upper=ymax)\\n\\n # Add the grid. Grid looks cool and is actually very helpful.\\n self.main_plot.grid(True, color='gray')\\n\\n pylab.setp(self.main_plot.get_xticklabels(), \\n visible=True)\\n \\n self.plot_data.set_xdata(arange(len(self.daq.data0)))\\n self.plot_data.set_ydata(array(self.daq.data0))\\n \\n self.canvas.draw()\",\n \"def plot_xy(nc,params,tms,lev=None):\\n \\n import matplotlib.pyplot as plt\\n import ggWRFutils as gW\\n from datetime import datetime\\n import numpy as np\\n wvar={}\\n for p in params:\\n if p != 'Times':\\n if p=='WS10':\\n wvar[p]=np.sqrt(nc.variables['U10'][:]**2+nc.variables['U10'][:]**2)\\n elif p=='UV10': \\n wvar['U10']=nc.variables['U10'][:,:,:] \\n wvar['V10']=nc.variables['V10'][:,:,:] \\n elif p=='UV':\\n wvar['U']=nc.variables['U'][:,lev,:,:] \\n wvar['V']=nc.variables['V'][:,lev,:,:] \\n elif len(nc.variables[p].shape) > 3:\\n wvar[p]=nc.variables[p][:,lev,:,:] \\n else: \\n wvar[p]=nc.variables[p][:] \\n Nx,Ny,Nz,lon,lat,dx,dy=gW.getDimensions(nc)\\n for p in params:\\n if params[p]=='pcolor':\\n plt.pcolor(lon,lat,wvar[p][tms,:,:],shading='flat')\\n plt.colorbar()\\n if params[p]=='contourf':\\n plt.contourf(lon,lat,wvar[p][tms,:,:],50)\\n plt.colorbar()\\n if params[p]=='contour':\\n plt.contourf(lon,lat,wvar[p][tms,:,:])\\n plt.colorbar()\\n if params[p]=='quiver':\\n if p=='UV10':\\n plt.quiver(lon[::10,::10],lat[::10,::10],wvar['U10'][tms,::10,::10],wvar['V10'][tms,::10,::10],units='width')\\n elif p=='UV':\\n plt.quiver(lon,lat,wvar['U'][tms,:,:],wvar['V'][tms,:,:])\\n plt.hold(True)\\n plt.xlim(lon.min(),lon.max())\\n plt.ylim(lat.min(),lat.max())\\n fig=plt.gcf()\\n return fig\",\n \"def plot(self, *, ax=..., n_cols=..., line_kw=..., contour_kw=...):\\n ...\",\n \"def plots(x_bef,y_bef,z_bef):\\r\\n # Makes a 3-D plot of the x, y and z axes representing the ball's total trajectory\\r\\n plt.figure(3)\\r\\n plot3 = plt.axes(projection=\\\"3d\\\")\\r\\n plot3.plot3D(x_bef,y_bef,z_bef,'blue')\\r\\n plot3.set_xlabel('x (ft)')\\r\\n plot3.set_ylabel('y (ft)')\\r\\n plot3.set_zlabel('z (ft)')\\r\\n plot3.set_title('Total Trajectory')\\r\\n \\r\\n # Makes a 2-D plot of the x, and z axes representing the ball's total 2-D trajectory\\r\\n plt.figure(4)\\r\\n plt.plot(x_bef,z_bef)\\r\\n plt.xlabel('x (ft)')\\r\\n plt.ylabel('z (ft)')\\r\\n plt.title('z (ft) vs x (ft)')\\r\\n plt.show()\",\n \"def plot(self):\\n\\t\\tself.plotOfSpect().plot()\",\n \"def plot(self, num_levels=5):\\n Schrodinger1D.plot(self, num_levels)\\n xlabel('Electron height, z (nm)')\\n ylabel('Energy (GHz)')\\n mine = amin(self.energies(num_levels))\\n maxe = amax(self.energies(num_levels))\\n ylim(mine - (maxe - mine) * .5, maxe + (maxe - mine) * .5)\",\n \"def plot(self, fig=None, ax=None):\\n\\n self._plot_setup(fig, ax)\\n\\n if self.stokes == 'v':\\n self.cmap = plt.cm.coolwarm\\n\\n absmax = max(self.data.max(), self.data.min(), key=abs)\\n rms = np.sqrt(np.mean(np.square(self.data)))\\n\\n logger.debug(f\\\"Max flux in cutout: {absmax:.2f} mJy.\\\")\\n logger.debug(f\\\"RMS flux in cutout: {rms:.2f} mJy.\\\")\\n\\n self.im = self.ax.imshow(self.data, cmap=self.cmap, norm=self.norm)\\n\\n if self.options.get('bar', True):\\n try:\\n self.fig.colorbar(self.im, label=r'Flux Density (mJy beam$^{-1}$)', ax=self.ax)\\n except UnboundLocalError:\\n logger.error(\\\"Colorbar failed. Upgrade to recent version of astropy \\\")\\n\\n if self.options.get('psf'):\\n self.add_psf()\\n\\n self.add_source_ellipse()\",\n \"def plot(x, y, z):\\n pylab.plot(x, y)\\n pylab.plot(x, z)\\n pylab.show()\",\n \"def _xy_plot(cube, x_coord=None, reg_line=False, **plot_kwargs):\\n plot_kwargs = deepcopy(plot_kwargs)\\n if reg_line:\\n if plot_kwargs.get('linestyle', '-') == '-':\\n plot_kwargs.setdefault('marker', 'o')\\n else:\\n plot_kwargs.setdefault('marker', 's')\\n plot_kwargs['linestyle'] = 'none'\\n plot_kwargs.setdefault('markersize', 3)\\n if x_coord is None:\\n iris.plot.plot(cube, **plot_kwargs)\\n if cube.coords(dim_coords=True):\\n coord = cube.coord(dim_coords=True)\\n x_data = coord.points\\n else:\\n coord = None\\n x_data = np.arange(cube.shape[0])\\n else:\\n coord = cube.coord(x_coord)\\n iris.plot.plot(coord, cube, **plot_kwargs)\\n x_data = coord.points\\n if not reg_line:\\n return\\n plot_kwargs['linestyle'] = '-'\\n plot_kwargs['marker'] = None\\n plot_kwargs.pop('label', None)\\n y_data = cube.data\\n reg = linregress(x_data, y_data)\\n y_reg = reg.slope * x_data + reg.intercept\\n plt.plot(x_data, y_reg, **plot_kwargs)\",\n \"def __plot(name, x, y):\\n import matplotlib.pyplot as plt\\n\\n plt.plot(x, y)\\n plt.xlabel('elements')\\n plt.ylabel('time (seconds)')\\n plt.savefig(\\\"{}\\\".format(name))\",\n \"def plot(self):\\n\\t\\tself.plotOfSpect()\",\n \"def plot(self, x_unit='ft', y_unit='psi'):\\n\\n #Find the grid centers (where the solution exists)\\n x_pos = np.cumsum(self.dx_arr) - self.dx_arr[0] / 2.0\\n\\n #Loop over all stored solutions and plot stair-step line (because\\n #pressure is constant over grid block). We skip the first stored values\\n #because they are just the initialization values.\\n plt.figure()\\n for P in self.P_plot:\\n plt.plot(x_pos, P)\\n\\n #Labels, etc.\\n plt.xlabel('Reservoir position (' + x_unit + ')')\\n plt.ylabel('Pressure (' + y_unit + ')')\\n plt.xlim([0, self.res_length])\\n plt.show()\",\n \"def plot_xy(self, subplot = None, center_of_gravity = False, marker = \\\"b-\\\"):\\n if subplot is None:\\n plot = plt.subplot(111)\\n\\n for mass in self.flatten():\\n x,y = mass.geometry.project_xy.plot_coordinates\\n subplot.plot(x, y, marker)\\n\\n if center_of_gravity:\\n x, y, _ = mass.center_of_gravity_global.as_tuple()\\n subplot.plot(x, y,\\\"*\\\")\\n\\n x, y, _ = self.center_of_gravity_global.as_tuple()\\n subplot.plot(x, y, \\\"o\\\")\\n\\n return subplot\",\n \"def plotSpectrum(self,wavelengths,intensities = 1.0):\\n\\n fieldAngle,spectralOutput = self.getIntensitySpectum(wavelengths,intensities)\\n\\n # Do the actual plot\\n plot(np.degrees(fieldAngle),spectralOutput)\\n grid()\\n title(\\\"Spectral plot\\\")\\n xlabel(\\\"Angle in degrees\\\")\\n ylabel(\\\"Intensty\\\")\",\n \"def show():\\n\\tplt.show()\",\n \"def show_plot(segment_times, sample_freqs, spec, wave, wav_data, vad_feat):\\n plt.subplot(3, 1, 1)\\n plt.pcolormesh(segment_times, sample_freqs, 10*np.log10(spec), cmap='jet')\\n plt.ylabel('Frequency [Hz]')\\n plt.xlabel('Time [sec]')\\n\\n plt.subplot(3,1,2)\\n axes = plt.gca()\\n axes.set_xlim([0, wave.duration])\\n tmp_axis = np.linspace(0, wave.duration, wav_data.shape[0])\\n plt.plot(tmp_axis, wav_data/np.abs(np.max(wav_data)))\\n plt.xlabel('Time [sec]')\\n\\n plt.subplot(3,1,3)\\n axes = plt.gca()\\n axes.set_xlim([0, wave.duration])\\n tmp_axis = np.linspace(0, wave.duration, vad_feat.shape[0])\\n plt.plot(tmp_axis, vad_feat)\\n plt.xlabel('Time [sec]')\\n\\n plt.savefig('test', bbox_inches='tight')\",\n \"def make_plot(x,y):\",\n \"def generate_plot(self):\\r\\n\\t\\tx, y = zip(*[p.p for p in self.universe])\\r\\n\\t\\tself.ax.cla()\\r\\n\\t\\tself.ax.plot(x, y, '.')\\r\\n\\t\\tself.ax.set_title('Universe at time: %d' % self.universe.time)\\r\\n\\t\\tself.ax.set_xlim([P_MU-4*P_STD, P_MU+4*P_STD])\\r\\n\\t\\tself.ax.set_ylim([P_MU-4*P_STD, P_MU+4*P_STD])\",\n \"def show_graphs ():\\n plt.ylim = (0, 300)\\n plt.xlim = (0, 300)\\n #Set up lidar plot to figure 1\\n lidar_plot = plt.figure (1)\\n #Assign title\\n plt.title ('Lidar data')\\n #Assign data\\n plt.imshow (lidar_clean)\\n #Set up radar plot to figure 2\\n radar_plot = plt.figure (2)\\n #Assign title\\n plt.title ('Radar data')\\n #Assign data\\n plt.imshow (radar_clean)\\n #Show plots\\n plt.show ()\",\n \"def plot_x(t, x):\\n plt.figure()\\n plt.plot(t, x)\\n plt.title(\\\"Vertical position of the skydiver as a function of time\\\")\\n plt.xlabel(\\\"Time t [s]\\\")\\n plt.ylabel(\\\"Height [m]\\\")\\n plt.savefig('Parachute_position.png')\",\n \"def plot(self, *args, **kwargs):\\n raise NotImplementedError\",\n \"def show_plot(self):\\r\\n\\t\\tself.generate_plot()\\r\\n\\t\\tplt.show()\",\n \"def show():\\n setup()\\n plt.show()\",\n \"def view(self, lo_en: Quantity = Quantity(0.0, \\\"keV\\\"), hi_en: Quantity = Quantity(30.0, \\\"keV\\\"),\\n figsize: Tuple = (8, 6)):\\n if lo_en > hi_en:\\n raise ValueError(\\\"hi_en cannot be greater than lo_en\\\")\\n else:\\n lo_en = lo_en.to(\\\"keV\\\").value\\n hi_en = hi_en.to(\\\"keV\\\").value\\n\\n if len(self._plot_data.keys()) != 0:\\n # Create figure object\\n plt.figure(figsize=figsize)\\n\\n # Set the plot up to look nice and professional.\\n ax = plt.gca()\\n ax.minorticks_on()\\n ax.tick_params(axis='both', direction='in', which='both', top=True, right=True)\\n\\n # Set the title with all relevant information about the spectrum object in it\\n plt.title(\\\"{n} - {o}{i} Spectrum\\\".format(n=self.src_name, o=self.obs_id, i=self.instrument.upper()))\\n for mod_ind, mod in enumerate(self._plot_data):\\n x = self._plot_data[mod][\\\"x\\\"]\\n # If the defaults are left, just update them to the min and max of the dataset\\n # to avoid unsightly gaps at the sides of the plot\\n if lo_en == 0.:\\n lo_en = x.min()\\n if hi_en == 30.0:\\n hi_en = x.max()\\n\\n # Cut the x dataset to just the energy range we want\\n plot_x = x[(x > lo_en) & (x < hi_en)]\\n\\n if mod_ind == 0:\\n # Read out the data just for line length reasons\\n # Make the cuts based on energy values supplied to the view method\\n plot_y = self._plot_data[mod][\\\"y\\\"][(x > lo_en) & (x < hi_en)]\\n plot_xerr = self._plot_data[mod][\\\"x_err\\\"][(x > lo_en) & (x < hi_en)]\\n plot_yerr = self._plot_data[mod][\\\"y_err\\\"][(x > lo_en) & (x < hi_en)]\\n plot_mod = self._plot_data[mod][\\\"model\\\"][(x > lo_en) & (x < hi_en)]\\n\\n plt.errorbar(plot_x, plot_y, xerr=plot_xerr, yerr=plot_yerr, fmt=\\\"k+\\\", label=\\\"data\\\", zorder=1)\\n else:\\n # Don't want to re-plot data points as they should be identical, so if there is another model\\n # only it will be plotted\\n plot_mod = self._plot_data[mod][\\\"model\\\"][(x > lo_en) & (x < hi_en)]\\n\\n # The model line is put on\\n plt.plot(plot_x, plot_mod, label=mod, linewidth=1.5)\\n\\n # Generate the legend for the data and model(s)\\n plt.legend(loc=\\\"best\\\")\\n\\n # Ensure axis is limited to the chosen energy range\\n plt.xlim(lo_en, hi_en)\\n\\n plt.xlabel(\\\"Energy [keV]\\\")\\n plt.ylabel(\\\"Normalised Counts s$^{-1}$ keV$^{-1}$\\\")\\n\\n ax.set_xscale(\\\"log\\\")\\n ax.xaxis.set_major_formatter(ScalarFormatter())\\n ax.xaxis.set_minor_formatter(FuncFormatter(lambda inp, _: '{:g}'.format(inp)))\\n ax.xaxis.set_major_formatter(FuncFormatter(lambda inp, _: '{:g}'.format(inp)))\\n\\n plt.tight_layout()\\n # Display the spectrum\\n plt.show()\\n\\n # Wipe the figure\\n plt.close(\\\"all\\\")\\n\\n else:\\n warnings.warn(\\\"There are no XSPEC fits associated with this Spectrum, you can't view it.\\\")\",\n \"def plot(self, param):\\n # process param to be lowercase and without spaces\\n param = str(param).lower().replace(\\\" \\\", \\\"\\\")\\n plt.ion() # enable interactive mode\\n\\n # making plot according to param\\n if param == \\\"illuminantenergy\\\": # energy of illuminant\\n self.illuminant.plot(\\\"energy\\\")\\n elif param == \\\"illuminantphotons\\\": # photons of illuminant\\n self.illuminant.plot(\\\"photons\\\")\\n elif param == \\\"srgb\\\": # srgb image of the scene\\n plt.imshow(self.srgb)\\n plt.show()\\n else:\\n raise(ValueError, \\\"Unknown parameter\\\")\",\n \"def plot(self, num_levels=10,**kwargs):\\n Schrodinger1D.plot(self, num_levels,**kwargs)\\n xlabel('$\\\\delta/2\\\\pi$')\\n ylabel('E/h (GHz)')\\n ylim(min(self.fluxonium_potential()),min(2*self.energies(num_levels)[-1],max(self.fluxonium_potential())))\\n title('(Ej=%.2f , El=%.2f , Ec=%.2f)GHz , ($\\\\Phi_J=%.2f $,$\\\\Phi_L=%.2f \\\\,) \\\\Phi_0$ ' % (self.Ej, self.El, self.Ec, self.phi,self.phiL))\",\n \"def plot(self, xminorticks = 250, yminorticks = 0.1,\\n show_lims = False, small = False, cumulative = False, return_figure=False,\\n *args, **kwargs):\\n\\n ## Check if there is something in the class to plot\\n if hasattr(self, \\\"wavelength\\\") and hasattr(self, \\\"throughput\\\"):\\n\\n utils.setup_plot_defaults()\\n if hasattr(self._wavelength_units, \\\"format\\\"):\\n if \\\"latex\\\" in self._wavelength_units.format:\\n xaxis_label_string = r'$\\\\textnormal{Wavelength, ' + self._wavelength_units.name + ' (}' + self._wavelength_units._format['latex'] +')$'\\n else:\\n xaxis_label_string = r'$\\\\textnormal{Wavelength, ' + self._wavelength_units.name + '}$'\\n\\n plot_label_string = r'$\\\\textnormal{' + self.filter_name.replace('_', '\\\\\\\\_') + '}$'\\n\\n yminorLocator = MultipleLocator(yminorticks)\\n xminorLocator = MultipleLocator(xminorticks)\\n\\n if not small:\\n fig = plt.figure(figsize=[8, 4])\\n else:\\n fig = plt.figure(figsize=[4, 2])\\n plt.rcParams['font.size'] = 10\\n\\n fig.subplots_adjust(left = 0.09, bottom = 0.13, top = 0.99,\\n right = 0.99, hspace=0, wspace = 0)\\n\\n ax1 = fig.add_subplot(111)\\n\\n if cumulative:\\n throughput = np.cumsum(self.throughput)/np.sum(self.throughput)\\n yaxis_label_string = r'$\\\\textnormal{Cumulative Throughput}$'\\n\\n else:\\n throughput = self.throughput\\n yaxis_label_string = r'$\\\\textnormal{Fractional Throughput}$'\\n\\n\\n if hasattr(self, \\\"_plot_colour\\\"):\\n ax1.plot(self.wavelength, throughput, color = self._plot_colour,\\n lw = 2, label = plot_label_string)\\n else:\\n ax1.plot(self.wavelength, throughput, lw = 2, label = plot_label_string)\\n\\n if show_lims:\\n try:\\n ax1.plot([self._upper_edge, self._upper_edge], [0,1] ,\\n lw = 1.5, alpha = 0.5, ls = ':',\\n color = colours.hex['batman'], zorder = 0, )\\n ax1.plot([self._lower_edge, self._lower_edge], [0,1] ,\\n lw = 1.5, alpha = 0.5, ls = ':',\\n color = colours.hex['batman'], zorder = 0, )\\n except:\\n print(\\\"Failed\\\")\\n\\n ax1.spines['top'].set_visible(True)\\n\\n ax1.set_xlabel(xaxis_label_string)\\n ax1.set_ylabel(yaxis_label_string)\\n\\n ax1.yaxis.set_minor_locator(yminorLocator)\\n ax1.xaxis.set_minor_locator(xminorLocator)\\n\\n ax1.legend(loc = 0)\\n\\n if return_figure:\\n return fig\\n\\n plt.show()\\n pass\\n else:\\n warnings.warn(\\\"Doesn't look like you have loaded a filter into the object\\\")\",\n \"def plot(self, inline=True, fname=None, show_colorbar=False):\\n color_norm = matplotlib.colors.Normalize(\\n vmin=self.decibel_limits[0], vmax=self.decibel_limits[1]\\n )\\n\\n plt.imshow(self.spectrogram[::-1], cmap=\\\"Greys\\\", norm=color_norm)\\n\\n # pick values to show on time and frequency axes\\n yvals = self.frequencies.round(-2).astype(int)\\n xvals = self.times.round(2)\\n y_idx = [int(ti) for ti in np.linspace(0, len(yvals), 8)]\\n y_idx[-1] -= 1\\n plt.yticks(len(yvals) - np.array(y_idx), yvals[y_idx])\\n x_idx = [int(ti) for ti in np.linspace(0, len(xvals), 6)]\\n x_idx[-1] -= 1\\n plt.xticks(x_idx, xvals[x_idx])\\n\\n # add axes labels\\n plt.ylabel(\\\"frequency (Hz): mel scale\\\")\\n plt.xlabel(\\\"time (sec)\\\")\\n\\n if show_colorbar:\\n plt.colorbar()\\n\\n # if fname is not None, save to file path fname\\n if fname:\\n plt.savefig(fname)\\n\\n # if not saving to file, check if a matplotlib backend is available\\n if inline:\\n if os.environ.get(\\\"MPLBACKEND\\\") is None:\\n warnings.warn(\\\"MPLBACKEND is 'None' in os.environ. Skipping plot.\\\")\\n else:\\n plt.show()\",\n \"def plotPowerSpectrum(self,l_edges,show_angle=True,angle_unit=u.arcmin,fig=None,ax=None,**kwargs):\\n\\n\\t\\tif not matplotlib:\\n\\t\\t\\traise ImportError(\\\"matplotlib is not installed, cannot plot the power spectrum!\\\")\\n\\n\\t\\t#Instantiate figure\\n\\t\\tif (fig is None) or (ax is None):\\n\\t\\t\\t\\n\\t\\t\\tself.fig,self.ax = plt.subplots()\\n\\n\\t\\telse:\\n\\n\\t\\t\\tself.fig = fig\\n\\t\\t\\tself.ax = ax\\n\\n\\t\\t#Calculate the power spectrum\\n\\t\\tl,Pl = self.powerSpectrum(l_edges)\\n\\n\\t\\t#Plot\\n\\t\\tself.ax.plot(l,l*(l+1.)*Pl/(2*np.pi),**kwargs)\\n\\t\\tself.ax.set_xscale(\\\"log\\\")\\n\\t\\tself.ax.set_yscale(\\\"log\\\")\\n\\n\\t\\t#Upper scale shows the angle\\n\\t\\tif show_angle:\\n\\t\\t\\tax_top = self.ax.twiny()\\n\\t\\t\\tax_top.set_xticks(self.ax.get_xticks())\\n\\t\\t\\tax_top.set_xlim(self.ax.get_xlim())\\n\\t\\t\\tax_top.set_xticklabels([\\\"{0:.2f}\\\".format(((2*np.pi/ell)*u.rad).to(angle_unit).value) for ell in self.ax.get_xticks()])\\n\\t\\t\\tax_top.set_xlabel(r\\\"$\\\\theta$({0})\\\".format(angle_unit.to_string()),fontsize=22)\\n\\n\\t\\t#Labels\\n\\t\\tself.ax.set_xlabel(r\\\"$\\\\ell$\\\",fontsize=22)\\n\\t\\tself.ax.set_ylabel(r\\\"$\\\\ell(\\\\ell+1)P_\\\\ell^{\\\\kappa\\\\kappa}/2\\\\pi$\\\",fontsize=22)\",\n \"def plot(self, num_levels=10,**kwargs):\\n Schrodinger1D.plot(self, num_levels,**kwargs)\\n xlabel('$\\\\delta/2\\\\pi$')\\n ylabel('E/h (GHz)')\\n ylim(min(self.flux_qubit_potential()),min(2*self.energies(num_levels)[-1],max(self.flux_qubit_potential())))\\n title('Ej=%.2f GHz, El=%.2f GHz, Ec=%.2f GHz, $\\\\Phi=%.2f \\\\, \\\\Phi_0$' % (self.Ej, self.El, self.Ec, self.phi))\",\n \"def plot_flux( source, ctr_freq, bandwidth, nchan, format1 = False, show = False, **kwargs ):\\n\\n freqs = psr_u.chan_to_freq( ctr_freq, bandwidth, nchan )\\n fluxes = []\\n for f in freqs:\\n flux = getFlux( f, source, format1 )\\n fluxes.append( flux )\\n\\n if show:\\n # Set up figure and axes\\n fig = plt.figure()\\n ax = fig.add_subplot( 111, facecolor = 'w' )\\n\\n xText = ax.set_xlabel( r\\\"Frequency (GHz)\\\" )\\n yText = ax.set_ylabel( r\\\"Flux (Jy)\\\" )\\n title = ax.set_title( r\\\"The change in flux (Jy) as a function of frequency (GHz)\\\" )\\n ax.plot( freqs, fluxes, **kwargs )\\n plt.show()\\n return ax\\n else:\\n return fluxes\",\n \"def plot_spectrum(self, sp1d, title=None, color='k'):\\n if title is not None:\\n self.set_title(title)\\n self.set_axis_label(''.join(['Wavelength [', sp1d.wunit.name, ']']),\\n 'x')\\n self.set_axis_label('Counts', 'y')\\n self.axplot.plot(sp1d.wlen, sp1d.counts, color)\\n self.axplot.axis('tight')\\n self.fig.canvas.draw()\\n return\",\n \"def plot(self, num_levels=10):\\n if num_levels == -1:\\n num_levels = len(self.energies())\\n print(self.energies(num_levels))\\n figure(figsize=(20, 5))\\n subplot(1, num_levels + 1, 1)\\n self.plot_potential()\\n #xlabel('$\\\\phi$')\\n for ii, psi2D in enumerate(self.get_2Dpsis(num_levels)):\\n subplot(1, num_levels + 1, ii + 2)\\n #imshow(psi2D.real,extent=(self.x[0],self.x[-1],self.y[0],self.y[-1]),interpolation=\\\"None\\\",aspect='auto')\\n imshow(psi2D.real, interpolation=\\\"None\\\", aspect='auto')\\n xlabel(ii)\",\n \"def plot(self, ax, x_coord):\\n self._plot_band(ax, x_coord)\\n self._plot_label(ax, x_coord)\",\n \"def _plot_robot(self):\\n try:\\n x = 200\\n y = 200\\n self.ax1.plot(x, y, marker='o', markersize=10, linestyle='None')\\n except Exception as err:\\n rospy.loginfo(err)\",\n \"def set_up(self):\\n self.h, = self.ax.plot(self.x, lw=2)\\n self.ax.set_ylim(0,100)\\n self.ax.set_xlim(0,100)\\n self.ax.title.set_text(self.config[\\\"title\\\"])\\n self.ax.set_xlabel(self.config[\\\"x_label\\\"])\\n self.ax.set_ylabel(self.config[\\\"y_label\\\"])\",\n \"def view(filename):\\n n, data, data_dB,sr,ch=inputwav(filename)\\n t=np.linspace(0,n/sr,n)\\n py.close()\\n fig, (ax1) = py.subplots(nrows=1) \\n ax1.plot(t[0:n:100],data[0:n:100],'k-',linewidth=1,label=filename)\\n ax1.legend(loc=1)\\n ax1.set_ylabel('Amplitude (Rel. Bit)')\\n ax1.set_xlabel('Time (s)')\",\n \"def plot(self):\\n self.plotsite()\\n self.plotbond()\\n plt.show()\",\n \"def our_plot(ax, event, plot_args, scale=1, limits=None):\\n _x = plot_args['x']\\n _y = plot_args['y']\\n ax.cla()\\n ax.plot(_x, _y, zorder=0, color='k', alpha=0.5)\\n ax.plot(_x + 200, _y, zorder=0, color='r', alpha=0.5)\\n if hasattr(event, 'xdata') and event is not None:\\n xmin, xmax, ymin, ymax = limits\\n deltax, deltay = xmax - xmin, ymax - ymin\\n\\n if event.xdata is not None and event.ydata is not None:\\n print(event.xdata, event.ydata, xmin, xmax, ymin, ymax, scale)\\n ax.set(xlim=[event.xdata - scale * deltax,\\n event.xdata + scale * deltax],\\n ylim=[event.ydata - scale * deltay,\\n event.ydata + scale * deltay])\\n ax.set_xticklabels([])\\n ax.set_yticklabels([])\\n ax.plot([event.xdata], [event.ydata], marker='+', color='k',\\n ms=20, alpha=0.25)\\n else:\\n ax.set(title='Press \\\"r\\\" to reset, \\\"z\\\" to undo last point')\\n\\n # plot coords\\n for it in range(len(newcoords)):\\n ax.scatter(*newcoords[it],\\n marker=r\\\"$ {} $\\\".format(it),\\n color='red', zorder=10)\\n for it in range(len(oldcoords)):\\n ax.scatter(*oldcoords[it],\\n marker=r\\\"$ {} $\\\".format(it),\\n color='black', zorder=10)\",\n \"def plot(\\n self,\\n color_map={\\n \\\"ex\\\": (1, 0.2, 0.2),\\n \\\"ey\\\": (1, 0.5, 0),\\n \\\"hx\\\": (0, 0.5, 1),\\n \\\"hy\\\": (0.5, 0.2, 1),\\n \\\"hz\\\": (0.2, 1, 1),\\n },\\n channel_order=None,\\n ):\\n\\n if channel_order is not None:\\n ch_list = channel_order()\\n else:\\n ch_list = self.channels\\n\\n n_channels = len(self.channels)\\n\\n fig = plt.figure()\\n fig.subplots_adjust(hspace=0)\\n ax_list = []\\n for ii, comp in enumerate(ch_list, 1):\\n try:\\n color = color_map[comp]\\n except KeyError:\\n color = (0, 0.4, 0.8)\\n if ii == 1:\\n ax = plt.subplot(n_channels, 1, ii)\\n else:\\n ax = plt.subplot(n_channels, 1, ii, sharex=ax_list[0])\\n self.dataset[comp].plot.line(ax=ax, color=color)\\n ax.grid(which=\\\"major\\\", color=(0.65, 0.65, 0.65), ls=\\\"--\\\", lw=0.75)\\n ax.grid(which=\\\"minor\\\", color=(0.85, 0.85, 0.85), ls=\\\"--\\\", lw=0.5)\\n ax.set_axisbelow(True)\\n if ii != len(ch_list):\\n plt.setp(ax.get_xticklabels(), visible=False)\\n\\n ax_list.append(ax)\",\n \"def plot_skyline_5578(fig_size,\\n flux_5578,\\n flux_5578_medfilt, show_plot=False):\\n fig, ax = plt.subplots(figsize=(fig_size, fig_size / 2.5))\\n ax.plot(flux_5578, alpha=0.5)\\n ax.plot(flux_5578_medfilt, alpha=1.0)\\n ax.set_ylabel(r\\\"Integrated flux of skyline 5578 $\\\\AA$\\\")\\n ax.set_xlabel(\\\"Fibre\\\")\\n p01 = np.nanpercentile(flux_5578, 1)\\n p99 = np.nanpercentile(flux_5578, 99)\\n ax.set_ylim(p01, p99)\\n ax.set_title(r\\\"Checking throughput correction using skyline 5578 $\\\\AA$\\\")\\n ax.tick_params(axis='both', which='minor')\\n if show_plot:\\n plt.show()\\n\\n return fig\",\n \"def plot_sine_evaluation(real_samples, fake_samples, idx, identifier):\\n ### frequency\\n seq_length = len(real_samples[0]) # assumes samples are all the same length\\n frate = seq_length\\n freqs_hz = np.fft.rfftfreq(seq_length)*frate # this is for labelling the plot\\n # TODO, just taking axis 0 for now...\\n w_real = np.mean(np.abs(np.fft.rfft(real_samples[:, :, 0])), axis=0)\\n w_fake = np.mean(np.abs(np.fft.rfft(fake_samples[:, :, 0])), axis=0)\\n ### amplitude\\n A_real = np.max(np.abs(real_samples[:, :, 0]), axis=1)\\n A_fake = np.max(np.abs(fake_samples[:, :, 0]), axis=1)\\n ### now plot\\n nrow = 2\\n ncol = 2\\n fig, axarr = plt.subplots(nrow, ncol, sharex='col', figsize=(6, 6))\\n # freq\\n axarr[0, 0].vlines(freqs_hz, ymin=np.minimum(np.zeros_like(w_real), w_real), ymax=np.maximum(np.zeros_like(w_real), w_real), color='#30ba50')\\n axarr[0, 0].set_title(\\\"frequency\\\", fontsize=16)\\n axarr[0, 0].set_ylabel(\\\"real\\\", fontsize=16)\\n axarr[1, 0].vlines(freqs_hz, ymin=np.minimum(np.zeros_like(w_fake), w_fake), ymax=np.maximum(np.zeros_like(w_fake), w_fake), color='#ba4730')\\n axarr[1, 0].set_ylabel(\\\"generated\\\", fontsize=16)\\n # amplitude\\n axarr[0, 1].hist(A_real, normed=True, color='#30ba50', bins=30)\\n axarr[0, 1].set_title(\\\"amplitude\\\", fontsize=16)\\n axarr[1, 1].hist(A_fake, normed=True, color='#ba4730', bins=30)\\n\\n fig.savefig('./experiments/plots/' + identifier + '_eval' + str(idx).zfill(4) +'.png')\\n plt.clf()\\n plt.close()\\n return True\",\n \"def plot_waveforms(data, name, title, directory_name):\\n plt.figure(figsize=(20, 10))\\n plt.plot(data)\\n plt.title(title)\\n plt.savefig('./' + directory_name + '/' + name)\\n pass\",\n \"def mplot(m, xlabel='', ylabel='', title='', custom=(7,7)):\\n lag = ps.lag_spatial(m.w, m.z)\\n fit = ps.spreg.OLS(m.z[:, None], lag[:,None])\\n\\n # Customize plot\\n fig = plt.figure(figsize=custom)\\n ax = fig.add_subplot(111)\\n\\n ax.set_xlabel(xlabel)\\n ax.set_ylabel(ylabel)\\n fig.suptitle(title)\\n\\n ax.scatter(m.z, lag, s=60, color='k', alpha=.6)\\n ax.plot(lag, fit.predy, color='r')\\n\\n ax.axvline(0, alpha=0.5)\\n ax.axhline(0, alpha=0.5)\\n\\n return fig\",\n \"def plot(self, *args, ax=None,\\n cmap_name='seismic', if_show=False, **kwargs):\\n import matplotlib.pylab as plt\\n\\n if ax is None:\\n ax = plt.gca()\\n plt.sca(ax)\\n\\n plt.imshow(\\n self, *args, cmap=plt.get_cmap(cmap_name),\\n extent=self.extent, **kwargs\\n )\\n\\n if if_show:\\n plt.colorbar(orientation='horizontal')\\n plt.show()\",\n \"def data2energy_plot(params, datadir, ylimmax='auto', plotBIND=False):\\n # get dirs\\n xypath = sorted(glob.glob(datadir + 'xyv/'))[0]\\n KLpath = sorted(glob.glob(datadir + 'KL/'))[0]\\n print 'found KL dir : ', KLpath\\n # list files\\n xyfiles = sorted(glob.glob(xypath + '*.txt'))\\n KLfiles = sorted(glob.glob(KLpath + '*.txt'))\\n # load setup\\n xy0file = sorted(glob.glob(datadir + 'xy.txt'))[0]\\n xyv0file = sorted(glob.glob(datadir + 'xyv0.txt'))[0]\\n\\n # Note the inversion of the naming system below!\\n # xy file is mesh, here stored as the variable xy0\\n xy0 = np.loadtxt(xy0file, delimiter=',', usecols=(0, 1))\\n\\n # xyv0 file is initial condition, store as xy and v, etc\\n xy = np.loadtxt(xyv0file, delimiter=',', usecols=(0, 1))\\n try:\\n '''Data is 5D (x,y,theta,phi,psi)'''\\n theta, phi, vx, vy, vtheta, vphi, vpsi = \\\\\\n np.loadtxt(xyv0file, delimiter=',', usecols=(2, 3, 5, 6, 7, 8, 9), unpack=True)\\n dimension = 5\\n except:\\n try:\\n '''Data is 3D'''\\n v0 = np.loadtxt(xyv0file, delimiter=',', usecols=(3, 4))\\n dimension = 3\\n except:\\n '''Data is 2D'''\\n v0 = np.loadtxt(xyv0file, delimiter=',', usecols=(2, 3))\\n dimension = 2\\n\\n NLfile = sorted(glob.glob(datadir + 'NL.txt'))[0]\\n NL = np.loadtxt(NLfile, dtype='int', delimiter=',')\\n # hfile = sorted(glob.glob(datadir+'h.txt'))[0]\\n # h = np.loadtxt(hfile)\\n h = params['h']\\n\\n # Load masses, from file, or else from params, or else define it as unity\\n if os.path.exists(datadir + 'Mm.txt'):\\n Mfile = sorted(glob.glob(datadir + 'Mm.txt'))[0]\\n Mm = np.loadtxt(Mfile)\\n print 'Loaded mass list from txt file...'\\n else:\\n try:\\n Mm = params['Mm']\\n print 'Loaded mass list from params dict...'\\n except:\\n Mm = np.ones_like(xy0[:, 0])\\n print 'le: WARNING: Could not find mass array, defined as unity...'\\n\\n # Calculate or load initial setup --> assumes KL at h=0 is same as initial\\n KL = np.loadtxt(KLfiles[0], delimiter=',')\\n BL = NL2BL(NL, KL)\\n bo = bond_length_list(xy0, BL)\\n\\n kL = KL2kL(NL, KL, BL) * params['k']\\n nzcount = np.count_nonzero(KL)\\n NP = len(xy0[:, 0])\\n print('NP = ' + str(NP))\\n\\n fig = plt.figure(1)\\n plt.clf()\\n if dimension < 5:\\n ax = plt.subplot(2, 1, 1)\\n ax2 = plt.subplot(2, 1, 2)\\n else:\\n ax = plt.subplot(4, 1, 1)\\n ax2 = plt.subplot(4, 1, 2)\\n ax3 = plt.subplot(4, 1, 3)\\n ax4 = plt.subplot(4, 1, 4)\\n\\n # Calc and plot initial vals\\n bU = potential_energy(xy, BL, bo, kL)\\n if dimension < 5:\\n KE = kinetic_energy(v0, Mm)\\n totE = bU + KE\\n else:\\n KE, KEvec, KE_bulk, T1, T2, T3, T4 = \\\\\\n kinetic_energy_rigidbody(theta, phi, vx, vy, vtheta, vphi, vpsi, Mm, params)\\n print 'KE = ', KE\\n # Gravitational potential energy\\n gU_v = Mm * params['g'] * params['l'] * np.cos(theta)\\n gU = np.sum(gU_v)\\n totE = bU + KE + gU\\n ax4.plot(-h, gU, 'g.') # label='Gravitational')\\n # ax3.plot(-h,totE-np.sum(0.5*params['I3']*(vpsi+vphi*np.cos(theta))**2),'k.')\\n\\n ax.plot(-h, totE - T4, 'k.') # ,label='Total')\\n ax3.plot(-h, bU, 'b.') # ,label='Elastic')\\n ax2.plot(-h, KE - T4, 'r.') # ,label='Kinetic')\\n ax2.plot(-h, T3, 'rx') # ,label='Kinetic')\\n\\n if plotBIND:\\n if 'BIND' in params:\\n if len(params['BIND']) > 0:\\n BIND = params['BIND']\\n fig2 = plt.figure(2)\\n plt.clf()\\n ax21 = plt.subplot(4, 1, 1)\\n ax22 = plt.subplot(4, 1, 2)\\n ax23 = plt.subplot(4, 1, 3)\\n ax24 = plt.subplot(4, 1, 4)\\n # ax.plot(-h,bU,'b.',label='Bulk Potential')\\n bulkIND = np.setdiff1d(np.arange(len(xy[:, 0])), BIND)\\n gU_bulk = np.sum(gU_v[bulkIND])\\n print 'bulkIND = ', bulkIND\\n print 'gU_particle4 = ', gU_bulk\\n totE_bulk = KE_bulk + bU + gU_bulk\\n ax21.plot(-h, totE_bulk, 's', color=[0.3, .3, .3])\\n ax22.plot(-h, KE_bulk, 's', color=[1.0, .5, .5]) # ,label='Bulk Kinetic')\\n ax23.plot(-h, bU, 'bs')\\n ax24.plot(-h, gU_bulk, 's', color=[0.5, 1.0, .5], markeredgecolor='none')\\n\\n ax21.set_ylabel('Total')\\n ax24.set_xlabel('time')\\n ax22.set_ylabel('Kinetic')\\n ax23.set_ylabel('Elastic')\\n ax24.set_ylabel('Gravitational')\\n\\n # make list of indices to plot\\n doall = range(0, len(xyfiles))\\n\\n print('Plotting energy vs t...')\\n for i in doall:\\n KL = np.loadtxt(KLfiles[i], delimiter=',')\\n iterind = (xyfiles[i].split('_')[-1]).split('.')[0]\\n t = float(iterind) * h\\n\\n if dimension < 5:\\n xy = np.loadtxt(xyfiles[i], delimiter=',', usecols=(0, 1))\\n v = np.loadtxt(xyfiles[i], delimiter=',', usecols=(2, 3))\\n KE = kinetic_energy(v, Mm)\\n else:\\n x, y, theta, phi = np.loadtxt(xyfiles[i], delimiter=',', usecols=(0, 1, 2, 3), unpack=True)\\n vx, vy, vtheta, vphi, vpsi = np.loadtxt(xyfiles[i], delimiter=',', usecols=(5, 6, 7, 8, 9), unpack=True)\\n xy = np.dstack((x, y))[0]\\n KE, KEvec, KE_bulk, T1, T2, T3, T4 = kinetic_energy_rigidbody(theta, phi, vx, vy, vtheta, vphi, vpsi, Mm,\\n params)\\n # Gravitational potential energy\\n gU_v = Mm * params['g'] ** params['l'] * np.cos(theta)\\n gU = np.sum(gU_v)\\n\\n # redo calculations of BL, bo, kL if bonds were cut\\n if np.count_nonzero(KL) != nzcount:\\n BL = NL2BL(NL, KL)\\n bo = bond_length_list(xy0, BL)\\n kL = KL2kL(NL, KL, BL) * params['k']\\n nzcount = np.count_nonzero(KL)\\n\\n if 'shrinkrate' in params:\\n if 'prestrain' in params:\\n bU = potential_energy(xy, BL, bo * (1. - params['prestrain'] - params['shrinkrate'] * t), kL)\\n else:\\n bU = potential_energy(xy, BL, bo * (1. - params['shrinkrate'] * t), kL)\\n else:\\n bU = potential_energy(xy, BL, bo, kL)\\n\\n if dimension < 5:\\n totE = bU + KE\\n else:\\n totE = bU + KE + gU\\n ax4.plot(t, gU, 'g.')\\n # ax3.plot(t,totE-np.sum(0.5*params['I3']*(vpsi+vphi*np.cos(theta))**2),'k.')\\n # ax3.plot(t,totE-np.sum(0.5*params['I3']*params['w3']**2),'k.')\\n\\n ax.plot(t, totE - T4, 'k.')\\n ax2.plot(t, KE - T4, 'r.')\\n # ax2.plot(t,T1,'ro') #,label='Kinetic')\\n # ax2.plot(t,T2,'r^') #,label='Kinetic')\\n # ax2.plot(t,T3,'rx') #,label='Kinetic')\\n ax3.plot(t, bU, 'b.')\\n\\n if plotBIND:\\n if 'BIND' in params:\\n if len(params['BIND']) > 0:\\n # ax.plot(-h,bU,'b.',label='Bulk Potential')\\n ax22.plot(t, KE_bulk, 's', color=[1.0, .5, .5], markeredgecolor='none') # 'Bulk Kinetic'\\n gU_bulk = np.sum(gU_v[bulkIND])\\n totE_bulk = KE_bulk + bU + gU_bulk\\n ax24.plot(t, gU_bulk, 's', color=[0.5, 1.0, .5], markeredgecolor='none')\\n ax23.plot(t, bU, 'bs')\\n ax21.plot(t, totE_bulk, 's', color=[0.5, .3, .3], markeredgecolor='none') # 'Bulk Total'\\n\\n title = 'Energy Conservation'\\n ax.set_title(title)\\n ax.set_ylabel(r'Total - $\\\\frac{I_3 \\\\omega_3^2}{2} $')\\n ax3.set_xlabel('time')\\n ax2.set_ylabel(r'Kinetic - $\\\\frac{I_3 \\\\omega_3^2}{2}$')\\n ax3.set_ylabel('Elastic')\\n\\n ax.set_xlim([-h, t])\\n ax2.set_xlim([-h, t])\\n ax3.set_xlim([-h, t])\\n\\n if dimension == 5:\\n ax4.set_ylabel('Gravitational')\\n ax4.set_xlim([-h, t])\\n ax3.set_xlabel('')\\n ax4.set_xlabel('time')\\n ax3.set_xticks([])\\n\\n # ylimit of first axis is either the last total energy or a large number\\n if ylimmax != 'auto':\\n ax.set_ylim(0, NP * ylimmax) # np.nanmin((totE,NP*ylimmax)))\\n print('ylim_max = ' + str(np.nanmin((totE, NP * ylimmax))))\\n\\n ax.set_xticks([])\\n ax2.set_xticks([])\\n\\n outname = datadir + 'Energy_vs_t.png'\\n plt.figure(1)\\n plt.savefig(outname)\\n\\n if plotBIND:\\n if 'BIND' in params:\\n if len(params['BIND']) > 0:\\n plt.figure(2)\\n ax21.set_xlim([-h, t])\\n ax22.set_xlim([-h, t])\\n ax23.set_xlim([-h, t])\\n ax24.set_xlim([-h, t])\\n\\n ax21.set_xticks([])\\n ax22.set_xticks([])\\n ax23.set_xticks([])\\n\\n outname = datadir + 'Energy_vs_t_BIND.png'\\n plt.savefig(outname)\\n\\n # ax.set_xlim([-h,5])\\n # ax2.set_xlim([-h,5])\\n # ax3.set_xlim([-h,5])\\n # ax4.set_xlim([-h,5])\\n #\\n # ax.set_xticks([])\\n # ax2.set_xticks([])\\n #\\n # outname = datadir+'Energy_vs_t_zoom.png'\\n # #plt.show()\\n # plt.figure(1)\\n # plt.savefig(outname)\",\n \"def builtin_plot(self, **kwargs):\\n self.gp.plot(**kwargs)\\n return\",\n \"def plot_couplingmatrix(self,lmax,nwins,show=True,fname=None):\\n figsize = mpl.rcParams['figure.figsize']\\n figsize[0] = figsize[1]\\n fig = plt.figure(figsize=figsize)\\n ax = fig.add_subplot(111)\\n coupling_matrix = self.get_couplingmatrix(lmax,nwins)\\n ax.imshow(coupling_matrix)\\n ax.set_xlabel('output power')\\n ax.set_ylabel('input power')\\n fig.tight_layout(pad=0.1)\\n\\n if show: plt.show()\\n if fname is not None:\\n fig.savefig(fname)\",\n \"def show(self):\\n lines, = pylab.plot(self.wavelengths, self.intensities)\\n return lines\",\n \"def show():\\n plt.show()\",\n \"def show():\\n plt.show()\",\n \"def show():\\n plt.show()\",\n \"def plot_zoom(ax, xlims):\\n\\n xmin, xmax, ymin, ymax = get_y_lims(ax, xlims)\\n ax.set_xlim(xmin, xmax)\\n ax.set_ylim(ymin, ymax)\\n\\n return ax\",\n \"def plot(axes, axis, values, c='chartreuse'):\\n a = axes[axis]\\n a.set_xlabel('time (s)')\\n x = np.array(range(len(values))) / 1000\\n dim = 'x' if axis == 0 else 'y' if axis == 1 else 'z'\\n a.set_title('-'.join([dim, 'acceleration']))\\n a.plot(x, values / 1000, c=c)\",\n \"def plot(self): \\n\\t\\txandy = sep_xy(self.start, self.end)\\n\\t\\tplt.plot(xandy[0], xandy[1], 'k-', lw=1, color='blue')\",\n \"def plot(self):\\n pass\",\n \"def peek(self, **kwargs):\\n\\n plt.figure()\\n axes = plt.gca()\\n data_lab=self.meta['OBS-FREQ'][0:2] + ' ' + self.meta['OBS-FREQ'][2:5]\\n axes.plot(self.data.index,self.data,label=data_lab)\\n axes.set_yscale(\\\"log\\\")\\n axes.set_ylim(1e-4,1)\\n axes.set_title('Nobeyama Radioheliograph')\\n axes.set_xlabel('Start time: ' + self.data.index[0].strftime(TIME_FORMAT))\\n axes.set_ylabel('Correlation')\\n axes.legend()\\n plt.show()\",\n \"def plot_powerlaw(self, **kwargs):\\n\\n if self.gamma is None:\\n self.exponent()\\n p = powerlaw.plot(exponent=-self.gamma,\\n xmax=self.max_deg, xmin=self.k_min,\\n **kwargs\\n )\\n pylab.show()\\n return p\",\n \"def _plot(self):\\r\\n fig = plt.figure()\\r\\n\\r\\n # Take out second component of intensity if needed\\r\\n # if self._vna.isTwoComponents():\\r\\n # intensitySimplified = []\\r\\n # for i in range(len(self._intensity)):\\r\\n # tempSet = []\\r\\n # for j in range(len(self._intensity[i])):\\r\\n # if (j%2) == 0:\\r\\n # tempSet.append(self._intensity[i][j])\\r\\n # intensitySimplified.append(tempSet)\\r\\n # for i in range(len(self._frequency)):\\r\\n # plt.plot(self._frequency[i],intensitySimplified[i],label=('%sv' % self._voltages[i][0]))\\r\\n # else:\\r\\n for i in range(len(self._frequency)):\\r\\n plt.plot(self._frequency[i],self._intensity[i],label=('%sv' % self._voltages[i][0]))\\r\\n plt.legend(loc='upper left')\\r\\n fig.suptitle('Intensity-Frequency with non-Constant Voltage', fontsize=18)\\r\\n plt.xlabel('Frequency (Hz)', fontsize=18)\\r\\n plt.ylabel('Intensity (dBm)', fontsize=16)\\r\\n\\r\\n # Save plot\\r\\n self._saveFig()\",\n \"def plot(self, x, y, mX = 1, mY = 1):\\n x = self.xy[x]\\n y = self.xy[y]\\n\\n # Find pareto front:\\n xp, yp = self.pareto_frontier(x,y, mX, mY)\\n\\n plt.plot(x, y, 'o')\\n plt.plot(xp, yp, '-')\\n plt.tight_layout()\\n plt.show()\",\n \"def showPlot1(title, x_label, y_label):\\n num_robot_range = range(1, 11)\\n times1 = []\\n times2 = []\\n for num_robots in num_robot_range:\\n print \\\"Plotting\\\", num_robots, \\\"robots...\\\"\\n times1.append(runSimulation(num_robots, 1.0, 20, 20, 0.8, 20, StandardRobot))\\n times2.append(runSimulation(num_robots, 1.0, 20, 20, 0.8, 20, RandomWalkRobot))\\n pylab.plot(num_robot_range, times1)\\n pylab.plot(num_robot_range, times2)\\n pylab.title(title)\\n pylab.legend(('StandardRobot', 'RandomWalkRobot'))\\n pylab.xlabel(x_label)\\n pylab.ylabel(y_label)\\n pylab.show()\",\n \"def plot_track_rigidbody(params, datadir, pp=4, zoom=None):\\n h = params['h']\\n\\n # get dirs\\n xypath = sorted(glob.glob(datadir + 'xyv/'))[0]\\n # list files\\n xyfiles = sorted(glob.glob(xypath + '*.txt'))\\n\\n plt.clf()\\n ax1 = plt.subplot(5, 1, 1)\\n ax2 = plt.subplot(5, 1, 2)\\n ax3 = plt.subplot(5, 1, 3)\\n ax4 = plt.subplot(5, 1, 4)\\n ax5 = plt.subplot(5, 1, 5)\\n doall = range(0, len(xyfiles))\\n for i in doall:\\n iterind = (xyfiles[i].split('_')[-1]).split('.')[0]\\n t = float(iterind) * h\\n\\n x, y, theta, phi, psi = np.loadtxt(xyfiles[i], delimiter=',', usecols=(0, 1, 2, 3, 4), unpack=True)\\n # vX,vY,vtheta,vphi,vpsi = np.loadtxt(xyfiles[i],delimiter=',', usecols=(5,6,7,8,9), unpack=True)\\n\\n ax1.plot(t, x[pp], 'k.')\\n ax2.plot(t, y[pp], 'r.')\\n ax3.plot(t, theta[pp], 'r.')\\n ax4.plot(t, phi[pp], 'r.')\\n ax5.plot(t, psi[pp], 'g.')\\n\\n title = 'Tracking Single Gyro'\\n ax1.set_title(title)\\n ax5.set_xlabel('time')\\n ax1.set_ylabel('X')\\n ax2.set_ylabel('Y')\\n ax3.set_ylabel(r'$\\\\theta$')\\n ax4.set_ylabel(r'$\\\\phi$')\\n ax5.set_ylabel(r'$\\\\psi$')\\n\\n ax1.set_xlim([-h, t])\\n ax2.set_xlim([-h, t])\\n ax3.set_xlim([-h, t])\\n ax4.set_xlim([-h, t])\\n ax5.set_xlim([-h, t])\\n\\n ax1.set_xticks([])\\n ax2.set_xticks([])\\n ax3.set_xticks([])\\n ax4.set_xticks([])\\n\\n outname = datadir + 'Track.png'\\n plt.savefig(outname)\\n\\n if zoom != None:\\n ax1.set_xlim([-h, zoom])\\n ax2.set_xlim([-h, zoom])\\n ax3.set_xlim([-h, zoom])\\n ax4.set_xlim([-h, zoom])\\n ax5.set_xlim([-h, zoom])\\n\\n outname = datadir + 'Track_zoom.png'\\n plt.savefig(outname)\",\n \"def display1(*args):\\n #----------*----------* # unpack\\n twiss_func = args[0]\\n lat_plot = args[3]\\n #-------------------- beta x,y & dispersion x\\n s = [twiss_func(i,'s') for i in range(twiss_func.nbpoints)]\\n bx = [twiss_func(i,'bx') for i in range(twiss_func.nbpoints)]\\n by = [twiss_func(i,'by') for i in range(twiss_func.nbpoints)]\\n dx = [twiss_func(i,'dx') for i in range(twiss_func.nbpoints)]\\n #-------------------- lattice viseo\\n vzero = [0. for i in range(lat_plot.nbpoints)] # zero line\\n vis_abszisse = [lat_plot(i,'s') for i in range(lat_plot.nbpoints)]\\n vis_ordinate = [lat_plot(i,'viseo') for i in range(lat_plot.nbpoints)]\\n #-------------------- figure frame\\n width=14; height=7.6\\n plt.figure(num=0,figsize=(width,height),facecolor='#eaecef',tight_layout=False)\\n\\n #-------------------- transverse X\\n splot111=plt.subplot(111)\\n splot111.set_title('beta functions')\\n plt.plot(s,bx, label=r'$\\\\beta_x$ [m]', color='red', linestyle='-') # beta x\\n plt.plot(s,by, label=r'$\\\\beta_y$ [m]', color='blue', linestyle='-') # beta y\\n plt.plot(s,dx, label=r'$\\\\eta_x$ [m]' , color='green',linestyle='-') # dispersion x\\n vscale=splot111.axis()[3]*0.25\\n viseoz = [x*vscale for x in vis_ordinate]\\n plt.plot(vis_abszisse,viseoz,label='',color='black')\\n plt.plot(vis_abszisse,vzero,color='black')\\n plt.legend(loc='lower right',fontsize='x-small')\",\n \"def visualize_signal(self):\\n plt.figure()\\n plt.title('Accelerometer Signal')\\n plt.plot(range(len(self.data)), self.data[1])\",\n \"def raster_plot(nucleus, label=None, **kwargs):\\r\\n\\r\\n # Get fireds data\\r\\n fireds = nucleus.historique['fired']\\r\\n\\r\\n # Build x-axis and y-axis data by looping through fireds\\r\\n xdata, ydata = [], []\\r\\n for x, fires in fireds.items():\\r\\n for y in fires:\\r\\n xdata.append(x)\\r\\n ydata.append(y)\\r\\n\\r\\n # Matplotlib\\r\\n fig = plt.figure()\\r\\n plt.plot(xdata, ydata, '|', **kwargs)\\r\\n plt.ylabel('Neuron indexes')\\r\\n plt.xlabel('time')\\r\\n if label is None and nucleus.label is None:\\r\\n plt.title('Raster plot')\\r\\n elif label is not None and nucleus.label is None:\\r\\n plt.title('Raster plot (%s)' % label)\\r\\n elif label is None and nucleus.label is not None:\\r\\n plt.title('Raster plot of %s' % nucleus.label)\\r\\n else:\\r\\n plt.title('Raster plot of %s (%s)' % (nucleus.label, label))\\r\\n\\r\\n return fig\",\n \"def plot(self, A = None):\\r\\n if A is not None: self.A = A\\r\\n self.im.set_data(self.A)\\r\\n self.ax.draw_artist(self.im)\\r\\n self.fig.canvas.blit(self.ax.bbox)\",\n \"def plot_linear(x_range, w, b):\\n\\tplt.plot(x_range, x_range * w + b)\",\n \"def plot_motion(x, y):\\n plt.xlabel(\\\"X Position (m)\\\")\\n plt.ylabel(\\\"Y Position (m)\\\")\\n plt.plot(x, y)\\n plt.show()\",\n \"def plot_3d(self, ax_3d: Axes3D, lims_x: array_like = (-1, 1), lims_y: array_like = (-1, 1), **kwargs) -> None:\\n X, Y, Z = self.to_mesh(lims_x, lims_y)\\n\\n ax_3d.plot_surface(X, Y, Z, **kwargs)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.68592244","0.6670617","0.6542144","0.65134996","0.6377094","0.62712955","0.62569517","0.6249064","0.6229926","0.61167306","0.60711694","0.60472214","0.60371035","0.60346633","0.60338837","0.5984468","0.59759843","0.5972779","0.59544533","0.5941109","0.5929436","0.59293425","0.59262824","0.5925206","0.59247416","0.5918899","0.5918604","0.5917219","0.5901537","0.5901438","0.5896284","0.58394396","0.5817318","0.5802223","0.57863396","0.57849044","0.5783956","0.5776572","0.57683015","0.57629925","0.57559645","0.5755866","0.57506996","0.5750452","0.57483095","0.57428026","0.5740073","0.5732571","0.572986","0.5729604","0.57252526","0.57030016","0.5693144","0.5678296","0.56722635","0.5671898","0.5671779","0.56712776","0.5667864","0.56618714","0.56615436","0.56505257","0.56500643","0.5633667","0.5630259","0.56289864","0.56288004","0.5623237","0.56141144","0.5608888","0.5605704","0.55992013","0.5597194","0.5581377","0.5580386","0.5567166","0.55653244","0.55625916","0.55601645","0.55518025","0.5548981","0.55487573","0.55487573","0.55487573","0.55459696","0.55406684","0.55377847","0.5534389","0.5533307","0.553091","0.5525389","0.5524198","0.5523497","0.55234617","0.55169636","0.5512352","0.55034864","0.55009395","0.54886794","0.54875267","0.5485501"],"string":"[\n \"0.68592244\",\n \"0.6670617\",\n \"0.6542144\",\n \"0.65134996\",\n \"0.6377094\",\n \"0.62712955\",\n \"0.62569517\",\n \"0.6249064\",\n \"0.6229926\",\n \"0.61167306\",\n \"0.60711694\",\n \"0.60472214\",\n \"0.60371035\",\n \"0.60346633\",\n \"0.60338837\",\n \"0.5984468\",\n \"0.59759843\",\n \"0.5972779\",\n \"0.59544533\",\n \"0.5941109\",\n \"0.5929436\",\n \"0.59293425\",\n \"0.59262824\",\n \"0.5925206\",\n \"0.59247416\",\n \"0.5918899\",\n \"0.5918604\",\n \"0.5917219\",\n \"0.5901537\",\n \"0.5901438\",\n \"0.5896284\",\n \"0.58394396\",\n \"0.5817318\",\n \"0.5802223\",\n \"0.57863396\",\n \"0.57849044\",\n \"0.5783956\",\n \"0.5776572\",\n \"0.57683015\",\n \"0.57629925\",\n \"0.57559645\",\n \"0.5755866\",\n \"0.57506996\",\n \"0.5750452\",\n \"0.57483095\",\n \"0.57428026\",\n \"0.5740073\",\n \"0.5732571\",\n \"0.572986\",\n \"0.5729604\",\n \"0.57252526\",\n \"0.57030016\",\n \"0.5693144\",\n \"0.5678296\",\n \"0.56722635\",\n \"0.5671898\",\n \"0.5671779\",\n \"0.56712776\",\n \"0.5667864\",\n \"0.56618714\",\n \"0.56615436\",\n \"0.56505257\",\n \"0.56500643\",\n \"0.5633667\",\n \"0.5630259\",\n \"0.56289864\",\n \"0.56288004\",\n \"0.5623237\",\n \"0.56141144\",\n \"0.5608888\",\n \"0.5605704\",\n \"0.55992013\",\n \"0.5597194\",\n \"0.5581377\",\n \"0.5580386\",\n \"0.5567166\",\n \"0.55653244\",\n \"0.55625916\",\n \"0.55601645\",\n \"0.55518025\",\n \"0.5548981\",\n \"0.55487573\",\n \"0.55487573\",\n \"0.55487573\",\n \"0.55459696\",\n \"0.55406684\",\n \"0.55377847\",\n \"0.5534389\",\n \"0.5533307\",\n \"0.553091\",\n \"0.5525389\",\n \"0.5524198\",\n \"0.5523497\",\n \"0.55234617\",\n \"0.55169636\",\n \"0.5512352\",\n \"0.55034864\",\n \"0.55009395\",\n \"0.54886794\",\n \"0.54875267\",\n \"0.5485501\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":24991,"cells":{"query":{"kind":"string","value":"parse case excel file."},"document":{"kind":"string","value":"def manual_case_parser(self):\n data = self.excel_parser()\n result = self.process_module_field(data)\n self.add_class_name_field(result)\n self.process_multi_step_field(result)\n\n return result"},"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 test_parse_sample_sheet(self):\n pass","def parse_ra():\r\n fname = 'parse/File1.xlsx'\r\n sheet_name = 'Sheet1'\r\n\r\n ra_sheet = get_sheet(fname, sheet_name)\r\n return parse_sheet(ra_sheet)","def parse_xlsx(filename):\n from openpyxl import load_workbook\n\n workbook = load_workbook(filename=filename)\n worksheet = workbook.get_sheet_by_name(workbook.get_sheet_names()[0])\n row_it = worksheet.iter_rows()\n split_row_list = ([cell.value if cell.value is not None else \"\"\n for cell in row] for row in row_it)\n\n return parse_generic(split_row_list)","def read_xlsx(self, filename):\n xlsx = pd.ExcelFile(filename)\n for sheet in xlsx.sheet_names:\n table_index_header = cfg.get_list(\"table_index_header\", sheet)\n self.input_data[sheet] = xlsx.parse(\n sheet,\n index_col=list(range(int(table_index_header[0]))),\n header=list(range(int(table_index_header[1]))),\n squeeze=(\"series\" not in sheet),\n )\n self.check_input_data(warning=False)\n self.add_meta_data()\n return self","def parse(csv_file, xlsx_file):\n\n #Summary info\n no_dsa_pattern = r'\\((\\d+)/(\\d+)\\).*don\\'t have Deep Security installed'\n disable_ips_pattern = r'\\((\\d+)/(\\d+)\\).*don\\'t have Intrusion Prevention enabled'\n no_rule_pattern = r'\\((\\d+)/(\\d+)\\).*don\\'t have rules assigned'\n summary_patterns = re.compile('{}|{}|{}'.format(no_dsa_pattern, disable_ips_pattern, no_rule_pattern))\n no_dsa_count = None\n no_ips_count = None\n no_rule_count = None\n description = []\n summary = [[0, 0, 0], [0, 0, 0], [0, 0, 0]]\n\n #Detail info\n no_dsa_list_title = r\"Hosts that don't have Deep Security installed\"\n disable_ips_list_title = r\"Hosts that have Deep Security installed but don't have Intrusion Prevention enabled\"\n no_rule_list_title = r\"Hosts that have Intrusion Prevention enabled but no rules assigned\"\n title_patterns = re.compile('({})|({})|({})'.format(no_dsa_list_title, disable_ips_list_title, no_rule_list_title))\n no_dsa_list = []\n no_ips_list = []\n no_rule_list = []\n host_list = [\n no_dsa_list,\n no_ips_list,\n no_rule_list\n ]\n\n #Help url\n action_pattern = re.compile('\\[(.+)\\: (.+)\\]')\n action_list = []\n\n\n #Parse csv file\n with open(csv_file, 'r', newline='') as csv_file:\n rows = csv.reader(csv_file, quotechar='\"', delimiter=',', skipinitialspace=True)\n for index, row in enumerate(rows):\n if not row:\n continue\n\n if row[0].startswith('#'):\n description.append(row[0].replace('# ', ''))\n continue\n\n search = summary_patterns.search(row[0])\n if search:\n current_pattern = next((i for i, x in enumerate(search.groups()) if x), None)\n summary[int(current_pattern/2)] = ( int(search.group(current_pattern+1)), int(search.group(current_pattern+2)) - int(search.group(current_pattern+1)) )\n continue\n\n search = action_pattern.search(row[0])\n if search:\n action_list.append((search.group(1), search.group(2)))\n if len(action_list) == 4:\n break\n\n current_pattern = -1\n for index, row in enumerate(rows):\n if not row or re.match('None', row[0]):\n continue\n\n search = title_patterns.search(row[0])\n if search:\n current_pattern = next((i for i, x in enumerate(search.groups()) if x), None)\n continue\n\n if current_pattern == -1:\n continue\n host_list[current_pattern].append(row[0])\n\n no_dsa_count, no_ips_count, no_rule_count = summary\n\n #Write xlsx file\n workbook = xlsxwriter.Workbook(xlsx_file)\n summary_worksheet = workbook.add_worksheet('Summary')\n rawdata_worksheet = workbook.add_worksheet('Data')\n no_dsa_worksheet = workbook.add_worksheet(\"Hosts that don't have DS\")\n no_ips_worksheet = workbook.add_worksheet(\"Hosts that don't have IPS\")\n no_rule_worksheet = workbook.add_worksheet(\"Hosts that don't have rules\")\n\n #Rawdata worksheet\n data = [\n ['', 'Deep Security installed', 'Intrusion Prevention enabled', 'rules assigned'],\n ['Yes', no_dsa_count[1], no_ips_count[1], no_rule_count[1]],\n ['No', no_dsa_count[0], no_ips_count[0], no_rule_count[0]]\n ]\n rawdata_worksheet.write_column('A1', data[0], workbook.add_format({'bold': True}))\n rawdata_worksheet.write_column('B1', data[1])\n rawdata_worksheet.write_column('C1', data[2])\n\n #No DSA install worksheet\n no_dsa_worksheet.write_row(0, 0, [no_dsa_list_title])\n no_dsa_worksheet.write_column(1, 0, no_dsa_list)\n\n #No IPS enable worksheet\n no_ips_worksheet.write_row(0, 0, [disable_ips_list_title])\n no_ips_worksheet.write_column(1, 0, no_ips_list)\n\n #No Rule worksheet\n no_rule_worksheet.write_row(0, 0, [no_rule_list_title])\n no_rule_worksheet.write_column(1, 0, no_rule_list)\n\n #Summary worksheet\n chart = workbook.add_chart({'type': 'column', 'subtype': 'percent_stacked'})\n chart.add_series({\n 'name': '=Data!$B$1',\n 'categories': '=Data!$A$2:$A$4',\n 'values': '=Data!$B$2:$B$4',\n 'fill': {'color': '#21BC3B'}\n })\n chart.add_series({\n 'name': '=Data!$C$1',\n 'categories': '=Data!$A$2:$A$4',\n 'values': '=Data!$C$2:$C$4',\n 'fill': {'color': '#C22828'}\n })\n chart.set_title ({'name': 'Protected hosts'})\n chart.set_x_axis({\n 'name': 'Status',\n })\n\n chart.set_y_axis({\n 'major_unit' : 0.2,\n 'min' : 0,\n 'max' : 1\n })\n\n summary_worksheet.insert_chart('A1', chart)\n summary_worksheet.write_column('A16', description)\n for index, (text, url) in enumerate(action_list):\n summary_worksheet.write_url('A'+str(index+20), url, string = text)\n summary_worksheet.activate()\n\n workbook.close()","def Excel_Load_Data( self, ExcelFilename ):\n pass","def parse_tables_xlsx(inp):\n # --------------------------------------------------------------------------\n # Start\n # --------------------------------------------------------------------------\n raw_read = pd.read_excel(inp,sheet_name = None)\n indx = get_tab_index(raw_read)\n # --------------------------------------------------------------------------\n # Get the individual tables from the file\n # --------------------------------------------------------------------------\n tabdict = {}\n for i in indx['tab'].to_list():\n tabdict[i] = get_table_df(raw_read[i])\n # --------------------------------------------------------------------------\n # Finish\n # --------------------------------------------------------------------------\n out = {}\n out['indx'] = indx\n out['tabs'] = tabdict\n return out","def open_file(path):\n book = xlrd.open_workbook(path)\n # print number of sheets\n #print book.nsheets\n # print sheet names\n #print book.sheet_names()\n # get the first worksheet\n first_sheet = book.sheet_by_index(0)\n # read a row\n #print first_sheet.row_values(0)\n # read a cell\n cell = first_sheet.cell(1,0)\n #print cell\n #print cell.value\n # read a row slice\n #print first_sheet.row_slice(rowx=0,start_colx=0,end_colx=2)\n\n \"\"\"\n if Junipter.search_junipter_rule(first_sheet,1) == 0:\n print \"Juniper rule doesn't match\"\n else:\n print \"Juniper rule match\"\n \"\"\"\n\n \"\"\"\n if Mitac.search_mitac_rule(first_sheet,1) == 0:\n print \"Mitac rule doesn't match\"\n else:\n print \"Mitac rule match\"\n \"\"\"\n\n if Fabrinet.search_fabrinet_rule(first_sheet,3) == 0:\n print \"fabrinet rule doesn't match\"\n else:\n print \"fabrinet rule match\"","def parseSheet(self):\n self.log.info(\"Parsing {0} rows and {1} columns.\".format(self.rowns,self.colns))\n \n self.column_dimensions = {}\n self.property_dimensions = {}\n self.row_dimensions = {}\n self.rowhierarchy = {}\n\n # Get dictionary of annotations\n self.annotations = self.r_sheet.cell_note_map\n \n for i in range(0,self.rowns):\n self.rowhierarchy[i] = {}\n \n for j in range(0, self.colns):\n # Parse cell data\n self.source_cell = self.r_sheet.cell(i,j)\n self.source_cell_name = cellname(i,j)\n self.style = self.styles[self.source_cell].name\n self.cellType = self.getType(self.style)\n self.source_cell_qname = self.getQName(self.source_cell_name)\n \n self.log.debug(\"({},{}) {}/{}: \\\"{}\\\"\". format(i,j,self.cellType, self.source_cell_name, self.source_cell.value))\n\n # Try to parse ints to avoid ugly _0 URIs\n try:\n if int(self.source_cell.value) == self.source_cell.value:\n self.source_cell.value = int(self.source_cell.value)\n except ValueError:\n self.log.debug(\"(%s.%s) No parseable int\" % (i,j))\n\n \n # Parse annotation (if any)\n if self.config.get('annotations', 'enabled') == \"1\":\n if (i,j) in self.annotations:\n self.parseAnnotation(i, j)\n\n # Parse cell even if empty\n if self.cellType == 'Data':\n self.parseData(i, j)\n elif (self.cellType == 'HRowHeader') :\n self.updateRowHierarchy(i, j)\n elif self.cellType == 'ColHeader' :\n self.parseColHeader(i, j)\n elif self.cellType == 'RowProperty' :\n self.parseRowProperty(i, j)\n \n # If cell not empty, check for more types\n if not self.isEmpty(i,j) :\n #self.graph.add((self.namespaces['scope'][self.source_cell_qname],RDF.type,self.namespaces['tablink'][self.cellType]))\n #self.graph.add((self.namespaces['scope'][self.source_cell_qname],self.namespaces['tablink']['cell'],Literal(self.source_cell_name)))\n #self.graph.add((self.namespaces['scope'][self.source_cell_qname],self.namespaces['tablink']['col'],Literal(colname(j))))\n #self.graph.add((self.namespaces['scope'][self.source_cell_qname],self.namespaces['tablink']['row'],Literal(i+1)))\n #self.graph.add((self.namespaces['scope'][self.source_cell_qname] isrow row\n if self.cellType == 'Title' :\n self.parseTitle(i, j)\n \n elif self.cellType == 'RowHeader' :\n self.parseRowHeader(i, j)\n \n elif self.cellType == 'HRowHeader' :\n self.parseHierarchicalRowHeader(i, j)\n \n elif self.cellType == 'RowLabel' :\n self.parseRowLabel(i, j)\n \n # Add additional information about the hierarchy of column headers\n for value in self.column_dimensions.values():\n for index in range(1, len(value)):\n uri_sub = self.getColHeaderValueURI(value[:index+1])\n uri_top = self.getColHeaderValueURI(value[:index])\n self.graph.add((uri_sub, self.namespaces['tablink']['subColHeaderOf'], uri_top))\n self.graph.add((uri_sub, self.namespaces['tablink']['depth'], Literal(index)))\n self.graph.add((uri_top, self.namespaces['tablink']['depth'], Literal(index-1)))\n \n self.log.info(\"Done parsing...\")","def read_excel_file(self):\n self.df = pd.read_excel(str(self.file_path))\n self.data_mat=np.array(self.df).astype(float).transpose()","def parse_csv(filename):\n cases = []\n\n with open(filename) as file:\n # Read the rest of the lines\n for line in file:\n cases.append(Case(line))\n\n return cases","def getCaseData(filename):\n filename = filename\n casedata = pd.read_table(filename, sep=',', skiprows=3, parse_dates=True, \\\n infer_datetime_format=True, index_col=0, na_filter=False, \\\n names=[\"time\", \"value\", \"flag\"], true_values=['M'], false_values=[''])\n return casedata","def parse_xlsx_sheet(f, n=0):\n xl_file = pd.ExcelFile(f)\n dfs = xl_file.parse(xl_file.sheet_names[n], na_values=['n.a.', 'n.d.'])\n return dfs","def read_excel_file(self):\n self.df = pd.read_excel(str(self.file_path))\n self.data_mat=np.array(self.df).astype(float)","def parse_files(self):\n \"\"\" @param name: name of the file \"\"\"\n \"\"\" @type name: string \"\"\"\n df = pd.DataFrame()\n if not self.xlfnames:\n self.producer(\"THESS_ENV_CITYOFTHESS_DAILY_YEARLY_DATA_ERROR\", 'data source not found or cannot be open')\n logging.error('error happened: no excel files found')\n return False\n for fileName in self.xlfnames:\n try:\n xlfname = self.folder + '/' + fileName #\n xl = pd.ExcelFile(xlfname)\n except Exception as e:\n self.producer(\"THESS_ENV_CITYOFTHESS_DAILY_YEARLY_DATA_ERROR\",\n 'data source not found or cannot be open', e)\n return False\n try:\n # code for one file per sheet\n # for sheet in xl.sheet_names:\n # self.parse_sheet(xl,sheet)\n\n # code for one file for all\n for sheet in xl.sheet_names:\n df_tmp = self.parse_sheet_to_df(xl, sheet, df)\n df = df.append(df_tmp, ignore_index=True)\n except Exception as e:\n self.producer(\"THESS_ENV_CITYOFTHESS_DAILY_YEARLY_DATA_ERROR\", 'data source format is not as expected',\n e)\n return False\n return self.write_to_file(df)","def load_from_excel(self, excel_fp: str):\n # TODO:\n pass","def read_data(filename):\n \n # Iterate over all X-values. Y-values are stored in colummns of particular worksheet\n for x in range(0,13):\n\n wb = xlrd.open_workbook(filename)\n ws = wb.sheet_by_index(0)\n\n # This position of metadata doesn't change its relative position from sheet-to-sheet\n n_energy = int(ws.cell_value(1,3))\n n_iter = int(ws.cell_value(4,3))\n Rows_to_Skip = 15\n\n # Rename columns\n column_names = [str(x) for x in range(0,n_iter)]\n column_names.insert(0,'nan')\n column_names.insert(0,'KE')\n\n # Read data using pandas\n df_data = pd.read_excel(io = filename,\n sheet_name=x,\n skiprows = Rows_to_Skip,\n names = column_names,\n index_col='KE'\n )\n # Drop the second column as it is always supposed to be false\n df_data.drop(columns=df_data.columns[0],inplace=True)\n \n # Get x_data as the index \n x_array = np.array(df_data.index).reshape(len(df_data.index),1)\n \n # If we encounter first sheet\n if x==0:\n y = df_data.to_numpy()\n \n # Stack with the cummulative y built till now\n else:\n y = np.hstack((y, df_data.to_numpy()))\n \n # Ideally x_array should be (481, 1), and y should be (481, 169)\n return x_array, y","def start_parse(self, file_path, data=None):\n with open_xlsb(file_path) as wb:\n\n cols = []\n data_frame = []\n with wb.get_sheet(data) as sheet:\n for row in sheet.rows():\n l = [item.v for item in row]\n if not cols:\n cols = l\n data_frame.append(l)\n\n data_frame = pd.DataFrame(data_frame[1:], columns=data_frame[0])\n data = data_frame.to_dict(\"split\")[\"data\"]\n\n parsable = []\n for d in data:\n for i in d:\n if str(i) == \"nan\" and math.isnan(i):\n return None\n parsable.append(dict(zip(cols, d)))\n\n return json.dumps(parsable)","def import_data(self):\n\n self.worksheet = (\n xlrd.open_workbook(filename=self.source).sheet_by_index(0)\n )\n # Import conversion data from worksheet and store as scipy arrays\n self.T_exp = np.array(\n self.worksheet.col_values(0, start_rowx=4, end_rowx=None)\n ) + 273.15\n self.HCout_raw = np.array(\n self.worksheet.col_values(4, start_rowx=4, end_rowx=None)\n )\n self.HCin_raw = np.array(\n self.worksheet.col_values(8, start_rowx=4, end_rowx=None)\n )\n self.eta_exp = (\n (self.HCin_raw - self.HCout_raw) / self.HCin_raw\n )\n self.T_model = np.linspace(\n self.T_exp[0] - 50, self.T_exp[-1] + 50, 25\n )\n self.T_array = self.T_model","def readxl(df, file_name):\r\n print( 'reading the excel file') \r\n df = pd.read_excel(file_name, sheet_name = 'Sheet1')\r\n df.columns = [x.strip('/s+').lower().replace(' ','_').replace('.','_') for x in df.columns]\r\n print('list of columns of data frame ')\r\n print(df.columns)\r\n print('shape of data frame')\r\n print(df.shape)\r\n print('reading excel file completed')\r\n return(df)","def extract(self):\n \n print('Extracting Metrics data... ',end=''),\n self.df = pd.read_excel(self.file_path, index_col=0)\n print('Done')","def parse_cases(raw_data_file: str, source_id: str, source_url: str):\n with open(raw_data_file, \"r\") as f:\n reader = csv.DictReader(f, delimiter=\";\")\n for row in reader:\n if row[_CLASSIFICATION] == \"Confirmados\":\n try:\n case = {\n \"caseReference\": {\"sourceId\": source_id, \"sourceUrl\": source_url},\n \"location\": {\n \"query\": \", \".join(\n [row[_MUNICIPALITY], \"Espirito Santo\", \"Brazil\"]\n )\n },\n \"events\": convert_events(\n row[_DATE_CONFIRMED],\n row[_PCR],\n row[_SEROLOGICAL_METHOD1],\n row[_SEROLOGICAL_METHOD2],\n row[_SEROLOGICAL_METHOD3],\n row[_TEST_CLASS],\n row[_OUTCOME],\n row[_DATE_DEATH],\n row[_HOSPITALIZED]\n ),\n \"symptoms\": convert_symptoms(\n row[_HEADACHE],\n row[_SORE_THROAT],\n row[_FEVER],\n row[_COUGH],\n row[_DIARRHOEA],\n row[_DIFFICULTY_BREATHING]\n ),\n \"demographics\": convert_demographics(\n row[_GENDER], row[_AGE], row[_ETHNICITY], row[_HEALTHCARE_PROFESSIONAL]\n ),\n }\n case[\"preexistingConditions\"] = convert_preexisting_conditions(\n row[_LUNG], row[_KIDNEY], row[_DIABETES], row[_CARDIOVASCULAR], row[_OBESITY]\n )\n notes = convert_notes(\n row[_CORYZA],\n row[_SMOKER],\n row[_HOMELESS],\n row[_NEIGHBOURHOOD],\n row[_DISABILITY],\n row[_INTERNAL_TRAVEL],\n row[_INTERNATIONAL_TRAVEL],\n row[_SCHOOLING]\n )\n if notes:\n case[\"restrictedNotes\"] = notes\n yield case\n except ValueError as ve:\n raise ValueError(f\"error converting case: {ve}\")","def process_xlsx(content):\n data = {}\n workbook = xlrd.open_workbook(file_contents=content)\n worksheets = [w for w in workbook.sheet_names() if not w.startswith('_')]\n for worksheet_name in worksheets:\n if worksheet_name.startswith('_'):\n continue\n\n worksheet = workbook.sheet_by_name(worksheet_name)\n\n merged_cells = worksheet.merged_cells\n if len(merged_cells):\n raise MergedCellError(worksheet.name, merged_cells)\n\n worksheet.name = slughifi(worksheet.name)\n headers = make_headers(worksheet)\n worksheet_data = make_worksheet_data(headers, worksheet)\n data[worksheet.name] = worksheet_data\n return data","def process_data(self, excel_file, output_title):\n df = read_excel(excel_file)\n labels = df.columns.values.tolist()\n title = f\"{labels[1]} vs {labels[0]}\"\n data = []\n for label in labels:\n data.append(df[label].values.tolist())\n\n for callback in self.callbacks:\n callback(title, data, labels, output_title)","def get_xls(xls_name, sheet_name):\n cls = []\n # get xls file's path\n xlsPath = os.path.join(proDir, \"testFile\", 'case', xls_name)\n # open xls file\n file = open_workbook(xlsPath)\n # get sheet by name\n sheet = file.sheet_by_name(sheet_name)\n # get one sheet's rows\n nrows = sheet.nrows\n for i in range(nrows):\n if sheet.row_values(i)[0] != u'case_name':\n cls.append(sheet.row_values(i))\n return cls","def main():\n\n era = dt.datetime.now()\n\n parser = xlslisp_compile_argdoc()\n args = parser.parse_args()\n\n space = os.path.splitext(args.file)[0]\n\n # Import the Values of Sheets of one Xlsx File\n\n sheet_by_name = openpyxl.load_workbook(args.file, data_only=True)\n sheet_by_name_keys_list = sheet_by_name.sheetnames\n\n stderr_print(\n \"xlslisp: reading {} sheets from: {}\".format(\n len(sheet_by_name_keys_list), args.file\n )\n )\n\n # Option to quit early\n\n if not args.force:\n stderr_print(\n \"xlslisp.py: Xlsx imported, run again with --force to replace Csv's\"\n )\n\n sys.exit(1)\n\n # Visit each Sheet\n\n for (index, sheetname) in enumerate(sheet_by_name_keys_list):\n sheet = sheet_by_name[sheetname]\n\n csv_name = \"{space}-{dashed_sheet}.csv\".format(\n space=space, dashed_sheet=sheetname.replace(\" \", \"-\")\n ).lower()\n\n # Collect Rows of String Values\n\n csv_ragged_rows = list()\n for row_index in range(sheet.max_row):\n row_mark = 1 + row_index\n\n csv_cells = list()\n\n for col_index in range(sheet.max_column):\n cell = sheet.cell(1 + row_index, 1 + col_index)\n col_mark = cell.column_letter\n assert col_mark == excel_az_mark(col_index)\n\n if False:\n if (col_mark, row_mark) == (\"C\", 89):\n pdb.set_trace()\n\n csv_cells.append(cell.value)\n\n # Warn of trailing spaces\n\n if str(csv_cells[-1]).endswith(\" \"):\n stderr_print(\n \"xlslisp: Warning: \"\n \"could rstrip cell at: {!r}!{}{} {}\".format(\n sheetname, col_mark, row_mark, csv_cells[-1]\n )\n )\n\n csv_ragged_rows.append(csv_cells)\n\n # Format as rectangular Csv to please GitHub\n #\n # per GitHub > Rendering CSV and TSV data\n # flagging ragged as \"we can make this file beautiful and searchable\"\n #\n\n csv_rows = rows_complete(csv_ragged_rows, cell=None)\n\n charstream = io.StringIO()\n csv_writer = csv.writer(charstream)\n for csv_cells in csv_rows:\n csv_writer.writerow(csv_cells)\n\n charstream.seek(0)\n csv_chars = charstream.read()\n\n # Write the lines with local \"os.linesep\" line-ending's\n # specifically Not the mix of \"\\r\\n\" and \"\\n\" from multi-line Excel cells\n # but without rstrip'ping the lines # TODO: poor choice to skip rstrip?\n\n csv_lines = csv_chars.splitlines()\n csv_joined = \"\\n\".join(csv_lines) + \"\\n\"\n\n stderr_print(\n \"xlslisp: writing {} chars of {} rows to: {}\".format(\n len(csv_joined), sheet.max_row, csv_name\n )\n )\n\n with open(csv_name, \"w\") as csv_writing:\n csv_writing.write(csv_joined)\n\n now = dt.datetime.now()\n stderr_print(\"xlslisp: elapsed time of\", (now - era), \"since\", era)\n\n sys.exit(0)","def parse(instr):\n # TODO: a spreadsheet should really be an object and cellval a method\n global DATA, MESSAGES, CURRENT_ROW\n DATA = {}\n MESSAGES = []\n CURRENT_ROW = None\n\n updated = {}\n parse_gspreadsheet(instr, updated)\n # find header row: look for \"opportunity title\" (case insensitive)\n find_header_row('opportunity\\s*title')\n if not HEADER_ROW or not HEADER_STARTCOL:\n return len(MESSAGES), DATA, MESSAGES, [], []\n\n header_colidx = {}\n header_names = {}\n header_col = HEADER_STARTCOL\n while True:\n header_str = cellval(HEADER_ROW, header_col)\n if not header_str:\n break\n field_name = None\n header_str = header_str.lower()\n if header_str.find(\"title\") >= 0:\n field_name = \"OpportunityTitle\"\n elif header_str.find(\"organization\") >= 0 and \\\n header_str.find(\"sponsor\") >= 0:\n field_name = \"SponsoringOrganization\"\n elif header_str.find(\"description\") >= 0:\n field_name = \"Description\"\n elif header_str.find(\"skills\") >= 0:\n field_name = \"Skills\"\n elif header_str.find(\"location\") >= 0 and header_str.find(\"name\") >= 0:\n field_name = \"LocationName\"\n elif header_str.find(\"street\") >= 0:\n field_name = \"LocationStreet\"\n elif header_str.find(\"city\") >= 0:\n field_name = \"LocationCity\"\n elif header_str.find(\"state\") >= 0 or header_str.find(\"province\") >= 0:\n field_name = \"LocationProvince\"\n elif header_str.find(\"zip\") >= 0 or header_str.find(\"postal\") >= 0:\n field_name = \"LocationPostalCode\"\n elif header_str.find(\"country\") >= 0:\n field_name = \"LocationCountry\"\n elif header_str.find(\"start\") >= 0 and header_str.find(\"date\") >= 0:\n field_name = \"StartDate\"\n elif header_str.find(\"start\") >= 0 and header_str.find(\"time\") >= 0:\n field_name = \"StartTime\"\n elif header_str.find(\"end\") >= 0 and header_str.find(\"date\") >= 0:\n field_name = \"EndDate\"\n elif header_str.find(\"end\") >= 0 and header_str.find(\"time\") >= 0:\n field_name = \"EndTime\"\n elif header_str.find(\"contact\") >= 0 and header_str.find(\"name\") >= 0:\n field_name = \"ContactName\"\n elif header_str.find(\"email\") >= 0 or header_str.find(\"e-mail\") >= 0:\n field_name = \"ContactEmail\"\n elif header_str.find(\"phone\") >= 0:\n field_name = \"ContactPhone\"\n elif header_str.find(\"website\") >= 0 or header_str.find(\"url\") >= 0:\n field_name = \"URL\"\n elif header_str.find(\"often\") >= 0:\n field_name = \"Frequency\"\n elif header_str.find(\"days\") >= 0 and header_str.find(\"week\") >= 0:\n field_name = \"DaysOfWeek\"\n elif header_str.find(\"paid\") >= 0:\n field_name = \"Paid\"\n elif header_str.find(\"commitment\") >= 0 or header_str.find(\"hours\") >= 0:\n field_name = \"CommitmentHours\"\n elif header_str.find(\"age\") >= 0 and header_str.find(\"min\") >= 0:\n field_name = \"MinimumAge\"\n elif header_str.find(\"kid\") >= 0:\n field_name = \"KidFriendly\"\n elif header_str.find(\"senior\") >= 0 and header_str.find(\"only\") >= 0:\n field_name = \"SeniorsOnly\"\n elif header_str.find(\"sex\") >= 0 or header_str.find(\"gender\") >= 0:\n field_name = \"SexRestrictedTo\"\n elif header_str.find(\"volunteer appeal\") >= 0:\n field_name = None\n else:\n parser_error(\"couldn't map header '\"+header_str+\"' to a field name.\")\n if field_name != None:\n header_colidx[field_name] = header_col\n header_names[header_col] = field_name\n #print header_str, \"=>\", field_name\n header_col += 1\n\n if len(header_names) < 10:\n parser_error(\"too few fields found: \"+str(len(header_names)))\n\n data_startrow = 0\n\n # check to see if there's a header-description row\n header_desc = cellval(HEADER_ROW+1, HEADER_STARTCOL)\n if not header_desc:\n parser_error(\"blank row not allowed below header row\")\n else:\n header_desc = header_desc.lower()\n data_startrow = HEADER_ROW + 1\n if header_desc.find(\"Opportunity Title\") >= 0:\n data_startrow += 1\n\n\n # find the data\n CURRENT_ROW = data_startrow\n blankrows = 0\n numopps = 0\n addr_ar = []\n urls_ar = []\n\n if data_startrow == 0:\n MESSAGES = []\n MESSAGES.append('Spreadsheet appears to be empty')\n return len(MESSAGES), DATA, MESSAGES, [], []\n\n while True:\n blankrow = True\n #rowstr = \"row=\"+str(row)+\"\\n\"\n record = {}\n record['LastUpdated'] = '0000-00-00'\n for field_name in header_colidx:\n col = header_colidx[field_name]\n val = cellval(CURRENT_ROW, col)\n if val:\n blankrow = False\n else:\n val = \"\"\n #rowstr += \" \"+field_name+\"=\"+val+\"\\n\"\n record[field_name] = val\n key = 'R'+str(CURRENT_ROW)+'C'+str(col)\n if (key in updated and\n updated[key] > record['LastUpdated']):\n record['LastUpdated'] = updated[key]\n if blankrow:\n blankrows += 1\n if blankrows > MAX_BLANKROWS:\n break\n else:\n numopps += 1\n blankrows = 0\n record['oppid'] = str(numopps)\n get_minmaxlen(record, 'OpportunityTitle', 4, 100)\n get_minmaxlen(record, 'SpecialSkills', -1, 1000)\n location_name = get_minmaxlen(record, 'LocationName', 4)\n if location_name.lower() == \"virtual\":\n is_virtual = True\n else:\n is_virtual = False\n\n if is_virtual:\n reason = \" for virtual opportunities-- if you want both a location and\"\n reason += \" a virtual opportunity, then provide two separate records.\"\n get_blank(record, \"LocationStreet\", reason)\n get_blank(record, \"LocationCity\", reason)\n get_blank(record, \"LocationProvince\", reason)\n get_blank(record, \"LocationPostalCode\", reason)\n get_blank(record, \"LocationCountry\", reason)\n else:\n # TODO: appengine 30sec timeouts render this ambiguous/confuse for users\n addr = recordval(record, \"LocationStreet\")\n addr += \" \"+recordval(record, \"LocationCity\")\n addr += \" \"+recordval(record, \"LocationProvince\")\n addr += \" \"+recordval(record, \"LocationPostalCode\")\n addr += \" \"+recordval(record, \"LocationCountry\")\n addr_ar.append(addr)\n \n start_date = recordval(record, \"StartDate\").lower()\n if start_date == \"ongoing\":\n ongoing = True\n elif start_date == \"\":\n parser_error(\"Start Date may not be blank.\")\n ongoing = True\n else:\n ongoing = False\n\n if ongoing:\n start_time = recordval(record, \"StartTime\")\n if start_time != \"\" and start_time != \"ongoing\":\n parser_error(\"ongoing event should have blank Start Time.\")\n end_date = recordval(record, \"EndDate\")\n if end_date != \"\" and end_date != \"ongoing\":\n parser_error(\"ongoing event should have blank End Date.\")\n end_time = recordval(record, \"EndTime\")\n if end_time != \"\" and end_time != \"ongoing\":\n parser_error(\"ongoing event should have blank End Time.\")\n else:\n get_dtval(record, \"StartDate\")\n get_tmval(record, \"StartTime\")\n get_dtval(record, \"EndDate\")\n get_tmval(record, \"EndTime\")\n\n email = recordval(record, \"ContactEmail\")\n if email != \"\" and email.find(\"@\") == -1:\n parser_error(\"malformed email address: \"+email)\n\n url = recordval(record, \"URL\")\n if url == \"\":\n parser_error(\"Website - this field is required.\")\n urls_ar.append(url)\n \n daysofweek = recordval(record, \"DaysOfWeek\").split(\",\")\n for dow in daysofweek:\n lcdow = dow.strip().lower()\n if lcdow not in [\"sat\", \"saturday\",\n \"sun\", \"sunday\",\n \"mon\", \"monday\",\n \"tue\", \"tues\", \"tuesday\",\n \"wed\", \"weds\", \"wednesday\",\n \"thu\", \"thur\", \"thurs\", \"thursday\",\n \"fri\", \"friday\", \"\"]:\n # TODO: support these alternates in the datahub!\n parser_error(\"malformed day of week: '%s'\" % dow)\n get_boolval(record, \"Paid\")\n get_intval(record, \"CommitmentHours\")\n get_intval(record, \"MinimumAge\")\n get_boolval(record, \"KidFriendly\")\n get_boolval(record, \"SeniorsOnly\")\n sexrestrict = recordval(record, \"SexRestrictedTo\")\n if sexrestrict.lower() not in [\"women\", \"men\", \"either\", \"\"]:\n parser_error(\"bad SexRestrictedTo-- try Men, Women, Either or (blank).\")\n org = recordval(record, 'SponsoringOrganization')\n if org == \"\":\n parser_error(\"missing Sponsoring Organization-- this field is required.\"+\n \" (it can be an informal name, or even a person's name).\")\n else:\n get_minmaxlen(record, 'SponsoringOrganization', 4, 100)\n get_minmaxlen(record, 'Description', 15, 3000)\n freq = recordval(record, 'Frequency').lower()\n if not (freq == \"\" or freq == \"once\" or freq == \"daily\" or\n freq == \"weekly\" or freq == \"every other week\" or \n freq == \"monthly\"):\n parser_error(\"unsupported frequency: '\"+\n recordval(record, 'Frequency')+\"'\")\n CURRENT_ROW += 1\n\n return len(MESSAGES), DATA, MESSAGES, addr_ar, urls_ar","def setUp(self):\n wb = open_workbook(filename=self.filename)\n\n self.port_values = {}\n\n # find sheets that contain cash\n sheet_names = wb.sheet_names()\n for sn in sheet_names:\n if len(sn) > 4 and sn[-4:] == '-BOC':\n # print('read from sheet {0}'.format(sn))\n ws = wb.sheet_by_name(sn)\n read_cash(ws, self.port_values)","def test_from_file_xls(self):\n with TemporaryDirectory() as tmp:\n fp, df_test = save_simple_dataframe(tmp, 'test.xls')\n df_read = BaseDataClass.from_file(fp).df\n self.assertEqual(\n pd.testing.assert_frame_equal(df_test, df_read),\n None,\n )","def main(xls, seqtype):\n data_extraction = {}\n # 1 - Load data\n logger.info(f'Load {xls}')\n manifest, metadata = load_xls(xls)\n # 2 - Check file and data\n logger.info(f'Start to validate XLS')\n check_samples(manifest, metadata)\n check_seqtype(manifest, seqtype)\n check_metadata(metadata, seqtype)\n logger.success(f'Successfully validate XLS')\n # 3 - Export XLS to TSV for Qiime2\n logger.info(f'Start to export XLS to TSV')\n data_extraction = extract_manifest(manifest, seqtype, data_extraction)\n data_extraction, metadata_vars = extract_metadata(metadata, seqtype, data_extraction)\n export_to_tsv_for_qiime(data_extraction, metadata_vars, seqtype)\n logger.success(f'Done')","def parse_f_id():\r\n fname = 'parse/File2.xlsx'\r\n sheet_name = 'Sheet1'\r\n\r\n ran_sheet = get_sheet(fname, sheet_name)\r\n return parse_sheet(ran_sheet)","def read_in(path, projnum):\n\n is_xlsx = path.endswith('xlsx')\n if is_xlsx:\n data = pd.read_excel(path, header = 1)\n for i,r in data.iterrows():\n if r.isnull().all():\n rmv = i - 1\n break\n data = data.loc[:rmv]\n proj_name = pd.read_excel(path, skiprows = range(1, 10000)).columns[0]\n\n if not (proj_name and proj_name != 'Phase'):\n proj_name = ' '.join(path.split('/')[-1].split(' --- ')[0].split()[:-2])\n\n return data, proj_name\n else:\n data = pd.read_csv(path)\n if data.shape[1] == 1:\n data = pd.read_csv(path, sep = '\\t')\n\n # DEFAULT VALUES IF NECESSARY\n if 'Phase' not in data.columns:\n data['Phase'] = 'Base Bid'\n\n if 'Phase #' not in data.columns:\n data[\"Phase #\"] = 1\n\n if 'Form Method' not in data.columns:\n data[\"Form Method\"] = \"HP\"\n\n if 'Drafting ID' in data.columns:\n data.rename(columns = {'Drafting ID': 'Block ID'}, inplace = True)\n if 'Deleted' not in data.columns:\n data['Deleted'] = ''\n proj = [c for c in data.columns if 'Project #' in c]\n if proj:\n data.rename(columns = {proj[0]: 'Project #'}, inplace = True)\n if (data['Project #'] == '').all():\n data['Project #'] = 'TypeProjectNumberHere' if projnum == '-' else projnum\n\n else:\n data['Project #'] = 'TypeProjectNumberHere' if projnum == '-' else projnum\n \n\n return data","def __init__(self, infile, sheet, header=True, date_format=\"%Y-%m-%d\"):\n from openpyxl import load_workbook\n \n wb = load_workbook(infile, data_only=True, use_iterators=True, keep_vba=False)\n \n try:\n sheet = wb.worksheets[int(sheet)-1]\n \n except:\n for ws in wb.worksheets:\n if ws.title == sheet:\n sheet = ws\n break\n else:\n raise Exception(\"No worksheet named {0}\".format(sheet))\n \n self.iter = sheet.iter_rows()\n self.date_format = date_format\n \n if header:\n self.fieldnames = self.format_excel_row(self.iter.next())\n self.aliases = dict(zip(\n list(\"col{0}\".format(idx+1) for idx in xrange(len(self.fieldnames))),\n self.fieldnames))\n else:\n self.fieldnames = list(\"col{0}\".format(idx+1) for idx in xrange(len(sheet.columns))),\n self.aliases = None","def validate_file(self):\n filename = str(self.filename)\n self.is_error = False\n self.message = \"\"\n if not (filename.endswith('xls') or filename.endswith('xlsx') or filename.endswith('csv')):\n self.message += \"Please Import only '.xls' or '.xlsx' or '.csv' File.\"\n elif (filename.endswith('xls') or filename.endswith('xlsx')):\n column_list = ['id', 'quantity']\n\n wb = xlrd.open_workbook(\n file_contents=base64.decodestring(self.xls_file))\n sheet = wb.sheet_by_index(0)\n row = sheet.row_values(0)\n invalid_cols = []\n import pdb;pdb.set_trace()\n for key in row:\n key = key.encode('ascii', 'ignore')\n if key.lower() not in column_list:\n invalid_cols.append(key)\n if invalid_cols:\n self.message = \"Invalid Column Name %s\", ', '.join(\n invalid_cols)\n if not self.message:\n for i in range(1, sheet.nrows):\n row = sheet.row_values(i)\n firstrow = sheet.row_values(0)\n firstrow = [str(item).lower() for item in firstrow]\n product_obj = self.env['product.product'].search(\n [('id', '=', row[firstrow.index('id')])])\n if not row[firstrow.index('quantity')]:\n self.message += \"Enter Quantity In Your Excel File\"\n if not product_obj:\n self.message += \"Enter Valid Product Id In Your Excel File\"\n else:\n column_list = ['id', 'quantity']\n xls_file = base64.b64decode(self.xls_file)\n file_input = cStringIO.StringIO(xls_file)\n file_input.seek(0)\n rows = []\n delimeter = ','\n reader = csv.reader(file_input, delimiter=delimeter,\n lineterminator='\\r\\n')\n for row in reader:\n rows.append(row)\n firstrow = [str(item).lower() for item in rows[0]]\n match = [column for column in firstrow if column not in column_list]\n if match:\n self.message += \"Enter Valid Column Name\"\n if not self.message:\n for row in rows[1:]:\n rows[0] = [str(item).lower() for item in rows[0]]\n product_obj = self.env['product.product'].search(\n [('id', '=', row[rows[0].index('id')])])\n if not row[rows[0].index('quantity')]:\n self.message += \"Enter Quantity In Your Excel File\"\n if not product_obj:\n self.message += \"Enter Valid Product Id In Your Excel File\"\n\n if self.message:\n self.is_error = True\n if not self.is_error:\n self.is_validate = True\n return {\n 'res_id': self.id,\n 'view_id': self.env.ref('import_stock_inventory_drc.import_stock_inventory_view_wizard_form').ids,\n 'view_type': 'form',\n 'view_mode': 'form',\n 'res_model': 'stock.inventory.wizard',\n 'type': 'ir.actions.act_window',\n 'target': 'new'\n }","def test_read_xls_wrong_format(self):\r\n my_tape = Tape()\r\n non_excel_file = os.path.join(test_files_dir, 'not_excel_file.txt')\r\n my_tape.read_xls(non_excel_file)","def evaluer_case(sheet,case):\n\tvaleur_conv=convert_wb(sheet[case].value)\n\treturn eval(valeur_conv)","def nodes_data_excel_parser(excel_path,**kwargs):\n excel_parser_engine = kwargs.get(\"engine\",\"xlrd\")\n\n # Check if excel file exists\n if not excel_path or not os.path.isfile(excel_path):\n raise FileNotFoundError(\n \"Excel data file {} not found.\".format(excel_path)\n )\n\n xls = pd.ExcelFile(excel_path,engine=excel_parser_engine)\n\n try:\n # TODO for sheet in xls.sheet_names:\n # nodes_data[sheet] = xls.parse(sheet)\n nodes_data = {\n \"buses\": xls.parse(\"buses\").replace({np.nan:None}),\n \"commodity_sources\": xls.parse(\"commodity_sources\").replace({np.nan:None}),\n \"transformers\": xls.parse(\"transformers\").replace({np.nan:None}),\n \"transformers_chp\": xls.parse(\"transformers_chp\").replace({np.nan:None}),\n \"renewables\": xls.parse(\"renewables\").replace({np.nan:None}),\n \"demand\": xls.parse(\"demand\").replace({np.nan:None}),\n \"storages\": xls.parse(\"storages\").replace({np.nan:None}),\n \"powerlines\": xls.parse(\"powerlines\").replace({np.nan:None}),\n \"timeseries\": xls.parse(\"time_series\").replace({np.nan:None}),\n \"financial\":xls.parse(\"financial\").replace({np.nan:None})\n }\n except KeyError:\n err_msg = \"Excel file must contains: [buses, commodity_sources, transformers, renewables, demand, storages, powerlines, financial and timeseries].\\n\\\n The following sheets are found: {}\".format(xls.sheet_names)\n raise Exception(err_msg)\n\n # set datetime index\n nodes_data[\"timeseries\"].set_index(\"timestamp\", inplace=True)\n nodes_data[\"timeseries\"].index = pd.to_datetime(\n nodes_data[\"timeseries\"].index\n )\n\n logger.info(\"Data from Excel file {} imported in as nodes data.\".format(excel_path))\n\n return nodes_data","def parse_bloomberg_excel(filename, colnames_sheet, data_sheets, space=1,\n colnames=None, **kwargs):\n if isinstance(data_sheets, str):\n data_sheets = [data_sheets, ]\n flag_single_input = True\n else:\n flag_single_input = False\n\n # converter for date\n def converter(x):\n try:\n res = pd.to_datetime(x)\n except Exception:\n res = pd.NaT\n return res\n\n # colnames_sheet\n if colnames is None:\n colnames = pd.read_excel(filename, sheet_name=colnames_sheet, header=0)\n colnames = colnames.columns\n\n # float converters\n float_conv = {\n k: float for k in list(range(1, len(colnames)*(2+space), 2+space))\n }\n\n # if data_sheets is None, read in all sheets\n if data_sheets is None:\n data_dict_full = pd.read_excel(filename, sheet_name=None,\n converters=float_conv, verbose=True,\n **kwargs)\n\n # remove the sheet with colnames from this dict\n data_dict_full.pop(colnames_sheet, None)\n\n else:\n data_dict_full = pd.read_excel(filename, sheet_name=data_sheets,\n converters=float_conv, verbose=True,\n **kwargs)\n\n # loop over sheetnames\n all_data = dict()\n\n for s, data_df in data_dict_full.items():\n # loop over triplets, map dates, extract\n new_data_df = []\n for p in range((data_df.shape[1]+1)//(space+2)):\n # this triplet\n this_piece = data_df.iloc[1:, p*(space+2):(p+1)*(space+2)-space]\n\n # map date\n this_piece.iloc[:, 0] = this_piece.iloc[:, 0].map(converter)\n\n # drop nans (with dates)\n this_piece = this_piece.dropna()\n\n # extract date as index\n this_piece = this_piece.set_index(this_piece.columns[0])\n\n # rename\n this_piece.columns = [colnames[p]]\n this_piece.index.name = \"date\"\n\n # drop duplicates from the index\n this_piece = this_piece.loc[\n ~this_piece.index.duplicated(keep='first'), :]\n\n # store\n new_data_df += [this_piece, ]\n\n # concat\n all_data[s] = pd.concat(new_data_df, axis=1, join=\"outer\")\n\n # if only one sheet was asked for\n if flag_single_input:\n all_data = list(all_data.values())[0]\n\n return all_data","def read_excel(self):\r\n try:\r\n self.check_point_1 = True\r\n self.filename = tkFileDialog.askopenfilename(initialdir=\"/\", title=\"Select file\",\r\n filetypes=((\"excel files\", \"*.xlsx\"), (\"all files\", \"*.*\")))\r\n\r\n book = open_workbook(self.filename)\r\n\r\n if self.filename == '' or self.filename.split('/')[-1] != 'Engr Student Data.xlsx':\r\n self.check_point_1 = False\r\n if self.check_point_1 == True:\r\n self.headings = ['ID', 'Name', 'Section', 'Dept', 'GPA', 'MP1 Grade:', 'MP2 Grade:', 'MP3 Grade:',\r\n 'MT Grade:', 'Final Grade:']\r\n book = open_workbook(self.filename)\r\n sheet = book.sheet_by_index(0)\r\n for row_index in range(1, sheet.nrows):\r\n index = 0\r\n traits = []\r\n for column_index in range(sheet.ncols):\r\n traits.append(sheet.cell(row_index, column_index).value)\r\n self.student[sheet.cell(row_index, 1).value] = traits\r\n index += 1\r\n used_list = []\r\n for key in self.student:\r\n used_list.append(key)\r\n self.sort_list = sorted(used_list)\r\n for index in range(len(self.sort_list) - 1, -1, -1):\r\n single = self.sort_list[index].split(' ')\r\n if len(single) == 3:\r\n app.tree.insert(\"\", 0, text=int(self.student[self.sort_list[index]][0]),\r\n values=(single[:2], single[2]))\r\n continue\r\n app.tree.insert(\"\", 0, text=int(self.student[self.sort_list[index]][0]),\r\n values=(single[0], single[1]))\r\n app.info.configure(text=\"INFO: File Loaded.\")\r\n # If the user loaded the file properly, 'Info' Label should shows the message: 'INFO: File Loaded.'\r\n\r\n except (IOError, XLRDError):\r\n app.info.configure(text=\"INFO: Loading Failed! Please Try Again.\", font=('','7'))\r\n # If the user did not load the file properly,'Info' Label shows the message: 'INFO: Loading Failed! Please Try Again.'\r","def excel_fun_read(file_name, template_name, template_location, counter) :\r\n for list_number in range(1, 4) :\r\n inputWorkbook = xlrd.open_workbook(file_name)\r\n inputWorksheet = inputWorkbook.sheet_by_index(list_number)\r\n rows = inputWorksheet.nrows\r\n cols = inputWorksheet.ncols\r\n print(f'{rows} Rows in the file\\t') # <- get rows number starts from 0\r\n print(f'{cols} Cols in the file\\n') # <- get coloms number starts from 0\r\n dictionary = {1 : 'ATR', 2 : 'ESS Hot cycle 1', 3 : 'ESS Cold cycle 1', 4 : 'ESS Hot cycle 2',\r\n 5 : 'ESS Cold cycle 2'}\r\n if cols == 9 :\r\n print('next file')\r\n if cols == 12 or cols == 9 :\r\n cols = 8\r\n sub = 2\r\n else :\r\n cols = 12\r\n sub = 3\r\n for excel_row in range(1, sub) :\r\n sn = int(inputWorksheet.cell_value(0, cols))\r\n print(f'working on 000{sn}.xlsx') # <- Indicates which file is open\r\n TestLocation_list = [] # <- Creation of list\r\n PassFail_col_list = [] # <- Creation of list\r\n for i in range(rows) :\r\n # Follow the H colom check if there is 'PASS'/'FAIL' or empty cell\r\n # If empty cell skip it until the end of the excel file\r\n if inputWorksheet.cell_value(i, cols - excel_row) == 'PASS' or inputWorksheet.cell_value(i,\r\n cols - excel_row) == 'FAIL' or inputWorksheet.cell_value(\r\n i, cols - excel_row) == 'N/T' :\r\n TestLocation_list.append(i)\r\n PassFail_col_list.append(str(inputWorksheet.cell_value(i, cols - excel_row)))\r\n\r\n location_list, len_of_every_test_list = Create_2_lists_of_locations(TestLocation_list, list_number)\r\n pass_fail_list = sort_list_of_pass_and_fail(len_of_every_test_list, location_list, file_name, list_number,\r\n cols, PassFail_col_list, excel_row)\r\n\r\n # print(f'''It's the end of {list_number} in file 000{sn} excel_row = {excel_row}''')\r\n print(f'''It's the end of {dictionary.pop(counter)} in file 000{sn}\\n''')\r\n write_to_excel(sn, template_location, pass_fail_list, counter)\r\n counter += 1\r\n\r\n print('''it's the end of the loop''')","def __init__(self, filename=None, filetype=None, instrument=None):\n if filename:\n if instrument == 'Element':\n skipfooter = 4\n header = 1\n drop = 9\n elif instrument == 'Agilent':\n skipfooter = 4\n header = 3\n drop = 3\n else:\n skipfooter = 0\n header = 0\n drop = 0\n\n if filetype == 'xlsx':\n pwd = os.getcwd()\n os.chdir(os.path.dirname(filename))\n self.imported = pd.ExcelFile(filename)\n self.data = self.imported.parse(\n 0, index_col=0, skipfooter=skipfooter, header=header)\n self.data = self.data.drop(self.data.index[:drop], axis=0)\n os.chdir(pwd)\n # TODO xlsx doesnt work with agilent type\n elif filetype == 'csv':\n pwd = os.getcwd()\n os.chdir(os.path.dirname(filename))\n self.data = pd.read_csv(filename, sep=',', index_col=0, skipfooter=skipfooter,\n header=header, engine='python')\n os.chdir(pwd)\n elif filetype == 'asc':\n pwd = os.getcwd()\n os.chdir(os.path.dirname(filename))\n self.data = pd.read_csv(filename, sep='\\t', index_col=0, skipfooter=skipfooter,\n header=header, engine='python')\n self.data = self.data.drop(self.data.index[:drop], axis=0)\n self.data.dropna(axis=1, how='all', inplace=True)\n self.data = self.data.apply(pd.to_numeric, errors='coerce')\n os.chdir(pwd)\n else:\n warnings.warn('File type not supported.')\n\n self.data.index = self.data.index.astype('float32')\n self.time = self.data.index\n self.elements = list(map(elem_resolution, self.data.columns))\n self.data.columns = self.elements\n\n self.srms = pd.ExcelFile('./SRM.xlsx').parse(index_col=0)\n self.sum_koeficients = pd.ExcelFile(\n './default_sum_koef.xlsx').parse(0, index_col=0, header=None).to_dict()[1]\n\n self.srm = None\n self.iolite = None\n self.names = None\n self.internal_std = None\n self.ablation_time = None\n\n self.laser_off = []\n self.laser_on = []\n self.skip = {'bcg_start': 0,\n 'bcg_end': 0,\n 'sample_start': 0,\n 'sample_end': 0} # time in seconds to skip from each bcg and sample\n\n self.filter_line = None\n self.starts = None\n self.ends = None\n self.bcg = None\n self.average_peaks = None\n self.ratio = None\n self.quantified = None\n self.lod = None\n self.correction_elements = None\n self.corrected_IS = None\n self.corrected_SO = None\n\n self.dx = None\n self.dy = None\n self.maps = {}\n self.qmaps = {}\n\n self.regression_values = {}\n self.regression_equations = {}","def _read_workbook_2007(maldoc):\n\n # Read in the 2007+ cells.\n color_print.output('g', \"Analyzing Excel 2007+ file ...\")\n workbook_info = XLM.excel2007.read_excel_2007_XLM(maldoc) \n color_print.output('g', \"Extracted XLM from ZIP archive.\")\n if (workbook_info is None):\n return (None, None, None)\n if (len(workbook_info) == 0):\n color_print.output('y', \"WARNING: No XLM macros found.\")\n return (None, None, None)\n\n if debug:\n print(\"=========== START 2007+ CONTENTS ==============\")\n for sheet in workbook_info.keys():\n print(\"\\n------\")\n print(sheet)\n print(\"\")\n for c in workbook_info[sheet].keys():\n print(str(c) + \" ---> \" + str(workbook_info[sheet][c]))\n print(\"=========== DONE 2007+ CONTENTS ==============\")\n \n # Figure out which sheet probably has the XLM macros.\n xlm_sheet_name = None\n max_formulas = -1\n for sheet in workbook_info.keys():\n if (len(workbook_info[sheet]) > max_formulas):\n max_formulas = len(workbook_info[sheet])\n xlm_sheet_name = sheet\n\n # Parse each formula and add it to a sheet object.\n xlm_cells = {}\n for cell_index in workbook_info[xlm_sheet_name].keys():\n\n # Value only cell?\n row = cell_index[0]\n col = cell_index[1]\n if (row not in xlm_cells):\n xlm_cells[row] = {}\n raw_formula = workbook_info[xlm_sheet_name][cell_index][0]\n if (raw_formula is None):\n\n # Do we have a value?\n formula_val = workbook_info[xlm_sheet_name][cell_index][1]\n if (formula_val is not None):\n\n # Just save the value in the cell.\n xlm_cells[row][col] = formula_val\n continue\n \n # Parse the formula into an XLM object.\n formula_str = b\"=\" + raw_formula\n formula = XLM.ms_stack_transformer.parse_ms_xlm(formula_str)\n\n # Set the value of the formula if we know it.\n formula_val = workbook_info[xlm_sheet_name][cell_index][1]\n if (formula_val is not None):\n formula.value = formula_val\n\n # Save the XLM object.\n formula.update_cell_id(cell_index)\n xlm_cells[row][col] = formula\n color_print.output('g', \"Parsed MS XLM macros.\")\n \n # Merge the XLM cells with the value cells into a single unified spereadsheet\n # object.\n workbook, xlm_cell_indices, xlm_sheet = _merge_XLM_cells(maldoc, xlm_cells)\n if (workbook is None):\n color_print.output('r', \"ERROR: Merging XLM cells failed. Emulation aborted.\")\n return (None, None, None)\n \n # Done.\n return (workbook, xlm_cell_indices, xlm_sheet)","def parse():\n\n try:\n if \"excel_doc\" not in request.files:\n return bad_request()\n\n excel_doc = request.files[\"excel_doc\"]\n\n if not models.allowed_file(excel_doc.filename):\n return bad_request()\n\n file_path = models.save_excel_doc(excel_doc)\n\n students = models.parse_students(file_path)\n\n os.remove(file_path)\n except ValueError as e:\n return bad_request()\n except Exception as e:\n print(e)\n return server_error()\n\n return success(students)","def get_arterial(file_path,category):\n book = xlrd.open_workbook(file_path)\n file_name = os.path.basename(file_path)\n year = str(20) + \"\".join([str(s) for s in file_name if s.isdigit()]) ## gets the year from filename\n Month = strptime(file_name[2:5],'%b').tm_mon ## gets month no\n mydate = datetime.date(int(year),Month, 1) ## first day of the month and year\n mydate_1 = mydate - datetime.timedelta(days=1) ## interested in last month of this year as data corresponds to last month and same year\n mydate_2 = mydate - datetime.timedelta(days=368) ## interested in last month of last year as data corresponds to last month and last year \n #monthid1 = str(mydate_1.strftime(\"%Y\")) + str(mydate_1.strftime(\"%m\")) ## 200706 for July 2007 file\n monthid2 = str(mydate_2.strftime(\"%Y\")) + str(mydate_2.strftime(\"%m\")) ## 200606 for July 2007 file\n try:\n if category.lower() == \"rural\":\n index = 3\n elif category.lower() == \"urban\":\n index = 4\n else:\n index = 5\n sheet = book.sheet_by_index(index)\n list_states = sheet.col_values(0)\n xstart = list_states.index('Connecticut')\n xend = list_states.index('TOTALS')\n #list1 = sheet.col_slice(colx= 8,start_rowx=xstart,end_rowx= xend - 1)\n #list1 = [w.value for w in list1]\n list2 = sheet.col_slice(colx= 9,start_rowx=xstart,end_rowx= xend - 1)\n list2 = [w.value for w in list2]\n list3 = sheet.col_slice(colx= 0,start_rowx=xstart,end_rowx= xend - 1)\n list3 = [w.value.lower() for w in list3] ## take lowercase for direct match later\n df = pd.concat([pd.DataFrame(list3),pd.DataFrame(list2)], axis = 1) # ,pd.DataFrame(list1)\n #col_name_1 = category + '_Arterial_' + monthid1\n col_name_2 = category + '_Arterial_' + monthid2\n df.columns = ['State', col_name_2 ] # col_name_1, \n df[col_name_2].replace('', np.nan, inplace=True) ## removes rows with blank records ( zonal categories)\n df['State'].replace('', np.nan, inplace=True)\n curr_monthid = str(mydate.strftime(\"%Y\")) + str(mydate.strftime(\"%m\")) ## 200707 for July 2007 file\n df['data_monthid'] = curr_monthid\n df.dropna(subset=[col_name_2], inplace=True)\n df.dropna(subset=['State'], inplace=True)\n df = df[~df.State.str.contains(\"subtotal\")] ### causes problems on joins, there in most files\n df = df[df.State != \"total\"] ## causes problems on joins, is there only in specific files\n df['State'] = df.State.str.strip() ## removes leading and lagging white spaces if any\n df2 = pd.melt(df,id_vars=['State','data_monthid'],var_name=['category'], value_name='Million_Vehicle_Miles')\n return df2\n except:\n print(\"error in file \",os.path.basename(file_path))","def batch(self, xls):\n \n workbook = xlrd.open_workbook(xls)\n sheet = workbook.sheet_by_name(workbook.sheet_names()[0])\n self.headers = sheet.row(0)\n self.index = self._getHeaders([x.value for x in sheet.row(0)])\n self.__create_batch([self.parseRow(sheet.row(i)) \n for i in range(1, (sheet.nrows))])","def read_elia_imbalanceprices(filename,status):\r\n \r\n df = pd.read_excel(filename,skiprows=1,parse_dates=False)\r\n df[\"Timestamp\"] = df[\"Date\"]+\" \"+df['Quarter'].map(lambda x: str(x)[:-9])\r\n pd.to_datetime(df[\"Timestamp\"])\r\n df.set_index(\"Timestamp\",inplace=True)\r\n if ((status == \"validated\") | (status == \"valid\")):\r\n df = df.drop(df[df.Status != \"Validated\"].index)\r\n df = df.drop([\"Date\",\"Quarter\",\"Status\"], axis=1)\r\n \r\n if len(df.columns) == 3:\r\n df.columns.values[0:3] = [\"NRV in MW\",\"POS in euro/MWh\", \"NEG in euro/MWh\"]\r\n \r\n if len(df.columns) == 7:\r\n df.columns.values[0:7] = [\"NRV in MW\",\"SI in MW\",\"alpha in euro/MWh\",\"MIP in euro/MWh\", \"MDP in euro/MWh\",\"POS in euro/MWh\", \"NEG in euro/MWh\"]\r\n \r\n if len(df.columns) == 8:\r\n df.columns.values[0:8] = [\"NRV in MW\",\"SI in MW\",\"alpha in euro/MWh\",\"MIP in euro/MWh\", \"MDP in euro/MWh\",\"SR in euro/MWh\",\"POS in euro/MWh\", \"NEG in euro/MWh\"]\r\n\r\n return df","def read_data(self, filepath, agg_type):\n\n data = pd.read_excel(filepath)\n data['date'] = data.activity_date.apply(lambda x: x.date())\n data['year'] = data.date.apply(lambda x: x.year)\n data['month'] = data.date.apply(lambda x: x.month)\n data['week'] = data.date.apply(lambda x: x.strftime('%U'))\n data['dom'] = data.date.apply(lambda x: x.day)\n data['day'] = data.date.apply(lambda x: x.isoweekday())\n data['last_dom'] = data.date.apply(lambda x: calendar.monthrange(x.year, x.month)[1])\n data['is_last_dom'] = np.where(data.dom == data.last_dom, 1, 0)\n data['quarter'] = data.month.apply(lambda x: (x-1) // 3 + 1)\n data['is_last_day_of_quarter'] = np.where(((data.month == 3) & (data.dom == 31)) | ((data.month == 6) & (data.dom == 30)) |\n ((data.month == 9) & (data.dom == 30)) | ((data.month == 12) & (data.dom == 31)), 1, 0)\n return data","def parse_columns():\n # Fetch columns letters\n old_column_letter = get_old_numbers_column()\n new_columns_letters = get_new_numbers_columns()\n\n # Fetch old numbers\n old_column_cells = sheet[f'{old_column_letter}15':f'{old_column_letter}120']\n old_numbers_cells = []\n for ii in old_column_cells:\n if re.match('[0-9]{7}', str(ii[0].value)):\n old_numbers_cells.append(ii)\n print(old_numbers_cells)\n\n ##----- WORKING UNTIL HERE -----##\n \n # Fetch all new numbers (for each format)\n # Creates an array of arrays of cells ([[CellA, CellB], [CellC, CellD]])\n for ii in old_numbers_cells:\n new_numbers_cells_array = []\n for ij in new_columns_letters:\n new_columns_cells = [f'{ij}15', f'{ij}120']\n new_numbers_cells = []\n for jj in new_columns_cells:\n if re.search('[0-9]{7}'):\n new_numbers_cells.append(ii)\n new_numbers_cells_array.append(new_numbers_cells)\n\n # Combines all the cells :\n # Creates an array of tuples, easier to work with..\n work_tuples = []\n for ii in old_numbers_cells:\n # First we create an array..\n work_array = [int(ii.value)]\n # Then we fill it..\n for ij in new_numbers_cells_array:\n # Using the current position in the old cells array...\n work_array.append(ij[old_numbers_cells.index(ii)])\n # Finally, the array is parsed as a tuple and added to the list\n work_tuples.append(tuple(work_array))\n\n return work_tuples","def get_arterial(file_path,category):\n book = xlrd.open_workbook(file_path)\n file_name = os.path.basename(file_path)\n year = str(20) + \"\".join([str(s) for s in file_name if s.isdigit()]) ## gets the year from filename\n Month = strptime(file_name[2:5],'%b').tm_mon ## gets month no\n mydate = datetime.date(int(year),Month, 1) ## first day of the month and year\n #mydate_1 = mydate - datetime.timedelta(days=1) ## interested in last month of this year as data corresponds to last month and same year\n mydate_2 = mydate - datetime.timedelta(days=368) ## interested in last month of last year as data corresponds to last month and last year \n #monthid1 = str(mydate_1.strftime(\"%Y\")) + str(mydate_1.strftime(\"%m\")) ## 200706 for July 2007 file\n monthid2 = str(mydate_2.strftime(\"%Y\")) + str(mydate_2.strftime(\"%m\")) ## 200606 for July 2007 file\n try:\n if category.lower() == \"rural\":\n index = 3\n elif category.lower() == \"urban\":\n index = 4\n else:\n index = 5\n sheet = book.sheet_by_index(index)\n list_states = sheet.col_values(0)\n xstart = list_states.index('Connecticut')\n xend = list_states.index('TOTALS')\n #list1 = sheet.col_slice(colx= 6,start_rowx=xstart,end_rowx= xend - 1)\n #list1 = [w.value for w in list1]\n list2 = sheet.col_slice(colx= 7,start_rowx=xstart,end_rowx= xend - 1)\n list2 = [w.value for w in list2]\n list3 = sheet.col_slice(colx= 0,start_rowx=xstart,end_rowx= xend - 1)\n list3 = [w.value.lower() for w in list3] ## take lowercase for direct match later\n df = pd.concat([pd.DataFrame(list3),pd.DataFrame(list2)], axis = 1) # pd.DataFrame(list1),\n #col_name_1 = category + '_Arterial_' + monthid1\n col_name_2 = category + '_Arterial_' + monthid2\n df.columns = ['State', col_name_2 ] ## col_name_1,\n df[col_name_2].replace('', np.nan, inplace=True) ## removes rows with blank records ( zonal categories)\n df['State'].replace('', np.nan, inplace=True)\n curr_monthid = str(mydate.strftime(\"%Y\")) + str(mydate.strftime(\"%m\")) ## 200707 for July 2007 file\n df['data_monthid'] = curr_monthid\n df.dropna(subset=[col_name_2], inplace=True)\n df.dropna(subset=['State'], inplace=True)\n df = df[~df.State.str.contains(\"subtotal\")] ### causes problems on joins, there in most files\n df = df[df.State != \"total\"] ## causes problems on joins, is there only in specific files\n df['State'] = df.State.str.strip() ## removes leading and lagging white spaces if any\n df2 = pd.melt(df,id_vars=['State','data_monthid'],var_name=['category'], value_name='Million_Vehicle_Miles')\n return df2\n except:\n print(\"error in file \",os.path.basename(file_path))","def get_context_from_xlsx(self):\n if re.search('^(http|https)://', self.project.CONTEXT_SOURCE_FILE):\n resp = requests.get(self.project.CONTEXT_SOURCE_FILE)\n content = resp.content\n else:\n try:\n with open(self.project.CONTEXT_SOURCE_FILE) as xlsxfile:\n content = xlsxfile.read()\n except IOError:\n filepath = \"%s/%s\" % (\n os.path.abspath(self.path),\n self.project.CONTEXT_SOURCE_FILE)\n with open(filepath) as xlsxfile:\n content = xlsxfile.read()\n\n data = process_xlsx(content)\n if 'values' in data:\n data = copy_global_values(data)\n\n return data","def test_read_xls(self):\r\n my_tape = Tape()\r\n input_xls = os.path.join(test_files_dir, 'test_tape.xlsx')\r\n my_tape.read_xls(input_xls)\r\n assert_frame_equal(self.test_df, my_tape.dataframe)","def _parse_cells(self):\n self.cells_with_solutions = []\n self.cells_without_solutions = []\n for cell in self.original_cells:\n if is_test_cell(cell):\n self.tests.append(read_test(cell))\n else:\n self.cells_with_solutions.append(cell)\n self.cells_without_solutions.append(replace_cell_solutions(cell))","def normalize_excelSheet(self, sheetname, conversion_dictionary):\n\n sheet = self.wb.sheet_by_name(sheetname)\n\n ami_data = []\n\n date_headers = [\"bibliographic.date\", \"technical.dateCreated\"]\n time_headers = [\"technical.durationHuman\"]\n\n #copy everything from the 3rd row to the last row with a filename\n for rownum in range(2, sheet.nrows):\n if sheet.cell(rownum, 0):\n ami_data.append(sheet.row_values(rownum))\n\n for i in range(0, sheet.ncols):\n #normalize header\n header_entry = self.get_headerEntryAsString(sheetname, i)\n ami_data[0][i] = self.normalize_headerEntry(\n header_entry,\n conversion_dictionary)\n\n #convert excel dates\n if ami_data[0][i] in date_headers:\n for j in range(3, sheet.nrows):\n if sheet.cell(j, i).ctype == 3:\n value = sheet.cell(j, i).value\n ami_data[j-2][i] = self.convert_excelDateTime(value, \"date\")\n\n #convert excel times\n if ami_data[0][i] in time_headers:\n for j in range(3, sheet.nrows):\n if sheet.cell(j, i).ctype == 3:\n value = sheet.cell(j, i).value\n ami_data[j-2][i] = self.convert_excelDateTime(value, \"time\")\n\n ami_df = self.normalize_values(ami_data)\n\n return ami_df","def load_plothrm_detailed(filename):\n\n filename = Path(filename)\n\n book = xlrd.open_workbook(filename)\n xlsx_file = pd.ExcelFile(filename)\n\n df_seq = None\n df_meta = None\n\n for sheetidx, sheetname in enumerate(xlsx_file.sheet_names):\n\n print(f'Parsing \"{filename}\" sheet \"{sheetname}\"', flush=True)\n\n try:\n\n sheetnumber = sheetidx + 1\n worksheet = book.sheet_by_name(sheetname)\n\n # try to load a value from the row and column\n def value_default(row, col, d):\n if row >= worksheet.nrows or col >= worksheet.ncols:\n return d\n s = worksheet.cell_value(row, col)\n if type(s) is str and len(s) == 0:\n return d\n else:\n return s\n\n # load metadata\n meta = dict()\n meta['sheetname'] = sheetname\n meta['sheetnumber'] = sheetnumber\n meta['plothrm_version'] = str(worksheet.cell_value(0, 1))\n meta['data_filename'] = str(worksheet.cell_value(1, 1))\n meta['seq_filename'] = str(worksheet.cell_value(2, 1))\n meta['nchan'] = int(worksheet.cell_value(3, 1))\n meta['nsamp'] = int(worksheet.cell_value(4, 1))\n meta['sampling_hz'] = float(worksheet.cell_value(5, 1))\n meta['opt_zero_above'] = float(value_default(6, 2, np.nan))\n meta['opt_remove_baselines'] = bool (value_default(6, 4, 0))\n meta['opt_remove_sync'] = bool (value_default(6, 6, 0))\n meta['opt_channel_smooth'] = bool (value_default(6, 8, 0))\n meta['opt_sample_smooth'] = float(value_default(6, 10, np.nan))\n meta['height_res'] = float(worksheet.cell_value(7, 1))\n meta['sync_bound'] = float(worksheet.cell_value(8, 1))\n # TODO load region data at rows 9, 10, 11 (Excel 1-based index rows 10-12)\n\n for k, v in meta.items():\n meta[k] = [v]\n meta = pd.DataFrame(meta)\n\n if df_meta is None:\n df_meta = meta\n else:\n df_meta = df_meta.append(meta)\n\n # load sequence data\n df = pd.read_excel(filename, sheetname, header=13, na_values=['ERROR', 'Infinity'])\n df['sheetname'] = sheetname\n df['sheetnumber'] = sheetnumber\n if df_seq is None:\n df_seq = df\n else:\n df_seq = df_seq.append(df)\n\n except Exception as e:\n print(f' error parsing worksheet \"{sheetname}\": {e}')\n continue\n\n return df_seq.reset_index(drop=True), df_meta.reset_index(drop=True)","def read_elia_activated_energy_prices(filename,status):\r\n \r\n df = pd.read_excel(filename,skiprows=2,parse_dates=False)\r\n df[\"Timestamp\"] = df[\"Date\"]+\" \"+df['Quarter'].map(lambda x: str(x)[:-9])\r\n pd.to_datetime(df[\"Timestamp\"])\r\n df.set_index(\"Timestamp\",inplace=True)\r\n if ((status == \"validated\") | (status == \"valid\")):\r\n df = df.drop(df[df.Status != \"Validated\"].index)\r\n df = df.drop([\"Date\",\"Quarter\",\"Status\"], axis=1)\r\n \r\n if len(df.columns)>14:\r\n df.columns.values[0:16] = [\"NRV in MW\",\"SR in euro/MWh\",\"MIP in euro/MWh\",\"IGGC+ in euro/MWh\", \"R2+ in euro/MWh\",\"Bids+ in euro/MWh\",\"R3 std in euro/MWh\", \"R3 flex in euro/MWh\", \"ICH in euro/MWh\", \"inter TSO import in euro/MWh\", \"MDP in euro/MWh\", \"IGCC- in euro/MWh\", \"R2- in euro/MWh\", \"Bids- in euro/MWh\", \"R3- in euro/MWh\"]\r\n\r\n if len(df.columns)<12:\r\n df.columns.values[0:12] = [\"NRV in MW\",\"MIP in euro/MWh\",\"IGGC+ in euro/MWh\", \"R2+ in euro/MWh\",\"Bids+ in euro/MWh\", \"R3+ in euro/MWh\", \"MDP in euro/MWh\", \"IGCC- in euro/MWh\", \"R2- in euro/MWh\", \"Bids- in euro/MWh\", \"R3- in euro/MWh\"]\r\n\r\n return df","def read_elia_cap(filename):\r\n df = pd.read_excel(filename,skiprows=0,parse_dates=False)\r\n \r\n #standaard datetime vorm omzetten\r\n df[\"Tendering Periodneww\"] = pd.to_datetime(df[\"Tendering Period\"],errors='coerce')\r\n df[\"Delivery Periodneww\"] = pd.to_datetime(df[\"Delivery Period\"],errors='coerce')\r\n \r\n #de 'weekvorm' van datetime omzetten\r\n df[\"Tendering Period\"]=df[\"Tendering Period\"].astype(str).map(lambda x: x.lstrip('W'))\r\n df[\"Delivery Period\"]=df[\"Delivery Period\"].astype(str).map(lambda x: x.lstrip('W'))\r\n df[\"Tendering Period\"]=df[\"Tendering Period\"].replace('\\s+', '_',regex=True)\r\n df[\"Delivery Period\"]=df[\"Delivery Period\"].replace('\\s+', '_',regex=True)\r\n df[\"Tendering Periodnew\"] = pd.to_datetime(df[\"Tendering Period\"][df[\"Delivery Periodneww\"].isnull()].astype(str).add('-1'), format=\"%W_%Y-%w\", errors='coerce')\r\n df[\"Delivery Periodnew\"] = pd.to_datetime(df[\"Delivery Period\"][df[\"Delivery Periodneww\"].isnull()].astype(str).add('-1'), format=\"%W_%Y-%w\", errors='coerce')\r\n \r\n #datumkolommen samenvoegen en overbodige kolommen verwijderen\r\n df[\"Tendering Period Combined\"] = df['Tendering Periodnew'].fillna(df['Tendering Periodneww'])\r\n df[\"Delivery Period Combined\"] = df['Delivery Periodnew'].fillna(df['Delivery Periodneww'])\r\n df=df.drop(columns=['Tendering Period', 'Delivery Period','Tendering Periodneww', 'Delivery Periodneww','Tendering Periodnew', 'Delivery Periodnew',])\r\n df.columns=[\"duration\",\"reserve type\",\"service type\",\"total contracted volume in MW\", \"average price in euro/MW/h\",\"forecasted average price in euro/MW/h\",\"total offered volume in MW\",\"tariff period\", \"symmetry type\", \"country\",\"tendering period\",\"delivery period\"] \r\n \r\n #multi index & sort\r\n df=df.set_index([\"delivery period\"])\r\n df=df.sort_index(ascending=False);\r\n \r\n return df","def read_elia_activated_energy_volumes(filename,status):\r\n df = pd.read_excel(filename,skiprows=2,parse_dates=False)\r\n df[\"Timestamp\"] = df[\"Date\"]+\" \"+df['Quarter'].map(lambda x: str(x)[:-9])\r\n pd.to_datetime(df[\"Timestamp\"])\r\n df.set_index(\"Timestamp\",inplace=True)\r\n if ((status == \"validated\") | (status == \"valid\")):\r\n df = df.drop(df[df.Status != \"Validated\"].index)\r\n df = df.drop([\"Date\",\"Quarter\",\"Status\"], axis=1)\r\n \r\n if ((len(df.columns)<13) & (len(df.columns)>11)) :\r\n df.columns.values[0:13] = [\"NRV in MW\", \"GUV in MW\", \"IGCC+ in MW\", \"R2+ in MW\", \"Bids+ in MW\", \"R3+ in MW\", \"R3DP+ in MW\", \"GDV in MW\", \"IGCC- in MW\", \"R2- in MW\", \"Bids- in MW\", \"R3- in MW\"]\r\n if len(df.columns)<= 11:\r\n df.columns.values[0:12] = [\"NRV in MW\", \"GUV in MW\", \"IGCC+ in MW\", \"R2+ in MW\", \"Bids+ in MW\", \"R3+ in MW\", \"GDV in MW\", \"IGCC- in MW\", \"R2- in MW\", \"Bids- in MW\", \"R3- in MW\"]\r\n if len(df.columns)>14:\r\n df.columns.values[0:16] = [\"NRV in MW\", \"SR in MW\",\"GUV in MW\", \"IGCC+ in MW\",\"R2+ in MW\",\"Bids+ in MW\",\"R3 std in MW\",\"R3 flex in MW\",\"ICH in MW\",\"inter TSO import in MW\",\"GDV in MW\",\"IGCC- in MW\",\"R2- in MW\",\"Bids- in MW\",\"inter TSO export in MW\"]\r\n \r\n return df","def import_heat_data(self):\n worksheet = (\n xlrd.open_workbook(filename=self.filename_heat).sheet_by_index(0)\n ) \n self.exh.corrected_reading = np.array(worksheet.col_values(0,\n start_rowx=self.start_rowx, end_rowx=self.end_rowx)) \n self.exh.datum = worksheet.cell_value(2,4) # manometer datum (in) \n self.exh.pressure_drop = ( (self.exh.corrected_reading -\n self.exh.datum) * 2. * self.H2O_kPa ) \n # pressure drop across heat exchanger (kPa)\n self.cummins.torque = np.array(worksheet.col_values(1,\n start_rowx=self.start_rowx, end_rowx=self.end_rowx))\n self.exh.T_inlet_array = np.array(worksheet.col_values(2,\n start_rowx=self.start_rowx, end_rowx=self.end_rowx)) \n self.exh.T_outlet_array = np.array(worksheet.col_values(3,\n start_rowx=self.start_rowx, end_rowx=self.end_rowx)) \n self.cool.T_inlet_array = np.array(worksheet.col_values(5,\n start_rowx=self.start_rowx, end_rowx=self.end_rowx)) \n self.cool.T_outlet_array = np.array(worksheet.col_values(4,\n start_rowx=self.start_rowx, end_rowx=self.end_rowx))","def _read_xls(self, options, datas):\n book = xlrd.open_workbook(file_contents=datas)\n return self._read_xls_book(book)","def test_from_file_xlsx(self):\n with TemporaryDirectory() as tmp:\n fp, df_test = save_simple_dataframe(tmp, 'test.xlsx')\n df_read = BaseDataClass.from_file(fp).df\n self.assertEqual(\n pd.testing.assert_frame_equal(df_test, df_read),\n None,\n )","def load_data_from_xsl(file_name):\n\tnlp_data = pd.read_excel(file_name, sheet_name=0, header=0, usecols=[1, 2, 3],\n\t converters={'bug_id': str, 'summary': str, 'description': str})\n\tnlp_data.fillna(' ', inplace=True)\n\n\t# nlp_data['description'] = nlp_data['description'].map(lambda x: clean_str(x+''))\n\n\treturn nlp_data","def main(url):\n\n return excel_parser(\n url,\n extract_product_from_data\n )","def _handleLoadFile(self) -> None:\n\n dialog: ChooseFileDialog = self._makeChooseFileDialog()\n result: DialogResult = dialog.show()\n if result == DialogResult.Ok:\n file: str = dialog.getSelectedFile()\n self._setWindowTitle(file)\n data: List[List[Any]] = csvReader.readFile(file)\n self.__spreadsheet.setData(data)","def parse_cases(raw_data_file: str, source_id: str, source_url: str):\n with open(raw_data_file, \"r\") as f:\n reader = csv.DictReader(f)\n for row in reader:\n case = {\n \"caseReference\": {\n \"sourceId\": source_id,\n \"sourceUrl\": source_url,\n },\n \"location\": {\n \"query\": \"Some district, Some country\"\n },\n \"events\": [\n {\n \"name\": \"confirmed\",\n \"dateRange\":\n {\n \"start\": \"03/06/2020Z\",\n \"end\": \"03/06/2020Z\",\n },\n },\n ],\n }\n yield case","def _read_excel(file: str, semester: str, users: set, courses: set, users_to_courses: dict):\n course_parts = file.split('/')[-1].split('_')\n course_name = '{}{}'.format(course_parts[0], course_parts[1])\n courses.add((course_name, semester))\n\n book = xlrd.open_workbook(file)\n sheet = book.sheet_by_index(0)\n skip = True\n\n for row in sheet.get_rows():\n first_column = row[0].value\n if skip:\n skip = not first_column.startswith(\"Name\")\n continue\n elif first_column == \"\" or first_column is None:\n continue\n\n full_name = first_column\n name_parts = [name.strip() for name in full_name.split(', ')]\n\n email = row[1].value + '@ithaca.edu'\n users.add((email, name_parts[0], name_parts[1]))\n\n users_to_courses[email].append([course_name, semester])","def read_file(path,filename,sheet_name = None, delimiter = None):\n os.chdir(path)\n filetype = file.split('.')[1] #splits filename by delimeter '.' to give 'csv' 'xls' or 'xlsx'\n \n if filetype == 'csv':\n if delimiter == None: delimiter = ',' #csv default delimeter should be a comma, but may often be a semi-colon!\n df = pd.read_csv(file,delimiter)\n \n else:\n df = pd.read_excel(file,sheet_name)\n \n return df","def __init__(self, input_file):\n self.file_name = input_file\n # Import the excel file:\n self.xlfile = ExcelFile(self.file_name) # to retrieve & work w/ input","def _read_workbook_97(maldoc):\n\n # Run olevba on the file and extract the XLM macro code lines.\n color_print.output('g', \"Analyzing Excel 97 file ...\")\n xlm_code = _extract_xlm(maldoc)\n color_print.output('g', \"Extracted XLM with olevba.\")\n if debug:\n print(\"=========== START RAW XLM ==============\")\n print(xlm_code)\n print(\"=========== DONE RAW XLM ==============\")\n if (xlm_code is None):\n color_print.output('r', \"ERROR: Unable to extract XLM. Emulation aborted.\")\n return (None, None, None)\n\n # Parse the XLM text and get XLM objects that can be emulated.\n xlm_cells = XLM.stack_transformer.parse_olevba_xlm(xlm_code)\n color_print.output('g', \"Parsed olevba XLM macros.\")\n if (xlm_cells is None):\n color_print.output('r', \"ERROR: Parsing of XLM failed. Emulation aborted.\")\n return (None, None, None)\n\n # Merge the XLM cells with the value cells into a single unified spereadsheet\n # object.\n workbook, xlm_cell_indices, xlm_sheet = _merge_XLM_cells(maldoc, xlm_cells)\n if (workbook is None):\n color_print.output('r', \"ERROR: Merging XLM cells failed. Emulation aborted.\")\n return (None, None, None)\n\n # Done. \n return (workbook, xlm_cell_indices, xlm_sheet)","def get_entities(self, xlsx_file):\n \n self.logger.info(\"Loading workbook: {}\".format(xlsx_file))\n\n # report on total rows.\n total_rows = sum(1 for row in self._get_rows(xlsx_file))\n self.logger.info(\"Found {} rows.\".format(total_rows))\n \n # get row data and modified checksum.\n entity_rows = self._get_rows(xlsx_file)\n hash_prefix = self._get_hash_prefix(xlsx_file)\n\n # get header.\n row = next(entity_rows)\n header = [cell.value for cell in row]\n header= tuple(header)\n\n # if header is invalid, return empty generator.\n if not self._validate_header(header):\n msg = \"Invalid header row: {}.\".format(header)\n raise self.SchemaError(msg)\n\n # create generator for each row.\n def entities():\n \n # start numbering at 2 because the header has already been read.\n row_number = 2\n \n # yield a dict for each non-header row.\n header_range = range(0,len(header))\n for row in entity_rows:\n\n self.logger.info(\"Processing row {}.\".format(row_number))\n \n # get row values.\n row = [cell.value for cell in row]\n row = [cell.strip() if isinstance(cell, str) else cell for cell in row]\n row = [(header[i], row[i]) for i in header_range]\n row = dict(row)\n\n # run row validator.\n row_valid = self._validate_row(row)\n if not row_valid:\n self.logger.warning(\"Skipping row {}; row is invalid.\".format(\n row_number))\n row_number += 1\n continue\n \n # alter data as needed and create dict for row.\n row[\"identifier\"] = hash_prefix + row[\"identifier\"]\n manifestations = self.get_manifestations(row[\"pattern\"], \n row[\"case_sensitive\"], row_number)\n row[\"manifestations\"] = [\"\".join(m) for m in manifestations]\n \n # yield row as dict.\n row_number += 1\n yield(row)\n\n return entities()","def read_meth(filename, name, window, smoothen=5):\n file_type = file_sniffer(filename)\n logging.info(\"File is of type {}\".format(file_type))\n try:\n if file_type.startswith(\"nanopolish\"):\n return parse_nanopolish(filename, file_type, name, window, smoothen=smoothen)\n elif file_type == \"nanocompore\":\n return parse_nanocompore(filename, name, window)\n elif file_type == \"ont-cram\":\n return parse_ont_cram(filename, name, window)\n except Exception:\n sys.stderr.write(\"\\n\\n\\nInput file {} not recognized!\\n\".format(filename))\n sys.stderr.write(\"\\n\\n\\nDetailed error:\\n\")\n raise","def read_ep_data(path=None):\n if path is None:\n path = \"\"\"C:/Users/Brendan/Downloads/ExodusPoint - Assignment Data (Rates Quantitative Strategist) - New York.xlsx\"\"\"\n \n xls = pd.ExcelFile(path)\n legacy_sheets = ['TU - Com; NonCom','FV - Com;NonCom', 'TY - Com;NonCom', 'US - Com;NonCom ', 'WN - Com;NonCom']\n tff_sheets = ['TU - Sectorial','FV - Sectorial', 'TY - Sectorial', 'US - Sectorial', 'WN - Sectorial']\n \n a, b = {}, {}\n for s in legacy_sheets:\n d = pd.read_excel(xls, sheet_name=s, index_col=0, header=3, skipfooter=1, parse_dates=True)\n d = d.rename(rename_legacy_cols, axis=1).drop('Total', axis=1)\n ct = s[0:2]\n a[ct] = d\n legacy_raw = pd.concat(a, axis=1)\n \n for s in tff_sheets:\n d = pd.read_excel(xls, sheet_name=s, index_col=0, header=3, skipfooter=1, parse_dates=True)\n d = d.rename(rename_tff_cols, axis=1)\n ct = s[0:2]\n b[ct] = d\n tff_raw = pd.concat(b, axis=1)\n \n futures_raw = pd.read_excel(xls, sheet_name=\"Futures Price and Duration Data\",\n index_col=0, header=[3,4,5], skipfooter=1, parse_dates=True)\n futures_raw.columns = futures_raw.columns.droplevel(1)\n futures_raw.columns.set_levels([s[0:2] for s in futures_raw.columns.levels[0]], \n level=0, inplace=True)\n futures_raw.columns.set_names(['ct', 'field'], inplace=True)\n \n swaps_raw = pd.read_excel(xls, sheet_name=\"Swap Prices\",\n index_col=0, header=3, skipfooter=1, parse_dates=True)\n \n return legacy_raw, tff_raw, futures_raw, swaps_raw","def __init__(self, filepath):\n self._column_names = []\n self._row_list = []\n self._workbook = None\n\n try:\n self._workbook = xlrd.open_workbook(filepath)\n except:\n raise Exception('Nie można otworzyć pliku lub nieprawidłowy rodzaj pliku.')","def load_excel_file(fname, sheet_name='Sheet1', cell_range=None):\n #DEPRICATED CODE\n #d = cell_range.split(:))\n #row_size = int(d[1][1:]) - int(d[0][1:]) + 1\n #col_size = (ord(d[1][0].lower()) - 96) - (ord(d[0][0].lower()) - 96) + 1\n #cell_data = np.zeros([row_size, col_size])\n\n wb = openpyxl.load_workbook(fname)\n sheet = wb[sheet_name]\n\n big_list = []\n for row in sheet[cell_range]:\n small_list = []\n for cell in row:\n #print(cell.coordinate, cell.value)\n small_list.append(cell.value)\n big_list.append(small_list)\n\n return np.array(big_list)","def process(workbook: Any, content: str) -> None:\n sheets = ['SMB', 'NFS', 'Multiprotocol']\n\n row_tuples = dict()\n row_tuples['SMB'] = [\n 'ArrayName', 'DataMover', 'ShareName', 'SharePath',\n 'RootPath', 'Type', 'umask', 'maxusr', 'netbios', 'comment'\n ]\n\n row_tuples['NFS'] = [\n 'Hostname', 'Server', 'MountedPath', 'FileSystem',\n 'Type', 'rw', 'root', 'access'\n ]\n\n row_tuples['Multiprotocol'] = [\n 'Hostname', 'Server',\n 'MountedPath', 'Type'\n ]\n\n server_export_out = run_parser_over(content, SERVER_EXPORT_TMPL)\n server_export_grouped = groupby(itemgetter(3), server_export_out)\n share, export, multi = classify_rows(server_export_grouped)\n\n for sheet, data_list in zip(sheets, [share, export, multi]):\n worksheet = workbook.get_sheet_by_name(sheet)\n build_header(worksheet, row_tuples[sheet])\n RowTuple = namedtuple('RowTuple', row_tuples[sheet])\n\n final_col, final_row = 0, 0\n for row_n, row_tuple in enumerate(map(RowTuple._make, data_list), 2):\n for col_n, col_value in \\\n enumerate(row_tuple._asdict().values(), ord('A')):\n cell = worksheet['{}{}'.format(column_format(col_n), row_n)]\n if isinstance(col_value, str):\n cell.value = str.strip(col_value)\n else:\n cell.alignment = Alignment(wrapText=True)\n cell.value = '\\n'.join(col_value)\n style_value_cell(cell)\n set_cell_to_number(cell)\n final_col = col_n\n final_row = row_n\n\n sheet_process_output(\n worksheet,\n '{}Table'.format(sheet),\n sheet,\n final_col,\n final_row)","def load_data(self) -> pd.DataFrame:\n\n if not os.path.exists(self.file_name):\n raise FileNotFoundError(f\"File does not exist: {self.file_name}\")\n\n _, ext = os.path.splitext(self.file_name)\n assert ext == \".xls\", \"Invalid filetype attempted to load\"\n\n return pd.read_excel(self.file_name)","def read_from_xlsx(filename='Infosys.xlsx', sheet='Profit & Loss', cell_range=OrderedDict([('A14','J14'), ('A15','J15')])):\n xl = win32com.client.Dispatch('Excel.Application')\n try:\n filename = env.DOWNLOAD_DIR + '\\\\' + filename\n wb = xl.Workbooks.Open(Filename=filename, ReadOnly=1, Editable=True)\n ws = wb.Worksheets(sheet)\n for k, val in cell_range.items():\n print (ws.Range(k + ':' + val).Value)\n\n except Exception as e:\n logger.exception(e)\n\n else:\n wb.Close(True)","def read(f):\n book = openpyxl.load_workbook(f) \n sheet = book.active \n items_list =[]\n n = sheet.cell(row = 2, column = 1).value\n c = sheet.cell(row = 2, column = 2).value\n for i in range(2,n+2): \n cell_obj = sheet.cell(row = i, column = 3)\n items_list.append(cell_obj.value) \n return items_list,c","def parse_input(file_handle):\n\tcases = []\n\tdata = file_handle.read().split('\\n')[1:]\n\t# remove empty lines\n\tdata = [x.split(' ') for x in data if x != '']\n\tdata = [[int(x) for x in y] for y in data]\n\t[cases.append(case(data[x])) for x in range(len(data))]\n\treturn cases","def loadData(self, file, sheet, cols, skip):\n df = pd.read_excel(io=file, sheetname=sheet, header=0, parse_cols=cols, skiprows=skip).values\n return df","def loadData(fileName, fileType):\n try:\n if (fileType == 'xlsx' or fileType == 'xls' or fileType == 'excel'):\n temp = pd.read_excel(fileName)\n elif fileType == 'csv':\n temp = pd.read_csv(fileName)\n else:\n return\n except FileNotFoundError:\n return 'FileNotFoundError'\n else:\n return temp","def read_lines(the_file, worksheet, w):\n ListOfData = []\n Cpu_Usage = 'usr', 'sys', 'idl', 'wai', 'hiq', 'siq'\n Cpu_bool = False\n Mem_Usage = 'used', 'buff', 'cach', 'free'\n Mem_bool = False\n Disk_Usage = 'read', 'writ'\n Disk_bool = False\n Net_Usage = 'recv', 'send'\n Net_bool = False\n rowNum = 7\n lineCount = 8\n\n #with open(the_file) as input_data:\n for line in the_file:\n if \"failed\" in line:\n error_mssg = line\n print \"Error message found in log: \", error_mssg\n worksheet[w].write(0, 0, 'Error Message in log: ' + error_mssg)\n continue\n if \"total-cpu-usage\" in line:\n ListOfData.append(Cpu_Usage)\n worksheet[w].write(6, 0, 'Total CPU Usage')\n Cpu_bool = True\n if \"memory-usage\" in line:\n ListOfData.append(Mem_Usage)\n worksheet[w].write(6, 6, 'Memory Usage')\n Mem_bool = True\n if \"dsk/sd\" in line:\n ListOfData.append(Disk_Usage)\n worksheet[w].write(6, 10, 'Disk Usage')\n Disk_bool = True\n if \"net/eth\" in line:\n ListOfData.append(Net_Usage)\n worksheet[w].write(6, 12, 'Network Usage')\n Net_bool = True\n continue\n continue\n else:\n line = line.replace(\"|\", \" \")\n line = line.replace(\"\\n\", \"\")\n line = re.sub(\" +\", \" \", line)\n lineCount = lineCount + 1\n if line[0] == \" \":\n line = line[1:]\n else:\n line = line[0:]\n #print line\n for a in ListOfData:\n colNum = 0\n a = [[y] for y in line.split(\" \")]\n #print \"This is an a: \", a\n for i in a:\n #print \"This is i:\", i[0]\n if \"M\" in i[0]:\n i[0] = (float(i[0].replace(\"M\", \"\"))*1048576)\n elif \"k\" in i[0] and not \"dsk\" in i[0] and not \"ticks\" in i[0]:\n i[0] = (float(i[0].replace(\"k\", \"\"))*1024)\n elif \"B\" in i[0]:\n i[0] = (float(i[0].replace(\"B\", \"\")))\n elif \"G\" in i[0]:\n i[0] = (float(i[0].replace(\"G\", \"\"))*1073741824)\n try:\n i = float(i[0])\n #print \"Converting to float!\"\n worksheet[w].write_number(rowNum, colNum, i)\n colNum = colNum + 1\n except:\n worksheet[w].write_row(rowNum, colNum, i)\n colNum = colNum + 1\n rowNum = rowNum + 1\n continue\n return Cpu_bool, Mem_bool, Disk_bool, Net_bool, worksheet, lineCount","def read_xls_csv(self):\n filename = str(self.filename)\n location_stock_id = self.location\n vals = []\n inventory_create = self.env['stock.inventory']\n\n if (filename.endswith('xls') or filename.endswith('xlsx')):\n wb = xlrd.open_workbook(\n file_contents=base64.decodestring(self.xls_file))\n sheet = wb.sheet_by_index(0)\n\n for i in range(1, sheet.nrows):\n row = sheet.row_values(i)\n firstrow = sheet.row_values(0)\n firstrow = [str(item).lower() for item in firstrow]\n pid = row[firstrow.index('id')]\n quantity = row[firstrow.index('quantity')]\n product_obj = self.env['product.product'].search(\n [('id', '=', pid)])\n vals.append({\n 'product_code': product_obj.default_code,\n 'product_qty': quantity,\n 'location_id': location_stock_id.id,\n 'product_id': product_obj.id\n })\n inv = inventory_create.create({'name': self.inventory_name,\n 'location_id': location_stock_id.id,\n 'filter': 'partial'})\n stock_inventory_line = self.env['stock.inventory.line']\n # inv.prepare_inventory()\n for record in vals:\n record.update({'inventory_id': inv.id})\n stock_inventory_line.create(record)\n inv.action_done()\n\n else:\n xls_file = base64.b64decode(self.xls_file)\n file_input = cStringIO.StringIO(xls_file)\n file_input.seek(0)\n rows = []\n delimeter = ','\n reader = csv.reader(file_input, delimiter=delimeter,\n lineterminator='\\r\\n')\n for row in reader:\n rows.append(row)\n for row in rows[1:]:\n rows[0] = [str(item).lower() for item in rows[0]]\n product_obj = self.env['product.product'].search(\n [('id', '=', row[rows[0].index('id')])])\n vals.append({\n 'product_code': row[rows[0].index('id')],\n 'product_qty': row[rows[0].index('quantity')],\n 'location_id': location_stock_id.id,\n 'product_id': product_obj.id\n })\n inv = inventory_create.create({'name': self.inventory_name,\n 'location_id': location_stock_id.id,\n 'filter': 'partial'})\n stock_inventory_line = self.env['stock.inventory.line']\n # inv.prepare_inventory()\n for record in vals:\n record.update({'inventory_id': inv.id})\n stock_inventory_line.create(record)\n inv.action_done()\n return {\n 'name': 'Stock import',\n 'type': 'ir.actions.act_window',\n 'view_type': 'form',\n 'res_id': self.id,\n 'view_mode': 'tree,form',\n 'res_model': 'stock.inventory',\n 'target': 'current',\n }","def parse_result_file(self, filepath: str):\n\n raise NotImplementedError","def read_elia_freq_R1(filename):\r\n df = pd.read_excel(filename,skiprows=4,parse_dates=True,index_col=0,dayfirst=True)\r\n df=df.drop(df.index[[0]])\r\n df.columns.values[0:3] = [\"Frequency\",\"ObligationR1\",\"RequestedR1\"]\r\n \r\n return df","def _parse_ach_file(self, contents):\n file_length = len(contents)\n\n for index in range(0, file_length, self.LINE_LENGTH):\n line = contents[index:index + self.LINE_LENGTH]\n\n if line.startswith('1'):\n self._read_header(line)\n elif line.startswith('5'):\n self._read_batch_header(line)\n elif line.startswith('6'):\n self._read_entry_detail(line)\n elif line.startswith('7'):\n self._read_addenda_record(line)\n elif line.startswith('8'):\n self._read_batch_control_record(line)\n elif line.startswith('9'):\n if line == '9' * 94:\n continue\n self._read_file_control_record(line)","def import_excel(self):\n self.ensure_one()\n if self.file_import:\n filecontent = base64.b64decode(self.file_import)\n try:\n # Todo: import excel\n input = cStringIO.StringIO()\n input.write(filecontent)\n wb = open_workbook(file_contents=input.getvalue())\n problem_emails = {\"inserted_names\": [],\n \"inserted_emails\": [],\n \"invalid_emails\": [],\n \"duplicate_names\": [],\n \"duplicate_emails\": []}\n for sheet in wb.sheets():\n try:\n self.insert_db(sheet, wb, problem_emails)\n except Exception as e:\n raise (str(e))\n\n except:\n # todo: import csv\n wb = filecontent.split('\\r\\n')\n for line in range(1, len(wb) - 1):\n line_data = wb[line].split(',')\n self.crete_line(line_data[0], line_data[1])\n\n if problem_emails['invalid_emails']:\n raise except_orm(_('Invalid Email Format Found!'),\n _( '\\n'.join(map(str, list(item for item in problem_emails['invalid_emails']))) + '\\n\\n Please check and try again.'))\n if problem_emails['duplicate_names']:\n raise except_orm(_('Duplicate Name Found!'),\n _( '\\n'.join(map(str, list(item for item in problem_emails['duplicate_names']))) + '\\n\\n Please check and try again.'))\n if problem_emails['duplicate_emails']:\n raise except_orm(_('Duplicate Email Found!'),\n _( '\\n'.join(map(str, list(item for item in problem_emails['duplicate_emails']))) + '\\n\\n Please check and try again.'))\n\n return {\n 'view_type': 'form',\n 'view_mode': 'form',\n 'res_model': 'shipmaster.invitation',\n 'res_id': self.id,\n 'view_id': False,\n 'type': 'ir.actions.act_window',\n 'target': 'new',\n }","def test_assemble_xml_file_A1(self):\n self.maxDiff = None\n\n fh = StringIO()\n worksheet = Worksheet()\n worksheet._set_filehandle(fh)\n cell_format = Format({\"xf_index\": 1})\n\n # No format. Should be ignored.\n worksheet.write_blank(\"A1\", None)\n\n worksheet.write_blank(\"C2\", None, cell_format)\n\n worksheet.select()\n worksheet._assemble_xml_file()\n\n exp = _xml_to_list(\n \"\"\"\n <?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\"?>\n <worksheet xmlns=\"http://schemas.openxmlformats.org/spreadsheetml/2006/main\" xmlns:r=\"http://schemas.openxmlformats.org/officeDocument/2006/relationships\">\n <dimension ref=\"C2\"/>\n <sheetViews>\n <sheetView tabSelected=\"1\" workbookViewId=\"0\"/>\n </sheetViews>\n <sheetFormatPr defaultRowHeight=\"15\"/>\n <sheetData>\n <row r=\"2\" spans=\"3:3\">\n <c r=\"C2\" s=\"1\"/>\n </row>\n </sheetData>\n <pageMargins left=\"0.7\" right=\"0.7\" top=\"0.75\" bottom=\"0.75\" header=\"0.3\" footer=\"0.3\"/>\n </worksheet>\n \"\"\"\n )\n\n got = _xml_to_list(fh.getvalue())\n\n self.assertEqual(got, exp)","def process_files(geodata_name, inp_dict):\n input_paths = inp_dict[\".xls\"][:]\n try:\n data = geodata(geodata_name)\n except UnicodeDecodeError:\n showerror(\"Ошибка кодирования\", \"Файл данных должен быть закодирован в utf-8\")\n data = geodata(askopenfilenames(initialdir=os.path.abspath(os.getcwd()), filetypes=[(\"Файл данных txt\", \".txt\")], title=\"Выберите файл данных txt\")[0])\n\n\n for book in input_paths:\n book_flag = False\n with open_workbook(book, formatting_info=True) as rb:\n header = False\n wb = copy(rb)\n for numb, sheet in enumerate(rb.sheets()):\n column = \"False\"\n for row in range(sheet.nrows):\n if column != \"False\":\n for data_row in data:\n if sheet.cell(row, column).value == data_row[0]:\n sheet_wb = wb.get_sheet(numb)\n sheet_wb.write(row, sheet.ncols, data_row[1])\n sheet_wb.write(row, sheet.ncols+1, data_row[2])\n break\n else:\n for col in range(sheet.ncols):\n for data_row in data:\n if sheet.cell(row, col).value == data_row[0]:\n column = col\n book_flag = True\n sheet_wb = wb.get_sheet(numb)\n sheet_wb.write(row, sheet.ncols, data_row[1])\n sheet_wb.write(row, sheet.ncols+1, data_row[2])\n if not header:\n header = True\n style_list = get_xlwt_style_list(rb)\n wb.get_sheet(numb).write(0, sheet.ncols, u\"Широта\", style=style_list[sheet.cell_xf_index(0, 0)])\n wb.get_sheet(numb).write(0, sheet.ncols+1, u\"Долгота\", style=style_list[sheet.cell_xf_index(0, 0)])\n break\n if book_flag:\n if not os.path.isdir(\"out\"):\n os.mkdir(\"out\")\n f_out = get_output_name(book)\n wb.save(f_out)\n inp_dict[\"del\"].append(f_out)\n inp_dict[\"out\"].append(f_out)\n return inp_dict","def file_loading():\r\n print(\"Loading the three excel files.\")\r\n\r\n elec_data1 = pd.read_excel(ELEC_FILE, sheet_name=ELEC_SHEET1)\r\n elec_data2 = pd.read_excel(ELEC_FILE, sheet_name=ELEC_SHEET2,\r\n skiprows=1)\r\n\r\n strp_elec1 = elec_data1[['Table', 'Column', 'SAP required']]\r\n strp_elec1 = strp_elec1.rename(columns={'Table': 'TABLE',\r\n 'Column': 'COLUMN',\r\n 'SAP required': 'SAP'})\r\n\r\n strp_elec2 = elec_data2[['Source Table', 'Source Column', 'SAP required']]\r\n strp_elec2 = strp_elec2.rename(columns={'Source Table': 'TABLE',\r\n 'Source Column': 'COLUMN',\r\n 'SAP required': 'SAP'})\r\n return strp_elec1, strp_elec2","def import_building_from_excel(\n project, building_name, construction_age, path_to_excel, sheet_names\n):\n\n def warn_constructiontype(element):\n \"\"\"Generic warning function\"\"\"\n if element.construction_type is None:\n warnings.warn(\n 'In zone \"%s\" the %s construction \"%s\" could not be loaded from the TypeBuildingElements.json, '\n \"an error will occur due to missing data for calculation.\"\n \"Check for spelling and the correct combination of building age and construction type.\"\n \"Here is the list of faulty entries:\\n%s\"\n \"\\nThese entries can easily be found checking the stated index in the produced ZonedInput.xlsx\"\n % (\n group[\"zone\"].iloc[0],\n element.name,\n group[\"OuterWallConstruction\"].iloc[0],\n group,\n )\n )\n\n bldg = Building(parent=project)\n bldg.name = building_name\n bldg.year_of_construction = construction_age\n bldg.with_ahu = True # HardCodedInput\n if bldg.with_ahu is True:\n bldg.central_ahu.heat_recovery = True # HardCodedInput\n bldg.central_ahu.efficiency_recovery = 0.35 # HardCodedInput\n bldg.central_ahu.temperature_profile = 25 * [273.15 + 18] # HardCodedInput\n bldg.central_ahu.min_relative_humidity_profile = 25 * [0] # HardCodedInput\n bldg.central_ahu.max_relative_humidity_profile = 25 * [1] # HardCodedInput\n bldg.central_ahu.v_flow_profile = 25 * [1] # HardCodedInput\n\n # Parameters that need hard coding in teasers logic classes\n # 1. \"use_set_back\" needs hard coding at aixlib.py in the init; defines\n # if the in the useconditions stated\n # heating_time with the respective set_back_temp should be applied.\n # use_set_back = false -> all hours of the day\n # have same set_temp_heat actual value: use_set_back = Check your current version!\n # 2. HeaterOn, CoolerOn, hHeat, lCool, etc. can be hard coded in the text\n # file\n # \"teaser / data / output / modelicatemplate / AixLib /\n # AixLib_ThermalZoneRecord_TwoElement\"\n # actual changes: Check your current version!\n\n # Parameters to be set for each and every zone (#HardCodedInput)\n # -----------------------------\n out_wall_tilt = 90\n window_tilt = 90\n ground_floor_tilt = 0\n floor_tilt = 0\n ceiling_tilt = 0\n rooftop_tilt = 0\n ground_floor_orientation = -2\n floor_orientation = -2\n rooftop_orientation = -1\n ceiling_orientation = -1\n # -----------------------------\n\n # load_building_data from excel_to_pandas DataFrame:\n data = import_data(path_to_excel, sheet_names)\n\n # informative print\n usage_types = get_list_of_present_entries(data[\"UsageType\"])\n print(\"List of present usage_types in the original Data set: \\n%s\" % usage_types)\n\n # define the zoning methodology/function\n data = zoning_example(data)\n\n # informative print\n usage_types = get_list_of_present_entries(data[\"Zone\"])\n print(\"List of zones after the zoning is applied: \\n%s\" % usage_types)\n\n # aggregate all rooms of each zone and for each set general parameter,\n # boundary conditions\n # and parameter regarding the building physics\n zones = data.groupby([\"Zone\"])\n for name, zone in zones:\n\n # Block: Thermal zone (general parameter)\n tz = ThermalZone(parent=bldg)\n tz.name = str(name)\n tz.area = zone[\"NetArea[m²]\"].sum()\n # room vice calculation of volume plus summing those\n tz.volume = (\n np.array(zone[\"NetArea[m²]\"]) * np.array(zone[\"HeatedRoomHeight[m]\"])\n ).sum()\n\n # Block: Boundary Conditions\n # load UsageOperationTime, Lighting, RoomClimate and InternalGains\n # from the \"UseCondition.json\"\n tz.use_conditions = UseConditions(parent=tz)\n tz.use_conditions.load_use_conditions(zone[\"Zone\"].iloc[0], project.data)\n\n # Block: Building Physics\n # Grouping by orientation and construction type\n # aggregating and feeding to the teaser logic classes\n grouped = zone.groupby([\"OuterWallOrientation[°]\", \"OuterWallConstruction\"])\n for name, group in grouped:\n # looping through a groupby object automatically discards the\n # groups where one of the attributes is nan\n # additionally check for strings, since the value must be of type\n # int or float\n if not isinstance(group[\"OuterWallOrientation[°]\"].iloc[0], str):\n out_wall = OuterWall(parent=tz)\n out_wall.name = (\n \"outer_wall_\"\n + str(int(group[\"OuterWallOrientation[°]\"].iloc[0]))\n + \"_\"\n + str(group[\"OuterWallConstruction\"].iloc[0])\n )\n out_wall.area = group[\"OuterWallArea[m²]\"].sum()\n out_wall.tilt = out_wall_tilt\n out_wall.orientation = group[\"OuterWallOrientation[°]\"].iloc[0]\n # load wall properties from \"TypeBuildingElements.json\"\n out_wall.load_type_element(\n year=bldg.year_of_construction,\n construction=group[\"OuterWallConstruction\"].iloc[0],\n )\n warn_constructiontype(out_wall)\n else:\n warnings.warn(\n 'In zone \"%s\" the OuterWallOrientation \"%s\" is '\n \"neither float nor int, \"\n \"hence this building element is not added.\\nHere is the \"\n \"list of faulty entries:\\n%s\"\n \"\\n These entries can easily be found checking the stated \"\n \"index in the produced ZonedInput.xlsx\"\n % (\n group[\"Zone\"].iloc[0],\n group[\"OuterWallOrientation[°]\"].iloc[0],\n group,\n )\n )\n\n grouped = zone.groupby([\"WindowOrientation[°]\", \"WindowConstruction\"])\n for name, group in grouped:\n # looping through a groupby object automatically discards the\n # groups where one of the attributes is nan\n # additionally check for strings, since the value must be of type\n # int or float\n if not isinstance(group[\"OuterWallOrientation[°]\"].iloc[0], str):\n window = Window(parent=tz)\n window.name = (\n \"window_\"\n + str(int(group[\"WindowOrientation[°]\"].iloc[0]))\n + \"_\"\n + str(group[\"WindowConstruction\"].iloc[0])\n )\n window.area = group[\"WindowArea[m²]\"].sum()\n window.tilt = window_tilt\n window.orientation = group[\"WindowOrientation[°]\"].iloc[0]\n # load wall properties from \"TypeBuildingElements.json\"\n window.load_type_element(\n year=bldg.year_of_construction,\n construction=group[\"WindowConstruction\"].iloc[0],\n )\n warn_constructiontype(window)\n else:\n warnings.warn(\n 'In zone \"%s\" the window orientation \"%s\" is neither '\n \"float nor int, \"\n \"hence this building element is not added. Here is the \"\n \"list of faulty entries:\\n%s\"\n \"\\nThese entries can easily be found checking the stated \"\n \"index in the produced ZonedInput.xlsx\"\n % (\n group[\"Zone\"].iloc[0],\n group[\"WindowOrientation[°]\"].iloc[0],\n group,\n )\n )\n\n grouped = zone.groupby([\"IsGroundFloor\", \"FloorConstruction\"])\n for name, group in grouped:\n if group[\"NetArea[m²]\"].sum() != 0: # to avoid devision by 0\n if group[\"IsGroundFloor\"].iloc[0] == 1:\n ground_floor = GroundFloor(parent=tz)\n ground_floor.name = \"ground_floor\" + str(\n group[\"FloorConstruction\"].iloc[0]\n )\n ground_floor.area = group[\"NetArea[m²]\"].sum()\n ground_floor.tilt = ground_floor_tilt\n ground_floor.orientation = ground_floor_orientation\n # load wall properties from \"TypeBuildingElements.json\"\n ground_floor.load_type_element(\n year=bldg.year_of_construction,\n construction=group[\"FloorConstruction\"].iloc[0],\n )\n warn_constructiontype(ground_floor)\n elif group[\"IsGroundFloor\"].iloc[0] == 0:\n floor = Floor(parent=tz)\n floor.name = \"floor\" + str(group[\"FloorConstruction\"].iloc[0])\n floor.area = group[\"NetArea[m²]\"].sum() / 2 # only half of\n # the floor belongs to this story\n floor.tilt = floor_tilt\n floor.orientation = floor_orientation\n # load wall properties from \"TypeBuildingElements.json\"\n floor.load_type_element(\n year=bldg.year_of_construction,\n construction=group[\"FloorConstruction\"].iloc[0],\n )\n warn_constructiontype(floor)\n else:\n warnings.warn(\n \"Values for IsGroundFloor have to be either 0 or 1, \"\n \"for no or yes respectively\"\n )\n else:\n warnings.warn(\n 'zone \"%s\" with IsGroundFloor \"%s\" and construction '\n 'type \"%s\" '\n \"has no floor nor groundfloor, since the area equals 0.\"\n % (\n group[\"Zone\"].iloc[0],\n group[\"IsGroundFloor\"].iloc[0],\n group[\"FloorConstruction\"].iloc[0],\n )\n )\n\n grouped = zone.groupby([\"IsRooftop\", \"CeilingConstruction\"])\n for name, group in grouped:\n if group[\"NetArea[m²]\"].sum() != 0: # to avoid devision by 0\n if group[\"IsRooftop\"].iloc[0] == 1:\n rooftop = Rooftop(parent=tz)\n rooftop.name = \"rooftop\" + str(group[\"CeilingConstruction\"].iloc[0])\n rooftop.area = group[\n \"NetArea[m²]\"\n ].sum() # sum up area of respective\n # rooftop parts\n rooftop.tilt = rooftop_tilt\n rooftop.orientation = rooftop_orientation\n # load wall properties from \"TypeBuildingElements.json\"\n rooftop.load_type_element(\n year=bldg.year_of_construction,\n construction=group[\"CeilingConstruction\"].iloc[0],\n )\n warn_constructiontype(rooftop)\n elif group[\"IsRooftop\"].iloc[0] == 0:\n ceiling = Ceiling(parent=tz)\n ceiling.name = \"ceiling\" + str(group[\"CeilingConstruction\"].iloc[0])\n ceiling.area = group[\"NetArea[m²]\"].sum() / 2 # only half\n # of the ceiling belongs to a story,\n # the other half to the above\n ceiling.tilt = ceiling_tilt\n ceiling.orientation = ceiling_orientation\n # load wall properties from \"TypeBuildingElements.json\"\n ceiling.load_type_element(\n year=bldg.year_of_construction,\n construction=group[\"CeilingConstruction\"].iloc[0],\n )\n warn_constructiontype(ceiling)\n else:\n warnings.warn(\n \"Values for IsRooftop have to be either 0 or 1, \"\n \"for no or yes respectively\"\n )\n else:\n warnings.warn(\n 'zone \"%s\" with IsRooftop \"%s\" and construction type '\n '\"%s\" '\n \"has no ceiling nor rooftop, since the area equals 0.\"\n % (\n group[\"Zone\"].iloc[0],\n group[\"IsRooftop\"].iloc[0],\n group[\"CeilingConstruction\"].iloc[0],\n )\n )\n\n grouped = zone.groupby([\"InnerWallConstruction\"])\n for name, group in grouped:\n if group[\"InnerWallArea[m²]\"].sum() != 0: # to avoid devision by 0\n in_wall = InnerWall(parent=tz)\n in_wall.name = \"inner_wall\" + str(\n group[\"InnerWallConstruction\"].iloc[0]\n )\n in_wall.area = group[\"InnerWallArea[m²]\"].sum() / 2 # only\n # half of the wall belongs to each room,\n # the other half to the adjacent\n # load wall properties from \"TypeBuildingElements.json\"\n in_wall.load_type_element(\n year=bldg.year_of_construction,\n construction=group[\"InnerWallConstruction\"].iloc[0],\n )\n warn_constructiontype(in_wall)\n else:\n warnings.warn(\n 'zone \"%s\" with inner wall construction \"%s\" has no '\n \"inner walls, since area = 0.\"\n % (group[\"Zone\"].iloc[0], group[\"InnerWallConstructio\" \"n\"].iloc[0])\n )\n\n # Block: AHU and infiltration #Attention hard coding\n # set the supply volume flow of the AHU per zone\n ahu_dict = {\n \"Bedroom\": [15.778, 15.778],\n \"Corridorsinthegeneralcarearea\": [5.2941, 5.2941],\n \"Examinationortreatmentroom\": [15.743, 15.743],\n \"MeetingConferenceseminar\": [16.036, 16.036],\n \"Stocktechnicalequipmentarchives\": [20.484, 20.484],\n \"WCandsanitaryroomsinnonresidentialbuildings\": [27.692, 27.692],\n }\n _i = 0\n for key in ahu_dict:\n if tz.name == key:\n tz.use_conditions.min_ahu = ahu_dict[key][0]\n tz.use_conditions.max_ahu = ahu_dict[key][1]\n _i = 1\n if _i == 0:\n warnings.warn(\n \"The zone %s could not be found in your ahu_dict. Hence, \"\n \"no AHU flow is defined. The default value is \"\n \"0 (min_ahu = 0; max_ahu=0\" % tz.name\n )\n\n return project, data","def read_sheet(workbook, name):\n\n sheet = workbook.sheet_by_name(name)\n\n # Number of written Rows in sheet\n r = sheet.nrows\n # Number of written Columns in sheet\n c = sheet.ncols\n\n data = np.zeros([r - 1, c])\n # Reading each cell in excel sheet 'BC'\n for i in range(1, r):\n for j in range(c):\n data[i - 1, j] = float(sheet.cell_value(i, j))\n\n return data","def __load( self, raw_content ):\n return( pd.read_excel( BytesIO( raw_content ) ) )","def test_parse_samplesheet(self):\n run_dir = 'data/nanopore_data/run4/done_demuxing/20200104_1412_MN19414_AAU644_68125dc2'\n run = MinIONqc(run_dir, None, None)\n run.lims_samplesheet = 'data/nanopore_samplesheets/2020/DELIVERY_SQK-LSK109_AAU644_Samplesheet_24-594126.csv'\n run._parse_samplesheet()\n self.assertTrue(filecmp.cmp(run.nanoseq_sample_sheet, 'data/nanopore_samplesheets/expected/SQK-LSK109_sample_sheet.csv'))\n self.assertTrue(filecmp.cmp(run.anglerfish_sample_sheet, 'data/nanopore_samplesheets/expected/anglerfish_sample_sheet.csv'))","def parse_file(filename):\r\n print(filename)\r\n fh = open(filename)\r\n header = next(fh)\r\n output_file = open(\"Sex\" + \"1_\" + filename, \"a\")\r\n output_file.write(header)\r\n output_file2 = open(\"Sex\" + \"2_\" + filename, \"a\")\r\n output_file2.write(header)\r\n\r\n for line in fh:\r\n line = line.strip().split(\",\") # split by \",\" because it is a csv file\r\n line = pre_process_data(line)\r\n if int(line[2]) == 1:\r\n print(line)\r\n output_file.write(\",\".join(line) + \"\\n\")\r\n else:\r\n output_file2.write(\",\".join(line) + \"\\n\")\r\n output_file.close()\r\n output_file2.close()\r\n fh.close()","def extract(fileName, sheetName,\n rangeSpec=None, rangeName=None,\n maxRows=None, maxCols=None):\n from rlextra.thirdparty.xlrd.biffh import \\\n XL_CELL_EMPTY, XL_CELL_DATE#, XL_CELL_TEXT, XL_CELL_NUMBER, XL_CELL_BOOLEAN, XL_CELL_ERROR\n\n if rangeName is not None:\n raise NotImplementedError('rangeName not yet implemented')\n\n book = xlrd.open_workbook(fileName, verbosity=0)\n sheet = book.sheet_by_name(sheetName)\n\n if rangeSpec is not None:\n if rangeSpec.count(':') != 1:\n raise ValueError(\"Bad Excel cell range: %r\" % rangeSpec)\n cell1, cell2 = [xlCellSpecToCoord(cellSpec) for cellSpec in rangeSpec.split(\":\")]\n cols = cell1[0], cell2[0]\n rows = cell1[1], cell2[1]\n colMin, colMax = min(cols), max(cols)+1\n rowMin, rowMax = min(rows), max(rows)+1\n\n if rangeSpec is None and rangeName is None:\n rowMin = colMin = 0\n rowMax = sheet.nrows+1\n colMax = sheet.ncols+1\n\n if maxCols is not None:\n colMax = min(colMax, maxCols)\n if maxRows is not None:\n rowMax = min(rowMax, maxRows)\n\n out = []\n for rowx in range(rowMin, rowMax):\n row = []\n for colx in range(colMin, colMax):\n cellType = sheet.cell_type(rowx, colx)\n cellValue = sheet.cell_value(rowx, colx)\n\n if cellType is XL_CELL_EMPTY:\n cellValue = None\n elif cellType is XL_CELL_DATE:\n #convert\n yyyy,mm,dd,hh,nn,ss = xlrd.xldate_as_tuple(cellValue, book.datemode)\n cellValue = datetime.date(yyyy,mm,dd)\n else:\n pass #native value is OK\n\n row.append(cellValue)\n #now trim empties off the row - we don't want extra stuff on the\n #right, which might be hundreds of rows.\n \n while row and row[-1] is None:\n row.pop()\n\n out.append(row)\n\n #now trim off any blank rows at the end\n while out[-1:] == []:\n out.pop()\n return out","def parse(filename):\n if filename.endswith('.tsv'):\n # Horrible filename-based hack; in future examine contents of file here\n return parse_separated(filename, '\\t')\n if filename.endswith('.xlsx'):\n return parse_xlsx(filename)\n # fallback to old assume-csv behavior\n return parse_separated(filename, ',')","def main():\n data_dir = \".\\\\excel\\\\data\\\\\"\n archive_dir = \".\\\\excel\\\\archive\\\\\"\n xl_list = glob.glob(data_dir + \"*.xlsx\")\n\n try:\n for xl_file in xl_list:\n workbook = pd.ExcelFile(xl_file)\n\n if fnmatch.fnmatch(xl_file.lower(), \"*base*.xlsx\") == True:\n print(f\"Creating DataFrame for '{xl_file}'...\")\n \n df_base = workbook.parse(0, skiprows=1, header=None)\n df_base.columns = [\"dept\", \n \"category\", \n \"itemDesc\", \n \"itemCode\", \n \"itemSize\", \n \"pvtLblFlag\", \n \"buyerCode\", \n \"invUnitShipped\", \n \"invCaseShipped\", \n \"storeOrdProdQty\", \n \"shortedQty\", \n \"grossSvcLvl\", \n \"netSvcLvl\"]\n df_base[\"itemCode\"] = df_base[\"itemCode\"].map('{:0>6}'.format)\n df_base[\"buyerCode\"] = df_base[\"buyerCode\"] * 10\n df_base[\"itemDesc\"] = df_base[\"itemDesc\"] + \" \" + df_base[\"itemSize\"]\n \n print(f\"'{xl_file}' Successfully processed\\n\") \n elif fnmatch.fnmatch(xl_file.lower(), \"*short*.xlsx\") == True:\n print(f\"Creating DataFrame for '{xl_file}'...\")\n \n df_shorts = workbook.parse(0, skiprows=1, header=None)\n df_shorts.columns = [\"itemDesc\", \n \"itemCode\", \n \"yesterdayOOS\"]\n df_shorts[\"itemCode\"] = df_shorts[\"itemCode\"].map('{:0>6}'.format)\n df_shorts.drop(columns=[\"itemDesc\"], inplace=True)\n \n print(f\"'{xl_file}' Successfully processed\\n\") \n elif fnmatch.fnmatch(xl_file.lower(), \"*reason*.xlsx\") == True:\n print(f\"Creating DataFrame for '{xl_file}'...\")\n \n df_reason = workbook.parse(0, skiprows=2, header=None)\n df_reason.columns = [\"dept\", \n \"category\", \n \"itemDesc\", \n \"itemCode\", \n \"outOfStock\", \n \"manufacIssue\",\n \"disc\",\n \"other\",\n \"newItemIssue\"]\n df_reason[\"itemCode\"] = df_reason[\"itemCode\"].map('{:0>6}'.format)\n df_reason[\"max\"] = df_reason[[df_reason.columns[4], \n df_reason.columns[5], \n df_reason.columns[6], \n df_reason.columns[7], \n df_reason.columns[8]]].max(axis=1)\n df_reason.loc[df_reason[\"max\"] == df_reason[\"outOfStock\"], \"primaryReason\"] = \"Out Of Stock\"\n df_reason.loc[df_reason[\"max\"] == df_reason[\"manufacIssue\"], \"primaryReason\"] = \"Manufacturer Issue\"\n df_reason.loc[df_reason[\"max\"] == df_reason[\"disc\"], \"primaryReason\"] = \"Discontinued\"\n df_reason.loc[df_reason[\"max\"] == df_reason[\"other\"], \"primaryReason\"] = \"Other\"\n df_reason.loc[df_reason[\"max\"] == df_reason[\"newItemIssue\"], \"primaryReason\"] = \"New Item Issue\"\n df_reason.sort_values(by=[\"max\"], ascending=False, inplace=True)\n df_reason.drop(columns=[\"dept\", \n \"category\", \n \"itemDesc\", \n \"outOfStock\", \n \"manufacIssue\", \n \"disc\", \n \"other\", \n \"newItemIssue\", \n \"max\"], inplace=True)\n \n print(f\"'{xl_file}' Successfully processed\\n\") \n elif fnmatch.fnmatch(xl_file.lower(), \"*export*.xlsx\") == True:\n print(f\"Creating DataFrame for '{xl_file}'...\")\n \n to_drop = [\"14:HATFIELD NORTH\", \"1:BRATTLEBORO\"]\n \n df_cs = workbook.parse(0, skiprows=3, skipfooter=20, header=None)\n df_cs = df_cs[~df_cs[7].isin(to_drop)]\n df_cs = df_cs.filter([0, 14, 15, 17, 34])\n df_cs.columns = [\"custCode\", \n \"poDueDate\", \n \"poApptDate\", \n \"inStock\", \n \"daysOOS\"]\n df_cs[\"itemCode\"] = df_cs[\"custCode\"].astype(str).str[9:15]\n df_cs.drop(columns=[\"custCode\"], inplace=True)\n df_cs.drop_duplicates(inplace=True)\n\n print(f\"'{xl_file}' Successfully processed\\n\")\n\n for data_file in os.listdir(data_dir):\n if fnmatch.fnmatch(data_file, \"*.xlsx\") == True:\n print(f\"Deleting '{data_file}'...\\n\")\n os.remove(data_dir + data_file)\n\n df_join_1 = df_base.merge(df_reason, how=\"left\", on=\"itemCode\")\n df_join_2 = df_join_1.merge(df_shorts, how=\"left\", on=\"itemCode\")\n df_join_3 = df_join_2.merge(df_cs, how=\"left\", on=\"itemCode\")\n \n print(\"Exporting to Excel...\\n\")\n df_join_3.to_excel(f\".\\\\excel\\\\archive\\\\oos-data-{timestamp()}.xlsx\", index=False)\n\n sys.exit(0)\n except:\n try:\n df_join_1 = df_base.merge(df_reason, how=\"left\", on=\"itemCode\")\n df_join_2 = df_join_1.merge(df_shorts, how=\"left\", on=\"itemCode\")\n\n df_join_2[\"poDueDate\"] = \"NO CS DATA\"\n df_join_2[\"poApptDate\"] = \"NO CS DATA\"\n df_join_2[\"inStock\"] = \"NO CS DATA\"\n df_join_2[\"daysOOS\"] = \"NO CS DATA\"\n \n print(\"Exporting to Excel...\\n\")\n df_join_2.to_excel(f\".\\\\excel\\\\archive\\\\oos-data-{timestamp()}.xlsx\", index=False)\n except:\n if not os.path.exists(archive_dir):\n os.makedirs(archive_dir)\n if not os.path.exists(data_dir):\n os.makedirs(data_dir)\n\n sys.exit(1)","def openData(self):\n\n\n path = QtWidgets.QFileDialog.getOpenFileName(self, 'Open File', os.getcwd(), 'CSV, XLSX(*.csv *.xlsx)')\n\n # If a file was specified, load it up. If not, tell the user to pick a valid file\n if path[0] != '':\n\n if os.path.exists(path[0]) and os.path.getsize(path[0]):\n\n filepath, filename = os.path.split(path[0])\n pandaData = procedures.load(filename, filepath)\n\n self.createTab(pandaData, name=filename)\n\n else:\n self.notifyUser(\"Please pick a valid file.\")","def _read_file(self):\n # Convert str to pathlib.Path() object.\n if isinstance(self.file_path, str):\n self.file_path = Path(self.file_path)\n\n # Check if file_path exists:\n if not self.file_path.exists():\n raise FileNotFoundError(f'File not found: {self.file_path}')\n\n # Open and read the \"xls\" file\n with open(self.file_path, encoding='windows-1252') as f:\n self.html_string = f.read()","def loadData(self):\n\n\n path = QtWidgets.QFileDialog.getOpenFileName(self, 'Open File', os.getcwd(), 'CSV, XLSX(*.csv *.xlsx)')\n\n # If a file was specified, load it up. If not, tell the user to pick a valid file\n if path[0] != '':\n\n if os.path.exists(path[0]) and os.path.getsize(path[0]):\n\n filepath, filename = os.path.split(path[0])\n pandaData = procedures.load(filename, filepath)\n\n while self.tabWidget.count() != 0:\n self.closeTab()\n self.createTab(pandaData)\n\n else:\n self.notifyUser(\"Please pick a valid file.\")"],"string":"[\n \"def test_parse_sample_sheet(self):\\n pass\",\n \"def parse_ra():\\r\\n fname = 'parse/File1.xlsx'\\r\\n sheet_name = 'Sheet1'\\r\\n\\r\\n ra_sheet = get_sheet(fname, sheet_name)\\r\\n return parse_sheet(ra_sheet)\",\n \"def parse_xlsx(filename):\\n from openpyxl import load_workbook\\n\\n workbook = load_workbook(filename=filename)\\n worksheet = workbook.get_sheet_by_name(workbook.get_sheet_names()[0])\\n row_it = worksheet.iter_rows()\\n split_row_list = ([cell.value if cell.value is not None else \\\"\\\"\\n for cell in row] for row in row_it)\\n\\n return parse_generic(split_row_list)\",\n \"def read_xlsx(self, filename):\\n xlsx = pd.ExcelFile(filename)\\n for sheet in xlsx.sheet_names:\\n table_index_header = cfg.get_list(\\\"table_index_header\\\", sheet)\\n self.input_data[sheet] = xlsx.parse(\\n sheet,\\n index_col=list(range(int(table_index_header[0]))),\\n header=list(range(int(table_index_header[1]))),\\n squeeze=(\\\"series\\\" not in sheet),\\n )\\n self.check_input_data(warning=False)\\n self.add_meta_data()\\n return self\",\n \"def parse(csv_file, xlsx_file):\\n\\n #Summary info\\n no_dsa_pattern = r'\\\\((\\\\d+)/(\\\\d+)\\\\).*don\\\\'t have Deep Security installed'\\n disable_ips_pattern = r'\\\\((\\\\d+)/(\\\\d+)\\\\).*don\\\\'t have Intrusion Prevention enabled'\\n no_rule_pattern = r'\\\\((\\\\d+)/(\\\\d+)\\\\).*don\\\\'t have rules assigned'\\n summary_patterns = re.compile('{}|{}|{}'.format(no_dsa_pattern, disable_ips_pattern, no_rule_pattern))\\n no_dsa_count = None\\n no_ips_count = None\\n no_rule_count = None\\n description = []\\n summary = [[0, 0, 0], [0, 0, 0], [0, 0, 0]]\\n\\n #Detail info\\n no_dsa_list_title = r\\\"Hosts that don't have Deep Security installed\\\"\\n disable_ips_list_title = r\\\"Hosts that have Deep Security installed but don't have Intrusion Prevention enabled\\\"\\n no_rule_list_title = r\\\"Hosts that have Intrusion Prevention enabled but no rules assigned\\\"\\n title_patterns = re.compile('({})|({})|({})'.format(no_dsa_list_title, disable_ips_list_title, no_rule_list_title))\\n no_dsa_list = []\\n no_ips_list = []\\n no_rule_list = []\\n host_list = [\\n no_dsa_list,\\n no_ips_list,\\n no_rule_list\\n ]\\n\\n #Help url\\n action_pattern = re.compile('\\\\[(.+)\\\\: (.+)\\\\]')\\n action_list = []\\n\\n\\n #Parse csv file\\n with open(csv_file, 'r', newline='') as csv_file:\\n rows = csv.reader(csv_file, quotechar='\\\"', delimiter=',', skipinitialspace=True)\\n for index, row in enumerate(rows):\\n if not row:\\n continue\\n\\n if row[0].startswith('#'):\\n description.append(row[0].replace('# ', ''))\\n continue\\n\\n search = summary_patterns.search(row[0])\\n if search:\\n current_pattern = next((i for i, x in enumerate(search.groups()) if x), None)\\n summary[int(current_pattern/2)] = ( int(search.group(current_pattern+1)), int(search.group(current_pattern+2)) - int(search.group(current_pattern+1)) )\\n continue\\n\\n search = action_pattern.search(row[0])\\n if search:\\n action_list.append((search.group(1), search.group(2)))\\n if len(action_list) == 4:\\n break\\n\\n current_pattern = -1\\n for index, row in enumerate(rows):\\n if not row or re.match('None', row[0]):\\n continue\\n\\n search = title_patterns.search(row[0])\\n if search:\\n current_pattern = next((i for i, x in enumerate(search.groups()) if x), None)\\n continue\\n\\n if current_pattern == -1:\\n continue\\n host_list[current_pattern].append(row[0])\\n\\n no_dsa_count, no_ips_count, no_rule_count = summary\\n\\n #Write xlsx file\\n workbook = xlsxwriter.Workbook(xlsx_file)\\n summary_worksheet = workbook.add_worksheet('Summary')\\n rawdata_worksheet = workbook.add_worksheet('Data')\\n no_dsa_worksheet = workbook.add_worksheet(\\\"Hosts that don't have DS\\\")\\n no_ips_worksheet = workbook.add_worksheet(\\\"Hosts that don't have IPS\\\")\\n no_rule_worksheet = workbook.add_worksheet(\\\"Hosts that don't have rules\\\")\\n\\n #Rawdata worksheet\\n data = [\\n ['', 'Deep Security installed', 'Intrusion Prevention enabled', 'rules assigned'],\\n ['Yes', no_dsa_count[1], no_ips_count[1], no_rule_count[1]],\\n ['No', no_dsa_count[0], no_ips_count[0], no_rule_count[0]]\\n ]\\n rawdata_worksheet.write_column('A1', data[0], workbook.add_format({'bold': True}))\\n rawdata_worksheet.write_column('B1', data[1])\\n rawdata_worksheet.write_column('C1', data[2])\\n\\n #No DSA install worksheet\\n no_dsa_worksheet.write_row(0, 0, [no_dsa_list_title])\\n no_dsa_worksheet.write_column(1, 0, no_dsa_list)\\n\\n #No IPS enable worksheet\\n no_ips_worksheet.write_row(0, 0, [disable_ips_list_title])\\n no_ips_worksheet.write_column(1, 0, no_ips_list)\\n\\n #No Rule worksheet\\n no_rule_worksheet.write_row(0, 0, [no_rule_list_title])\\n no_rule_worksheet.write_column(1, 0, no_rule_list)\\n\\n #Summary worksheet\\n chart = workbook.add_chart({'type': 'column', 'subtype': 'percent_stacked'})\\n chart.add_series({\\n 'name': '=Data!$B$1',\\n 'categories': '=Data!$A$2:$A$4',\\n 'values': '=Data!$B$2:$B$4',\\n 'fill': {'color': '#21BC3B'}\\n })\\n chart.add_series({\\n 'name': '=Data!$C$1',\\n 'categories': '=Data!$A$2:$A$4',\\n 'values': '=Data!$C$2:$C$4',\\n 'fill': {'color': '#C22828'}\\n })\\n chart.set_title ({'name': 'Protected hosts'})\\n chart.set_x_axis({\\n 'name': 'Status',\\n })\\n\\n chart.set_y_axis({\\n 'major_unit' : 0.2,\\n 'min' : 0,\\n 'max' : 1\\n })\\n\\n summary_worksheet.insert_chart('A1', chart)\\n summary_worksheet.write_column('A16', description)\\n for index, (text, url) in enumerate(action_list):\\n summary_worksheet.write_url('A'+str(index+20), url, string = text)\\n summary_worksheet.activate()\\n\\n workbook.close()\",\n \"def Excel_Load_Data( self, ExcelFilename ):\\n pass\",\n \"def parse_tables_xlsx(inp):\\n # --------------------------------------------------------------------------\\n # Start\\n # --------------------------------------------------------------------------\\n raw_read = pd.read_excel(inp,sheet_name = None)\\n indx = get_tab_index(raw_read)\\n # --------------------------------------------------------------------------\\n # Get the individual tables from the file\\n # --------------------------------------------------------------------------\\n tabdict = {}\\n for i in indx['tab'].to_list():\\n tabdict[i] = get_table_df(raw_read[i])\\n # --------------------------------------------------------------------------\\n # Finish\\n # --------------------------------------------------------------------------\\n out = {}\\n out['indx'] = indx\\n out['tabs'] = tabdict\\n return out\",\n \"def open_file(path):\\n book = xlrd.open_workbook(path)\\n # print number of sheets\\n #print book.nsheets\\n # print sheet names\\n #print book.sheet_names()\\n # get the first worksheet\\n first_sheet = book.sheet_by_index(0)\\n # read a row\\n #print first_sheet.row_values(0)\\n # read a cell\\n cell = first_sheet.cell(1,0)\\n #print cell\\n #print cell.value\\n # read a row slice\\n #print first_sheet.row_slice(rowx=0,start_colx=0,end_colx=2)\\n\\n \\\"\\\"\\\"\\n if Junipter.search_junipter_rule(first_sheet,1) == 0:\\n print \\\"Juniper rule doesn't match\\\"\\n else:\\n print \\\"Juniper rule match\\\"\\n \\\"\\\"\\\"\\n\\n \\\"\\\"\\\"\\n if Mitac.search_mitac_rule(first_sheet,1) == 0:\\n print \\\"Mitac rule doesn't match\\\"\\n else:\\n print \\\"Mitac rule match\\\"\\n \\\"\\\"\\\"\\n\\n if Fabrinet.search_fabrinet_rule(first_sheet,3) == 0:\\n print \\\"fabrinet rule doesn't match\\\"\\n else:\\n print \\\"fabrinet rule match\\\"\",\n \"def parseSheet(self):\\n self.log.info(\\\"Parsing {0} rows and {1} columns.\\\".format(self.rowns,self.colns))\\n \\n self.column_dimensions = {}\\n self.property_dimensions = {}\\n self.row_dimensions = {}\\n self.rowhierarchy = {}\\n\\n # Get dictionary of annotations\\n self.annotations = self.r_sheet.cell_note_map\\n \\n for i in range(0,self.rowns):\\n self.rowhierarchy[i] = {}\\n \\n for j in range(0, self.colns):\\n # Parse cell data\\n self.source_cell = self.r_sheet.cell(i,j)\\n self.source_cell_name = cellname(i,j)\\n self.style = self.styles[self.source_cell].name\\n self.cellType = self.getType(self.style)\\n self.source_cell_qname = self.getQName(self.source_cell_name)\\n \\n self.log.debug(\\\"({},{}) {}/{}: \\\\\\\"{}\\\\\\\"\\\". format(i,j,self.cellType, self.source_cell_name, self.source_cell.value))\\n\\n # Try to parse ints to avoid ugly _0 URIs\\n try:\\n if int(self.source_cell.value) == self.source_cell.value:\\n self.source_cell.value = int(self.source_cell.value)\\n except ValueError:\\n self.log.debug(\\\"(%s.%s) No parseable int\\\" % (i,j))\\n\\n \\n # Parse annotation (if any)\\n if self.config.get('annotations', 'enabled') == \\\"1\\\":\\n if (i,j) in self.annotations:\\n self.parseAnnotation(i, j)\\n\\n # Parse cell even if empty\\n if self.cellType == 'Data':\\n self.parseData(i, j)\\n elif (self.cellType == 'HRowHeader') :\\n self.updateRowHierarchy(i, j)\\n elif self.cellType == 'ColHeader' :\\n self.parseColHeader(i, j)\\n elif self.cellType == 'RowProperty' :\\n self.parseRowProperty(i, j)\\n \\n # If cell not empty, check for more types\\n if not self.isEmpty(i,j) :\\n #self.graph.add((self.namespaces['scope'][self.source_cell_qname],RDF.type,self.namespaces['tablink'][self.cellType]))\\n #self.graph.add((self.namespaces['scope'][self.source_cell_qname],self.namespaces['tablink']['cell'],Literal(self.source_cell_name)))\\n #self.graph.add((self.namespaces['scope'][self.source_cell_qname],self.namespaces['tablink']['col'],Literal(colname(j))))\\n #self.graph.add((self.namespaces['scope'][self.source_cell_qname],self.namespaces['tablink']['row'],Literal(i+1)))\\n #self.graph.add((self.namespaces['scope'][self.source_cell_qname] isrow row\\n if self.cellType == 'Title' :\\n self.parseTitle(i, j)\\n \\n elif self.cellType == 'RowHeader' :\\n self.parseRowHeader(i, j)\\n \\n elif self.cellType == 'HRowHeader' :\\n self.parseHierarchicalRowHeader(i, j)\\n \\n elif self.cellType == 'RowLabel' :\\n self.parseRowLabel(i, j)\\n \\n # Add additional information about the hierarchy of column headers\\n for value in self.column_dimensions.values():\\n for index in range(1, len(value)):\\n uri_sub = self.getColHeaderValueURI(value[:index+1])\\n uri_top = self.getColHeaderValueURI(value[:index])\\n self.graph.add((uri_sub, self.namespaces['tablink']['subColHeaderOf'], uri_top))\\n self.graph.add((uri_sub, self.namespaces['tablink']['depth'], Literal(index)))\\n self.graph.add((uri_top, self.namespaces['tablink']['depth'], Literal(index-1)))\\n \\n self.log.info(\\\"Done parsing...\\\")\",\n \"def read_excel_file(self):\\n self.df = pd.read_excel(str(self.file_path))\\n self.data_mat=np.array(self.df).astype(float).transpose()\",\n \"def parse_csv(filename):\\n cases = []\\n\\n with open(filename) as file:\\n # Read the rest of the lines\\n for line in file:\\n cases.append(Case(line))\\n\\n return cases\",\n \"def getCaseData(filename):\\n filename = filename\\n casedata = pd.read_table(filename, sep=',', skiprows=3, parse_dates=True, \\\\\\n infer_datetime_format=True, index_col=0, na_filter=False, \\\\\\n names=[\\\"time\\\", \\\"value\\\", \\\"flag\\\"], true_values=['M'], false_values=[''])\\n return casedata\",\n \"def parse_xlsx_sheet(f, n=0):\\n xl_file = pd.ExcelFile(f)\\n dfs = xl_file.parse(xl_file.sheet_names[n], na_values=['n.a.', 'n.d.'])\\n return dfs\",\n \"def read_excel_file(self):\\n self.df = pd.read_excel(str(self.file_path))\\n self.data_mat=np.array(self.df).astype(float)\",\n \"def parse_files(self):\\n \\\"\\\"\\\" @param name: name of the file \\\"\\\"\\\"\\n \\\"\\\"\\\" @type name: string \\\"\\\"\\\"\\n df = pd.DataFrame()\\n if not self.xlfnames:\\n self.producer(\\\"THESS_ENV_CITYOFTHESS_DAILY_YEARLY_DATA_ERROR\\\", 'data source not found or cannot be open')\\n logging.error('error happened: no excel files found')\\n return False\\n for fileName in self.xlfnames:\\n try:\\n xlfname = self.folder + '/' + fileName #\\n xl = pd.ExcelFile(xlfname)\\n except Exception as e:\\n self.producer(\\\"THESS_ENV_CITYOFTHESS_DAILY_YEARLY_DATA_ERROR\\\",\\n 'data source not found or cannot be open', e)\\n return False\\n try:\\n # code for one file per sheet\\n # for sheet in xl.sheet_names:\\n # self.parse_sheet(xl,sheet)\\n\\n # code for one file for all\\n for sheet in xl.sheet_names:\\n df_tmp = self.parse_sheet_to_df(xl, sheet, df)\\n df = df.append(df_tmp, ignore_index=True)\\n except Exception as e:\\n self.producer(\\\"THESS_ENV_CITYOFTHESS_DAILY_YEARLY_DATA_ERROR\\\", 'data source format is not as expected',\\n e)\\n return False\\n return self.write_to_file(df)\",\n \"def load_from_excel(self, excel_fp: str):\\n # TODO:\\n pass\",\n \"def read_data(filename):\\n \\n # Iterate over all X-values. Y-values are stored in colummns of particular worksheet\\n for x in range(0,13):\\n\\n wb = xlrd.open_workbook(filename)\\n ws = wb.sheet_by_index(0)\\n\\n # This position of metadata doesn't change its relative position from sheet-to-sheet\\n n_energy = int(ws.cell_value(1,3))\\n n_iter = int(ws.cell_value(4,3))\\n Rows_to_Skip = 15\\n\\n # Rename columns\\n column_names = [str(x) for x in range(0,n_iter)]\\n column_names.insert(0,'nan')\\n column_names.insert(0,'KE')\\n\\n # Read data using pandas\\n df_data = pd.read_excel(io = filename,\\n sheet_name=x,\\n skiprows = Rows_to_Skip,\\n names = column_names,\\n index_col='KE'\\n )\\n # Drop the second column as it is always supposed to be false\\n df_data.drop(columns=df_data.columns[0],inplace=True)\\n \\n # Get x_data as the index \\n x_array = np.array(df_data.index).reshape(len(df_data.index),1)\\n \\n # If we encounter first sheet\\n if x==0:\\n y = df_data.to_numpy()\\n \\n # Stack with the cummulative y built till now\\n else:\\n y = np.hstack((y, df_data.to_numpy()))\\n \\n # Ideally x_array should be (481, 1), and y should be (481, 169)\\n return x_array, y\",\n \"def start_parse(self, file_path, data=None):\\n with open_xlsb(file_path) as wb:\\n\\n cols = []\\n data_frame = []\\n with wb.get_sheet(data) as sheet:\\n for row in sheet.rows():\\n l = [item.v for item in row]\\n if not cols:\\n cols = l\\n data_frame.append(l)\\n\\n data_frame = pd.DataFrame(data_frame[1:], columns=data_frame[0])\\n data = data_frame.to_dict(\\\"split\\\")[\\\"data\\\"]\\n\\n parsable = []\\n for d in data:\\n for i in d:\\n if str(i) == \\\"nan\\\" and math.isnan(i):\\n return None\\n parsable.append(dict(zip(cols, d)))\\n\\n return json.dumps(parsable)\",\n \"def import_data(self):\\n\\n self.worksheet = (\\n xlrd.open_workbook(filename=self.source).sheet_by_index(0)\\n )\\n # Import conversion data from worksheet and store as scipy arrays\\n self.T_exp = np.array(\\n self.worksheet.col_values(0, start_rowx=4, end_rowx=None)\\n ) + 273.15\\n self.HCout_raw = np.array(\\n self.worksheet.col_values(4, start_rowx=4, end_rowx=None)\\n )\\n self.HCin_raw = np.array(\\n self.worksheet.col_values(8, start_rowx=4, end_rowx=None)\\n )\\n self.eta_exp = (\\n (self.HCin_raw - self.HCout_raw) / self.HCin_raw\\n )\\n self.T_model = np.linspace(\\n self.T_exp[0] - 50, self.T_exp[-1] + 50, 25\\n )\\n self.T_array = self.T_model\",\n \"def readxl(df, file_name):\\r\\n print( 'reading the excel file') \\r\\n df = pd.read_excel(file_name, sheet_name = 'Sheet1')\\r\\n df.columns = [x.strip('/s+').lower().replace(' ','_').replace('.','_') for x in df.columns]\\r\\n print('list of columns of data frame ')\\r\\n print(df.columns)\\r\\n print('shape of data frame')\\r\\n print(df.shape)\\r\\n print('reading excel file completed')\\r\\n return(df)\",\n \"def extract(self):\\n \\n print('Extracting Metrics data... ',end=''),\\n self.df = pd.read_excel(self.file_path, index_col=0)\\n print('Done')\",\n \"def parse_cases(raw_data_file: str, source_id: str, source_url: str):\\n with open(raw_data_file, \\\"r\\\") as f:\\n reader = csv.DictReader(f, delimiter=\\\";\\\")\\n for row in reader:\\n if row[_CLASSIFICATION] == \\\"Confirmados\\\":\\n try:\\n case = {\\n \\\"caseReference\\\": {\\\"sourceId\\\": source_id, \\\"sourceUrl\\\": source_url},\\n \\\"location\\\": {\\n \\\"query\\\": \\\", \\\".join(\\n [row[_MUNICIPALITY], \\\"Espirito Santo\\\", \\\"Brazil\\\"]\\n )\\n },\\n \\\"events\\\": convert_events(\\n row[_DATE_CONFIRMED],\\n row[_PCR],\\n row[_SEROLOGICAL_METHOD1],\\n row[_SEROLOGICAL_METHOD2],\\n row[_SEROLOGICAL_METHOD3],\\n row[_TEST_CLASS],\\n row[_OUTCOME],\\n row[_DATE_DEATH],\\n row[_HOSPITALIZED]\\n ),\\n \\\"symptoms\\\": convert_symptoms(\\n row[_HEADACHE],\\n row[_SORE_THROAT],\\n row[_FEVER],\\n row[_COUGH],\\n row[_DIARRHOEA],\\n row[_DIFFICULTY_BREATHING]\\n ),\\n \\\"demographics\\\": convert_demographics(\\n row[_GENDER], row[_AGE], row[_ETHNICITY], row[_HEALTHCARE_PROFESSIONAL]\\n ),\\n }\\n case[\\\"preexistingConditions\\\"] = convert_preexisting_conditions(\\n row[_LUNG], row[_KIDNEY], row[_DIABETES], row[_CARDIOVASCULAR], row[_OBESITY]\\n )\\n notes = convert_notes(\\n row[_CORYZA],\\n row[_SMOKER],\\n row[_HOMELESS],\\n row[_NEIGHBOURHOOD],\\n row[_DISABILITY],\\n row[_INTERNAL_TRAVEL],\\n row[_INTERNATIONAL_TRAVEL],\\n row[_SCHOOLING]\\n )\\n if notes:\\n case[\\\"restrictedNotes\\\"] = notes\\n yield case\\n except ValueError as ve:\\n raise ValueError(f\\\"error converting case: {ve}\\\")\",\n \"def process_xlsx(content):\\n data = {}\\n workbook = xlrd.open_workbook(file_contents=content)\\n worksheets = [w for w in workbook.sheet_names() if not w.startswith('_')]\\n for worksheet_name in worksheets:\\n if worksheet_name.startswith('_'):\\n continue\\n\\n worksheet = workbook.sheet_by_name(worksheet_name)\\n\\n merged_cells = worksheet.merged_cells\\n if len(merged_cells):\\n raise MergedCellError(worksheet.name, merged_cells)\\n\\n worksheet.name = slughifi(worksheet.name)\\n headers = make_headers(worksheet)\\n worksheet_data = make_worksheet_data(headers, worksheet)\\n data[worksheet.name] = worksheet_data\\n return data\",\n \"def process_data(self, excel_file, output_title):\\n df = read_excel(excel_file)\\n labels = df.columns.values.tolist()\\n title = f\\\"{labels[1]} vs {labels[0]}\\\"\\n data = []\\n for label in labels:\\n data.append(df[label].values.tolist())\\n\\n for callback in self.callbacks:\\n callback(title, data, labels, output_title)\",\n \"def get_xls(xls_name, sheet_name):\\n cls = []\\n # get xls file's path\\n xlsPath = os.path.join(proDir, \\\"testFile\\\", 'case', xls_name)\\n # open xls file\\n file = open_workbook(xlsPath)\\n # get sheet by name\\n sheet = file.sheet_by_name(sheet_name)\\n # get one sheet's rows\\n nrows = sheet.nrows\\n for i in range(nrows):\\n if sheet.row_values(i)[0] != u'case_name':\\n cls.append(sheet.row_values(i))\\n return cls\",\n \"def main():\\n\\n era = dt.datetime.now()\\n\\n parser = xlslisp_compile_argdoc()\\n args = parser.parse_args()\\n\\n space = os.path.splitext(args.file)[0]\\n\\n # Import the Values of Sheets of one Xlsx File\\n\\n sheet_by_name = openpyxl.load_workbook(args.file, data_only=True)\\n sheet_by_name_keys_list = sheet_by_name.sheetnames\\n\\n stderr_print(\\n \\\"xlslisp: reading {} sheets from: {}\\\".format(\\n len(sheet_by_name_keys_list), args.file\\n )\\n )\\n\\n # Option to quit early\\n\\n if not args.force:\\n stderr_print(\\n \\\"xlslisp.py: Xlsx imported, run again with --force to replace Csv's\\\"\\n )\\n\\n sys.exit(1)\\n\\n # Visit each Sheet\\n\\n for (index, sheetname) in enumerate(sheet_by_name_keys_list):\\n sheet = sheet_by_name[sheetname]\\n\\n csv_name = \\\"{space}-{dashed_sheet}.csv\\\".format(\\n space=space, dashed_sheet=sheetname.replace(\\\" \\\", \\\"-\\\")\\n ).lower()\\n\\n # Collect Rows of String Values\\n\\n csv_ragged_rows = list()\\n for row_index in range(sheet.max_row):\\n row_mark = 1 + row_index\\n\\n csv_cells = list()\\n\\n for col_index in range(sheet.max_column):\\n cell = sheet.cell(1 + row_index, 1 + col_index)\\n col_mark = cell.column_letter\\n assert col_mark == excel_az_mark(col_index)\\n\\n if False:\\n if (col_mark, row_mark) == (\\\"C\\\", 89):\\n pdb.set_trace()\\n\\n csv_cells.append(cell.value)\\n\\n # Warn of trailing spaces\\n\\n if str(csv_cells[-1]).endswith(\\\" \\\"):\\n stderr_print(\\n \\\"xlslisp: Warning: \\\"\\n \\\"could rstrip cell at: {!r}!{}{} {}\\\".format(\\n sheetname, col_mark, row_mark, csv_cells[-1]\\n )\\n )\\n\\n csv_ragged_rows.append(csv_cells)\\n\\n # Format as rectangular Csv to please GitHub\\n #\\n # per GitHub > Rendering CSV and TSV data\\n # flagging ragged as \\\"we can make this file beautiful and searchable\\\"\\n #\\n\\n csv_rows = rows_complete(csv_ragged_rows, cell=None)\\n\\n charstream = io.StringIO()\\n csv_writer = csv.writer(charstream)\\n for csv_cells in csv_rows:\\n csv_writer.writerow(csv_cells)\\n\\n charstream.seek(0)\\n csv_chars = charstream.read()\\n\\n # Write the lines with local \\\"os.linesep\\\" line-ending's\\n # specifically Not the mix of \\\"\\\\r\\\\n\\\" and \\\"\\\\n\\\" from multi-line Excel cells\\n # but without rstrip'ping the lines # TODO: poor choice to skip rstrip?\\n\\n csv_lines = csv_chars.splitlines()\\n csv_joined = \\\"\\\\n\\\".join(csv_lines) + \\\"\\\\n\\\"\\n\\n stderr_print(\\n \\\"xlslisp: writing {} chars of {} rows to: {}\\\".format(\\n len(csv_joined), sheet.max_row, csv_name\\n )\\n )\\n\\n with open(csv_name, \\\"w\\\") as csv_writing:\\n csv_writing.write(csv_joined)\\n\\n now = dt.datetime.now()\\n stderr_print(\\\"xlslisp: elapsed time of\\\", (now - era), \\\"since\\\", era)\\n\\n sys.exit(0)\",\n \"def parse(instr):\\n # TODO: a spreadsheet should really be an object and cellval a method\\n global DATA, MESSAGES, CURRENT_ROW\\n DATA = {}\\n MESSAGES = []\\n CURRENT_ROW = None\\n\\n updated = {}\\n parse_gspreadsheet(instr, updated)\\n # find header row: look for \\\"opportunity title\\\" (case insensitive)\\n find_header_row('opportunity\\\\s*title')\\n if not HEADER_ROW or not HEADER_STARTCOL:\\n return len(MESSAGES), DATA, MESSAGES, [], []\\n\\n header_colidx = {}\\n header_names = {}\\n header_col = HEADER_STARTCOL\\n while True:\\n header_str = cellval(HEADER_ROW, header_col)\\n if not header_str:\\n break\\n field_name = None\\n header_str = header_str.lower()\\n if header_str.find(\\\"title\\\") >= 0:\\n field_name = \\\"OpportunityTitle\\\"\\n elif header_str.find(\\\"organization\\\") >= 0 and \\\\\\n header_str.find(\\\"sponsor\\\") >= 0:\\n field_name = \\\"SponsoringOrganization\\\"\\n elif header_str.find(\\\"description\\\") >= 0:\\n field_name = \\\"Description\\\"\\n elif header_str.find(\\\"skills\\\") >= 0:\\n field_name = \\\"Skills\\\"\\n elif header_str.find(\\\"location\\\") >= 0 and header_str.find(\\\"name\\\") >= 0:\\n field_name = \\\"LocationName\\\"\\n elif header_str.find(\\\"street\\\") >= 0:\\n field_name = \\\"LocationStreet\\\"\\n elif header_str.find(\\\"city\\\") >= 0:\\n field_name = \\\"LocationCity\\\"\\n elif header_str.find(\\\"state\\\") >= 0 or header_str.find(\\\"province\\\") >= 0:\\n field_name = \\\"LocationProvince\\\"\\n elif header_str.find(\\\"zip\\\") >= 0 or header_str.find(\\\"postal\\\") >= 0:\\n field_name = \\\"LocationPostalCode\\\"\\n elif header_str.find(\\\"country\\\") >= 0:\\n field_name = \\\"LocationCountry\\\"\\n elif header_str.find(\\\"start\\\") >= 0 and header_str.find(\\\"date\\\") >= 0:\\n field_name = \\\"StartDate\\\"\\n elif header_str.find(\\\"start\\\") >= 0 and header_str.find(\\\"time\\\") >= 0:\\n field_name = \\\"StartTime\\\"\\n elif header_str.find(\\\"end\\\") >= 0 and header_str.find(\\\"date\\\") >= 0:\\n field_name = \\\"EndDate\\\"\\n elif header_str.find(\\\"end\\\") >= 0 and header_str.find(\\\"time\\\") >= 0:\\n field_name = \\\"EndTime\\\"\\n elif header_str.find(\\\"contact\\\") >= 0 and header_str.find(\\\"name\\\") >= 0:\\n field_name = \\\"ContactName\\\"\\n elif header_str.find(\\\"email\\\") >= 0 or header_str.find(\\\"e-mail\\\") >= 0:\\n field_name = \\\"ContactEmail\\\"\\n elif header_str.find(\\\"phone\\\") >= 0:\\n field_name = \\\"ContactPhone\\\"\\n elif header_str.find(\\\"website\\\") >= 0 or header_str.find(\\\"url\\\") >= 0:\\n field_name = \\\"URL\\\"\\n elif header_str.find(\\\"often\\\") >= 0:\\n field_name = \\\"Frequency\\\"\\n elif header_str.find(\\\"days\\\") >= 0 and header_str.find(\\\"week\\\") >= 0:\\n field_name = \\\"DaysOfWeek\\\"\\n elif header_str.find(\\\"paid\\\") >= 0:\\n field_name = \\\"Paid\\\"\\n elif header_str.find(\\\"commitment\\\") >= 0 or header_str.find(\\\"hours\\\") >= 0:\\n field_name = \\\"CommitmentHours\\\"\\n elif header_str.find(\\\"age\\\") >= 0 and header_str.find(\\\"min\\\") >= 0:\\n field_name = \\\"MinimumAge\\\"\\n elif header_str.find(\\\"kid\\\") >= 0:\\n field_name = \\\"KidFriendly\\\"\\n elif header_str.find(\\\"senior\\\") >= 0 and header_str.find(\\\"only\\\") >= 0:\\n field_name = \\\"SeniorsOnly\\\"\\n elif header_str.find(\\\"sex\\\") >= 0 or header_str.find(\\\"gender\\\") >= 0:\\n field_name = \\\"SexRestrictedTo\\\"\\n elif header_str.find(\\\"volunteer appeal\\\") >= 0:\\n field_name = None\\n else:\\n parser_error(\\\"couldn't map header '\\\"+header_str+\\\"' to a field name.\\\")\\n if field_name != None:\\n header_colidx[field_name] = header_col\\n header_names[header_col] = field_name\\n #print header_str, \\\"=>\\\", field_name\\n header_col += 1\\n\\n if len(header_names) < 10:\\n parser_error(\\\"too few fields found: \\\"+str(len(header_names)))\\n\\n data_startrow = 0\\n\\n # check to see if there's a header-description row\\n header_desc = cellval(HEADER_ROW+1, HEADER_STARTCOL)\\n if not header_desc:\\n parser_error(\\\"blank row not allowed below header row\\\")\\n else:\\n header_desc = header_desc.lower()\\n data_startrow = HEADER_ROW + 1\\n if header_desc.find(\\\"Opportunity Title\\\") >= 0:\\n data_startrow += 1\\n\\n\\n # find the data\\n CURRENT_ROW = data_startrow\\n blankrows = 0\\n numopps = 0\\n addr_ar = []\\n urls_ar = []\\n\\n if data_startrow == 0:\\n MESSAGES = []\\n MESSAGES.append('Spreadsheet appears to be empty')\\n return len(MESSAGES), DATA, MESSAGES, [], []\\n\\n while True:\\n blankrow = True\\n #rowstr = \\\"row=\\\"+str(row)+\\\"\\\\n\\\"\\n record = {}\\n record['LastUpdated'] = '0000-00-00'\\n for field_name in header_colidx:\\n col = header_colidx[field_name]\\n val = cellval(CURRENT_ROW, col)\\n if val:\\n blankrow = False\\n else:\\n val = \\\"\\\"\\n #rowstr += \\\" \\\"+field_name+\\\"=\\\"+val+\\\"\\\\n\\\"\\n record[field_name] = val\\n key = 'R'+str(CURRENT_ROW)+'C'+str(col)\\n if (key in updated and\\n updated[key] > record['LastUpdated']):\\n record['LastUpdated'] = updated[key]\\n if blankrow:\\n blankrows += 1\\n if blankrows > MAX_BLANKROWS:\\n break\\n else:\\n numopps += 1\\n blankrows = 0\\n record['oppid'] = str(numopps)\\n get_minmaxlen(record, 'OpportunityTitle', 4, 100)\\n get_minmaxlen(record, 'SpecialSkills', -1, 1000)\\n location_name = get_minmaxlen(record, 'LocationName', 4)\\n if location_name.lower() == \\\"virtual\\\":\\n is_virtual = True\\n else:\\n is_virtual = False\\n\\n if is_virtual:\\n reason = \\\" for virtual opportunities-- if you want both a location and\\\"\\n reason += \\\" a virtual opportunity, then provide two separate records.\\\"\\n get_blank(record, \\\"LocationStreet\\\", reason)\\n get_blank(record, \\\"LocationCity\\\", reason)\\n get_blank(record, \\\"LocationProvince\\\", reason)\\n get_blank(record, \\\"LocationPostalCode\\\", reason)\\n get_blank(record, \\\"LocationCountry\\\", reason)\\n else:\\n # TODO: appengine 30sec timeouts render this ambiguous/confuse for users\\n addr = recordval(record, \\\"LocationStreet\\\")\\n addr += \\\" \\\"+recordval(record, \\\"LocationCity\\\")\\n addr += \\\" \\\"+recordval(record, \\\"LocationProvince\\\")\\n addr += \\\" \\\"+recordval(record, \\\"LocationPostalCode\\\")\\n addr += \\\" \\\"+recordval(record, \\\"LocationCountry\\\")\\n addr_ar.append(addr)\\n \\n start_date = recordval(record, \\\"StartDate\\\").lower()\\n if start_date == \\\"ongoing\\\":\\n ongoing = True\\n elif start_date == \\\"\\\":\\n parser_error(\\\"Start Date may not be blank.\\\")\\n ongoing = True\\n else:\\n ongoing = False\\n\\n if ongoing:\\n start_time = recordval(record, \\\"StartTime\\\")\\n if start_time != \\\"\\\" and start_time != \\\"ongoing\\\":\\n parser_error(\\\"ongoing event should have blank Start Time.\\\")\\n end_date = recordval(record, \\\"EndDate\\\")\\n if end_date != \\\"\\\" and end_date != \\\"ongoing\\\":\\n parser_error(\\\"ongoing event should have blank End Date.\\\")\\n end_time = recordval(record, \\\"EndTime\\\")\\n if end_time != \\\"\\\" and end_time != \\\"ongoing\\\":\\n parser_error(\\\"ongoing event should have blank End Time.\\\")\\n else:\\n get_dtval(record, \\\"StartDate\\\")\\n get_tmval(record, \\\"StartTime\\\")\\n get_dtval(record, \\\"EndDate\\\")\\n get_tmval(record, \\\"EndTime\\\")\\n\\n email = recordval(record, \\\"ContactEmail\\\")\\n if email != \\\"\\\" and email.find(\\\"@\\\") == -1:\\n parser_error(\\\"malformed email address: \\\"+email)\\n\\n url = recordval(record, \\\"URL\\\")\\n if url == \\\"\\\":\\n parser_error(\\\"Website - this field is required.\\\")\\n urls_ar.append(url)\\n \\n daysofweek = recordval(record, \\\"DaysOfWeek\\\").split(\\\",\\\")\\n for dow in daysofweek:\\n lcdow = dow.strip().lower()\\n if lcdow not in [\\\"sat\\\", \\\"saturday\\\",\\n \\\"sun\\\", \\\"sunday\\\",\\n \\\"mon\\\", \\\"monday\\\",\\n \\\"tue\\\", \\\"tues\\\", \\\"tuesday\\\",\\n \\\"wed\\\", \\\"weds\\\", \\\"wednesday\\\",\\n \\\"thu\\\", \\\"thur\\\", \\\"thurs\\\", \\\"thursday\\\",\\n \\\"fri\\\", \\\"friday\\\", \\\"\\\"]:\\n # TODO: support these alternates in the datahub!\\n parser_error(\\\"malformed day of week: '%s'\\\" % dow)\\n get_boolval(record, \\\"Paid\\\")\\n get_intval(record, \\\"CommitmentHours\\\")\\n get_intval(record, \\\"MinimumAge\\\")\\n get_boolval(record, \\\"KidFriendly\\\")\\n get_boolval(record, \\\"SeniorsOnly\\\")\\n sexrestrict = recordval(record, \\\"SexRestrictedTo\\\")\\n if sexrestrict.lower() not in [\\\"women\\\", \\\"men\\\", \\\"either\\\", \\\"\\\"]:\\n parser_error(\\\"bad SexRestrictedTo-- try Men, Women, Either or (blank).\\\")\\n org = recordval(record, 'SponsoringOrganization')\\n if org == \\\"\\\":\\n parser_error(\\\"missing Sponsoring Organization-- this field is required.\\\"+\\n \\\" (it can be an informal name, or even a person's name).\\\")\\n else:\\n get_minmaxlen(record, 'SponsoringOrganization', 4, 100)\\n get_minmaxlen(record, 'Description', 15, 3000)\\n freq = recordval(record, 'Frequency').lower()\\n if not (freq == \\\"\\\" or freq == \\\"once\\\" or freq == \\\"daily\\\" or\\n freq == \\\"weekly\\\" or freq == \\\"every other week\\\" or \\n freq == \\\"monthly\\\"):\\n parser_error(\\\"unsupported frequency: '\\\"+\\n recordval(record, 'Frequency')+\\\"'\\\")\\n CURRENT_ROW += 1\\n\\n return len(MESSAGES), DATA, MESSAGES, addr_ar, urls_ar\",\n \"def setUp(self):\\n wb = open_workbook(filename=self.filename)\\n\\n self.port_values = {}\\n\\n # find sheets that contain cash\\n sheet_names = wb.sheet_names()\\n for sn in sheet_names:\\n if len(sn) > 4 and sn[-4:] == '-BOC':\\n # print('read from sheet {0}'.format(sn))\\n ws = wb.sheet_by_name(sn)\\n read_cash(ws, self.port_values)\",\n \"def test_from_file_xls(self):\\n with TemporaryDirectory() as tmp:\\n fp, df_test = save_simple_dataframe(tmp, 'test.xls')\\n df_read = BaseDataClass.from_file(fp).df\\n self.assertEqual(\\n pd.testing.assert_frame_equal(df_test, df_read),\\n None,\\n )\",\n \"def main(xls, seqtype):\\n data_extraction = {}\\n # 1 - Load data\\n logger.info(f'Load {xls}')\\n manifest, metadata = load_xls(xls)\\n # 2 - Check file and data\\n logger.info(f'Start to validate XLS')\\n check_samples(manifest, metadata)\\n check_seqtype(manifest, seqtype)\\n check_metadata(metadata, seqtype)\\n logger.success(f'Successfully validate XLS')\\n # 3 - Export XLS to TSV for Qiime2\\n logger.info(f'Start to export XLS to TSV')\\n data_extraction = extract_manifest(manifest, seqtype, data_extraction)\\n data_extraction, metadata_vars = extract_metadata(metadata, seqtype, data_extraction)\\n export_to_tsv_for_qiime(data_extraction, metadata_vars, seqtype)\\n logger.success(f'Done')\",\n \"def parse_f_id():\\r\\n fname = 'parse/File2.xlsx'\\r\\n sheet_name = 'Sheet1'\\r\\n\\r\\n ran_sheet = get_sheet(fname, sheet_name)\\r\\n return parse_sheet(ran_sheet)\",\n \"def read_in(path, projnum):\\n\\n is_xlsx = path.endswith('xlsx')\\n if is_xlsx:\\n data = pd.read_excel(path, header = 1)\\n for i,r in data.iterrows():\\n if r.isnull().all():\\n rmv = i - 1\\n break\\n data = data.loc[:rmv]\\n proj_name = pd.read_excel(path, skiprows = range(1, 10000)).columns[0]\\n\\n if not (proj_name and proj_name != 'Phase'):\\n proj_name = ' '.join(path.split('/')[-1].split(' --- ')[0].split()[:-2])\\n\\n return data, proj_name\\n else:\\n data = pd.read_csv(path)\\n if data.shape[1] == 1:\\n data = pd.read_csv(path, sep = '\\\\t')\\n\\n # DEFAULT VALUES IF NECESSARY\\n if 'Phase' not in data.columns:\\n data['Phase'] = 'Base Bid'\\n\\n if 'Phase #' not in data.columns:\\n data[\\\"Phase #\\\"] = 1\\n\\n if 'Form Method' not in data.columns:\\n data[\\\"Form Method\\\"] = \\\"HP\\\"\\n\\n if 'Drafting ID' in data.columns:\\n data.rename(columns = {'Drafting ID': 'Block ID'}, inplace = True)\\n if 'Deleted' not in data.columns:\\n data['Deleted'] = ''\\n proj = [c for c in data.columns if 'Project #' in c]\\n if proj:\\n data.rename(columns = {proj[0]: 'Project #'}, inplace = True)\\n if (data['Project #'] == '').all():\\n data['Project #'] = 'TypeProjectNumberHere' if projnum == '-' else projnum\\n\\n else:\\n data['Project #'] = 'TypeProjectNumberHere' if projnum == '-' else projnum\\n \\n\\n return data\",\n \"def __init__(self, infile, sheet, header=True, date_format=\\\"%Y-%m-%d\\\"):\\n from openpyxl import load_workbook\\n \\n wb = load_workbook(infile, data_only=True, use_iterators=True, keep_vba=False)\\n \\n try:\\n sheet = wb.worksheets[int(sheet)-1]\\n \\n except:\\n for ws in wb.worksheets:\\n if ws.title == sheet:\\n sheet = ws\\n break\\n else:\\n raise Exception(\\\"No worksheet named {0}\\\".format(sheet))\\n \\n self.iter = sheet.iter_rows()\\n self.date_format = date_format\\n \\n if header:\\n self.fieldnames = self.format_excel_row(self.iter.next())\\n self.aliases = dict(zip(\\n list(\\\"col{0}\\\".format(idx+1) for idx in xrange(len(self.fieldnames))),\\n self.fieldnames))\\n else:\\n self.fieldnames = list(\\\"col{0}\\\".format(idx+1) for idx in xrange(len(sheet.columns))),\\n self.aliases = None\",\n \"def validate_file(self):\\n filename = str(self.filename)\\n self.is_error = False\\n self.message = \\\"\\\"\\n if not (filename.endswith('xls') or filename.endswith('xlsx') or filename.endswith('csv')):\\n self.message += \\\"Please Import only '.xls' or '.xlsx' or '.csv' File.\\\"\\n elif (filename.endswith('xls') or filename.endswith('xlsx')):\\n column_list = ['id', 'quantity']\\n\\n wb = xlrd.open_workbook(\\n file_contents=base64.decodestring(self.xls_file))\\n sheet = wb.sheet_by_index(0)\\n row = sheet.row_values(0)\\n invalid_cols = []\\n import pdb;pdb.set_trace()\\n for key in row:\\n key = key.encode('ascii', 'ignore')\\n if key.lower() not in column_list:\\n invalid_cols.append(key)\\n if invalid_cols:\\n self.message = \\\"Invalid Column Name %s\\\", ', '.join(\\n invalid_cols)\\n if not self.message:\\n for i in range(1, sheet.nrows):\\n row = sheet.row_values(i)\\n firstrow = sheet.row_values(0)\\n firstrow = [str(item).lower() for item in firstrow]\\n product_obj = self.env['product.product'].search(\\n [('id', '=', row[firstrow.index('id')])])\\n if not row[firstrow.index('quantity')]:\\n self.message += \\\"Enter Quantity In Your Excel File\\\"\\n if not product_obj:\\n self.message += \\\"Enter Valid Product Id In Your Excel File\\\"\\n else:\\n column_list = ['id', 'quantity']\\n xls_file = base64.b64decode(self.xls_file)\\n file_input = cStringIO.StringIO(xls_file)\\n file_input.seek(0)\\n rows = []\\n delimeter = ','\\n reader = csv.reader(file_input, delimiter=delimeter,\\n lineterminator='\\\\r\\\\n')\\n for row in reader:\\n rows.append(row)\\n firstrow = [str(item).lower() for item in rows[0]]\\n match = [column for column in firstrow if column not in column_list]\\n if match:\\n self.message += \\\"Enter Valid Column Name\\\"\\n if not self.message:\\n for row in rows[1:]:\\n rows[0] = [str(item).lower() for item in rows[0]]\\n product_obj = self.env['product.product'].search(\\n [('id', '=', row[rows[0].index('id')])])\\n if not row[rows[0].index('quantity')]:\\n self.message += \\\"Enter Quantity In Your Excel File\\\"\\n if not product_obj:\\n self.message += \\\"Enter Valid Product Id In Your Excel File\\\"\\n\\n if self.message:\\n self.is_error = True\\n if not self.is_error:\\n self.is_validate = True\\n return {\\n 'res_id': self.id,\\n 'view_id': self.env.ref('import_stock_inventory_drc.import_stock_inventory_view_wizard_form').ids,\\n 'view_type': 'form',\\n 'view_mode': 'form',\\n 'res_model': 'stock.inventory.wizard',\\n 'type': 'ir.actions.act_window',\\n 'target': 'new'\\n }\",\n \"def test_read_xls_wrong_format(self):\\r\\n my_tape = Tape()\\r\\n non_excel_file = os.path.join(test_files_dir, 'not_excel_file.txt')\\r\\n my_tape.read_xls(non_excel_file)\",\n \"def evaluer_case(sheet,case):\\n\\tvaleur_conv=convert_wb(sheet[case].value)\\n\\treturn eval(valeur_conv)\",\n \"def nodes_data_excel_parser(excel_path,**kwargs):\\n excel_parser_engine = kwargs.get(\\\"engine\\\",\\\"xlrd\\\")\\n\\n # Check if excel file exists\\n if not excel_path or not os.path.isfile(excel_path):\\n raise FileNotFoundError(\\n \\\"Excel data file {} not found.\\\".format(excel_path)\\n )\\n\\n xls = pd.ExcelFile(excel_path,engine=excel_parser_engine)\\n\\n try:\\n # TODO for sheet in xls.sheet_names:\\n # nodes_data[sheet] = xls.parse(sheet)\\n nodes_data = {\\n \\\"buses\\\": xls.parse(\\\"buses\\\").replace({np.nan:None}),\\n \\\"commodity_sources\\\": xls.parse(\\\"commodity_sources\\\").replace({np.nan:None}),\\n \\\"transformers\\\": xls.parse(\\\"transformers\\\").replace({np.nan:None}),\\n \\\"transformers_chp\\\": xls.parse(\\\"transformers_chp\\\").replace({np.nan:None}),\\n \\\"renewables\\\": xls.parse(\\\"renewables\\\").replace({np.nan:None}),\\n \\\"demand\\\": xls.parse(\\\"demand\\\").replace({np.nan:None}),\\n \\\"storages\\\": xls.parse(\\\"storages\\\").replace({np.nan:None}),\\n \\\"powerlines\\\": xls.parse(\\\"powerlines\\\").replace({np.nan:None}),\\n \\\"timeseries\\\": xls.parse(\\\"time_series\\\").replace({np.nan:None}),\\n \\\"financial\\\":xls.parse(\\\"financial\\\").replace({np.nan:None})\\n }\\n except KeyError:\\n err_msg = \\\"Excel file must contains: [buses, commodity_sources, transformers, renewables, demand, storages, powerlines, financial and timeseries].\\\\n\\\\\\n The following sheets are found: {}\\\".format(xls.sheet_names)\\n raise Exception(err_msg)\\n\\n # set datetime index\\n nodes_data[\\\"timeseries\\\"].set_index(\\\"timestamp\\\", inplace=True)\\n nodes_data[\\\"timeseries\\\"].index = pd.to_datetime(\\n nodes_data[\\\"timeseries\\\"].index\\n )\\n\\n logger.info(\\\"Data from Excel file {} imported in as nodes data.\\\".format(excel_path))\\n\\n return nodes_data\",\n \"def parse_bloomberg_excel(filename, colnames_sheet, data_sheets, space=1,\\n colnames=None, **kwargs):\\n if isinstance(data_sheets, str):\\n data_sheets = [data_sheets, ]\\n flag_single_input = True\\n else:\\n flag_single_input = False\\n\\n # converter for date\\n def converter(x):\\n try:\\n res = pd.to_datetime(x)\\n except Exception:\\n res = pd.NaT\\n return res\\n\\n # colnames_sheet\\n if colnames is None:\\n colnames = pd.read_excel(filename, sheet_name=colnames_sheet, header=0)\\n colnames = colnames.columns\\n\\n # float converters\\n float_conv = {\\n k: float for k in list(range(1, len(colnames)*(2+space), 2+space))\\n }\\n\\n # if data_sheets is None, read in all sheets\\n if data_sheets is None:\\n data_dict_full = pd.read_excel(filename, sheet_name=None,\\n converters=float_conv, verbose=True,\\n **kwargs)\\n\\n # remove the sheet with colnames from this dict\\n data_dict_full.pop(colnames_sheet, None)\\n\\n else:\\n data_dict_full = pd.read_excel(filename, sheet_name=data_sheets,\\n converters=float_conv, verbose=True,\\n **kwargs)\\n\\n # loop over sheetnames\\n all_data = dict()\\n\\n for s, data_df in data_dict_full.items():\\n # loop over triplets, map dates, extract\\n new_data_df = []\\n for p in range((data_df.shape[1]+1)//(space+2)):\\n # this triplet\\n this_piece = data_df.iloc[1:, p*(space+2):(p+1)*(space+2)-space]\\n\\n # map date\\n this_piece.iloc[:, 0] = this_piece.iloc[:, 0].map(converter)\\n\\n # drop nans (with dates)\\n this_piece = this_piece.dropna()\\n\\n # extract date as index\\n this_piece = this_piece.set_index(this_piece.columns[0])\\n\\n # rename\\n this_piece.columns = [colnames[p]]\\n this_piece.index.name = \\\"date\\\"\\n\\n # drop duplicates from the index\\n this_piece = this_piece.loc[\\n ~this_piece.index.duplicated(keep='first'), :]\\n\\n # store\\n new_data_df += [this_piece, ]\\n\\n # concat\\n all_data[s] = pd.concat(new_data_df, axis=1, join=\\\"outer\\\")\\n\\n # if only one sheet was asked for\\n if flag_single_input:\\n all_data = list(all_data.values())[0]\\n\\n return all_data\",\n \"def read_excel(self):\\r\\n try:\\r\\n self.check_point_1 = True\\r\\n self.filename = tkFileDialog.askopenfilename(initialdir=\\\"/\\\", title=\\\"Select file\\\",\\r\\n filetypes=((\\\"excel files\\\", \\\"*.xlsx\\\"), (\\\"all files\\\", \\\"*.*\\\")))\\r\\n\\r\\n book = open_workbook(self.filename)\\r\\n\\r\\n if self.filename == '' or self.filename.split('/')[-1] != 'Engr Student Data.xlsx':\\r\\n self.check_point_1 = False\\r\\n if self.check_point_1 == True:\\r\\n self.headings = ['ID', 'Name', 'Section', 'Dept', 'GPA', 'MP1 Grade:', 'MP2 Grade:', 'MP3 Grade:',\\r\\n 'MT Grade:', 'Final Grade:']\\r\\n book = open_workbook(self.filename)\\r\\n sheet = book.sheet_by_index(0)\\r\\n for row_index in range(1, sheet.nrows):\\r\\n index = 0\\r\\n traits = []\\r\\n for column_index in range(sheet.ncols):\\r\\n traits.append(sheet.cell(row_index, column_index).value)\\r\\n self.student[sheet.cell(row_index, 1).value] = traits\\r\\n index += 1\\r\\n used_list = []\\r\\n for key in self.student:\\r\\n used_list.append(key)\\r\\n self.sort_list = sorted(used_list)\\r\\n for index in range(len(self.sort_list) - 1, -1, -1):\\r\\n single = self.sort_list[index].split(' ')\\r\\n if len(single) == 3:\\r\\n app.tree.insert(\\\"\\\", 0, text=int(self.student[self.sort_list[index]][0]),\\r\\n values=(single[:2], single[2]))\\r\\n continue\\r\\n app.tree.insert(\\\"\\\", 0, text=int(self.student[self.sort_list[index]][0]),\\r\\n values=(single[0], single[1]))\\r\\n app.info.configure(text=\\\"INFO: File Loaded.\\\")\\r\\n # If the user loaded the file properly, 'Info' Label should shows the message: 'INFO: File Loaded.'\\r\\n\\r\\n except (IOError, XLRDError):\\r\\n app.info.configure(text=\\\"INFO: Loading Failed! Please Try Again.\\\", font=('','7'))\\r\\n # If the user did not load the file properly,'Info' Label shows the message: 'INFO: Loading Failed! Please Try Again.'\\r\",\n \"def excel_fun_read(file_name, template_name, template_location, counter) :\\r\\n for list_number in range(1, 4) :\\r\\n inputWorkbook = xlrd.open_workbook(file_name)\\r\\n inputWorksheet = inputWorkbook.sheet_by_index(list_number)\\r\\n rows = inputWorksheet.nrows\\r\\n cols = inputWorksheet.ncols\\r\\n print(f'{rows} Rows in the file\\\\t') # <- get rows number starts from 0\\r\\n print(f'{cols} Cols in the file\\\\n') # <- get coloms number starts from 0\\r\\n dictionary = {1 : 'ATR', 2 : 'ESS Hot cycle 1', 3 : 'ESS Cold cycle 1', 4 : 'ESS Hot cycle 2',\\r\\n 5 : 'ESS Cold cycle 2'}\\r\\n if cols == 9 :\\r\\n print('next file')\\r\\n if cols == 12 or cols == 9 :\\r\\n cols = 8\\r\\n sub = 2\\r\\n else :\\r\\n cols = 12\\r\\n sub = 3\\r\\n for excel_row in range(1, sub) :\\r\\n sn = int(inputWorksheet.cell_value(0, cols))\\r\\n print(f'working on 000{sn}.xlsx') # <- Indicates which file is open\\r\\n TestLocation_list = [] # <- Creation of list\\r\\n PassFail_col_list = [] # <- Creation of list\\r\\n for i in range(rows) :\\r\\n # Follow the H colom check if there is 'PASS'/'FAIL' or empty cell\\r\\n # If empty cell skip it until the end of the excel file\\r\\n if inputWorksheet.cell_value(i, cols - excel_row) == 'PASS' or inputWorksheet.cell_value(i,\\r\\n cols - excel_row) == 'FAIL' or inputWorksheet.cell_value(\\r\\n i, cols - excel_row) == 'N/T' :\\r\\n TestLocation_list.append(i)\\r\\n PassFail_col_list.append(str(inputWorksheet.cell_value(i, cols - excel_row)))\\r\\n\\r\\n location_list, len_of_every_test_list = Create_2_lists_of_locations(TestLocation_list, list_number)\\r\\n pass_fail_list = sort_list_of_pass_and_fail(len_of_every_test_list, location_list, file_name, list_number,\\r\\n cols, PassFail_col_list, excel_row)\\r\\n\\r\\n # print(f'''It's the end of {list_number} in file 000{sn} excel_row = {excel_row}''')\\r\\n print(f'''It's the end of {dictionary.pop(counter)} in file 000{sn}\\\\n''')\\r\\n write_to_excel(sn, template_location, pass_fail_list, counter)\\r\\n counter += 1\\r\\n\\r\\n print('''it's the end of the loop''')\",\n \"def __init__(self, filename=None, filetype=None, instrument=None):\\n if filename:\\n if instrument == 'Element':\\n skipfooter = 4\\n header = 1\\n drop = 9\\n elif instrument == 'Agilent':\\n skipfooter = 4\\n header = 3\\n drop = 3\\n else:\\n skipfooter = 0\\n header = 0\\n drop = 0\\n\\n if filetype == 'xlsx':\\n pwd = os.getcwd()\\n os.chdir(os.path.dirname(filename))\\n self.imported = pd.ExcelFile(filename)\\n self.data = self.imported.parse(\\n 0, index_col=0, skipfooter=skipfooter, header=header)\\n self.data = self.data.drop(self.data.index[:drop], axis=0)\\n os.chdir(pwd)\\n # TODO xlsx doesnt work with agilent type\\n elif filetype == 'csv':\\n pwd = os.getcwd()\\n os.chdir(os.path.dirname(filename))\\n self.data = pd.read_csv(filename, sep=',', index_col=0, skipfooter=skipfooter,\\n header=header, engine='python')\\n os.chdir(pwd)\\n elif filetype == 'asc':\\n pwd = os.getcwd()\\n os.chdir(os.path.dirname(filename))\\n self.data = pd.read_csv(filename, sep='\\\\t', index_col=0, skipfooter=skipfooter,\\n header=header, engine='python')\\n self.data = self.data.drop(self.data.index[:drop], axis=0)\\n self.data.dropna(axis=1, how='all', inplace=True)\\n self.data = self.data.apply(pd.to_numeric, errors='coerce')\\n os.chdir(pwd)\\n else:\\n warnings.warn('File type not supported.')\\n\\n self.data.index = self.data.index.astype('float32')\\n self.time = self.data.index\\n self.elements = list(map(elem_resolution, self.data.columns))\\n self.data.columns = self.elements\\n\\n self.srms = pd.ExcelFile('./SRM.xlsx').parse(index_col=0)\\n self.sum_koeficients = pd.ExcelFile(\\n './default_sum_koef.xlsx').parse(0, index_col=0, header=None).to_dict()[1]\\n\\n self.srm = None\\n self.iolite = None\\n self.names = None\\n self.internal_std = None\\n self.ablation_time = None\\n\\n self.laser_off = []\\n self.laser_on = []\\n self.skip = {'bcg_start': 0,\\n 'bcg_end': 0,\\n 'sample_start': 0,\\n 'sample_end': 0} # time in seconds to skip from each bcg and sample\\n\\n self.filter_line = None\\n self.starts = None\\n self.ends = None\\n self.bcg = None\\n self.average_peaks = None\\n self.ratio = None\\n self.quantified = None\\n self.lod = None\\n self.correction_elements = None\\n self.corrected_IS = None\\n self.corrected_SO = None\\n\\n self.dx = None\\n self.dy = None\\n self.maps = {}\\n self.qmaps = {}\\n\\n self.regression_values = {}\\n self.regression_equations = {}\",\n \"def _read_workbook_2007(maldoc):\\n\\n # Read in the 2007+ cells.\\n color_print.output('g', \\\"Analyzing Excel 2007+ file ...\\\")\\n workbook_info = XLM.excel2007.read_excel_2007_XLM(maldoc) \\n color_print.output('g', \\\"Extracted XLM from ZIP archive.\\\")\\n if (workbook_info is None):\\n return (None, None, None)\\n if (len(workbook_info) == 0):\\n color_print.output('y', \\\"WARNING: No XLM macros found.\\\")\\n return (None, None, None)\\n\\n if debug:\\n print(\\\"=========== START 2007+ CONTENTS ==============\\\")\\n for sheet in workbook_info.keys():\\n print(\\\"\\\\n------\\\")\\n print(sheet)\\n print(\\\"\\\")\\n for c in workbook_info[sheet].keys():\\n print(str(c) + \\\" ---> \\\" + str(workbook_info[sheet][c]))\\n print(\\\"=========== DONE 2007+ CONTENTS ==============\\\")\\n \\n # Figure out which sheet probably has the XLM macros.\\n xlm_sheet_name = None\\n max_formulas = -1\\n for sheet in workbook_info.keys():\\n if (len(workbook_info[sheet]) > max_formulas):\\n max_formulas = len(workbook_info[sheet])\\n xlm_sheet_name = sheet\\n\\n # Parse each formula and add it to a sheet object.\\n xlm_cells = {}\\n for cell_index in workbook_info[xlm_sheet_name].keys():\\n\\n # Value only cell?\\n row = cell_index[0]\\n col = cell_index[1]\\n if (row not in xlm_cells):\\n xlm_cells[row] = {}\\n raw_formula = workbook_info[xlm_sheet_name][cell_index][0]\\n if (raw_formula is None):\\n\\n # Do we have a value?\\n formula_val = workbook_info[xlm_sheet_name][cell_index][1]\\n if (formula_val is not None):\\n\\n # Just save the value in the cell.\\n xlm_cells[row][col] = formula_val\\n continue\\n \\n # Parse the formula into an XLM object.\\n formula_str = b\\\"=\\\" + raw_formula\\n formula = XLM.ms_stack_transformer.parse_ms_xlm(formula_str)\\n\\n # Set the value of the formula if we know it.\\n formula_val = workbook_info[xlm_sheet_name][cell_index][1]\\n if (formula_val is not None):\\n formula.value = formula_val\\n\\n # Save the XLM object.\\n formula.update_cell_id(cell_index)\\n xlm_cells[row][col] = formula\\n color_print.output('g', \\\"Parsed MS XLM macros.\\\")\\n \\n # Merge the XLM cells with the value cells into a single unified spereadsheet\\n # object.\\n workbook, xlm_cell_indices, xlm_sheet = _merge_XLM_cells(maldoc, xlm_cells)\\n if (workbook is None):\\n color_print.output('r', \\\"ERROR: Merging XLM cells failed. Emulation aborted.\\\")\\n return (None, None, None)\\n \\n # Done.\\n return (workbook, xlm_cell_indices, xlm_sheet)\",\n \"def parse():\\n\\n try:\\n if \\\"excel_doc\\\" not in request.files:\\n return bad_request()\\n\\n excel_doc = request.files[\\\"excel_doc\\\"]\\n\\n if not models.allowed_file(excel_doc.filename):\\n return bad_request()\\n\\n file_path = models.save_excel_doc(excel_doc)\\n\\n students = models.parse_students(file_path)\\n\\n os.remove(file_path)\\n except ValueError as e:\\n return bad_request()\\n except Exception as e:\\n print(e)\\n return server_error()\\n\\n return success(students)\",\n \"def get_arterial(file_path,category):\\n book = xlrd.open_workbook(file_path)\\n file_name = os.path.basename(file_path)\\n year = str(20) + \\\"\\\".join([str(s) for s in file_name if s.isdigit()]) ## gets the year from filename\\n Month = strptime(file_name[2:5],'%b').tm_mon ## gets month no\\n mydate = datetime.date(int(year),Month, 1) ## first day of the month and year\\n mydate_1 = mydate - datetime.timedelta(days=1) ## interested in last month of this year as data corresponds to last month and same year\\n mydate_2 = mydate - datetime.timedelta(days=368) ## interested in last month of last year as data corresponds to last month and last year \\n #monthid1 = str(mydate_1.strftime(\\\"%Y\\\")) + str(mydate_1.strftime(\\\"%m\\\")) ## 200706 for July 2007 file\\n monthid2 = str(mydate_2.strftime(\\\"%Y\\\")) + str(mydate_2.strftime(\\\"%m\\\")) ## 200606 for July 2007 file\\n try:\\n if category.lower() == \\\"rural\\\":\\n index = 3\\n elif category.lower() == \\\"urban\\\":\\n index = 4\\n else:\\n index = 5\\n sheet = book.sheet_by_index(index)\\n list_states = sheet.col_values(0)\\n xstart = list_states.index('Connecticut')\\n xend = list_states.index('TOTALS')\\n #list1 = sheet.col_slice(colx= 8,start_rowx=xstart,end_rowx= xend - 1)\\n #list1 = [w.value for w in list1]\\n list2 = sheet.col_slice(colx= 9,start_rowx=xstart,end_rowx= xend - 1)\\n list2 = [w.value for w in list2]\\n list3 = sheet.col_slice(colx= 0,start_rowx=xstart,end_rowx= xend - 1)\\n list3 = [w.value.lower() for w in list3] ## take lowercase for direct match later\\n df = pd.concat([pd.DataFrame(list3),pd.DataFrame(list2)], axis = 1) # ,pd.DataFrame(list1)\\n #col_name_1 = category + '_Arterial_' + monthid1\\n col_name_2 = category + '_Arterial_' + monthid2\\n df.columns = ['State', col_name_2 ] # col_name_1, \\n df[col_name_2].replace('', np.nan, inplace=True) ## removes rows with blank records ( zonal categories)\\n df['State'].replace('', np.nan, inplace=True)\\n curr_monthid = str(mydate.strftime(\\\"%Y\\\")) + str(mydate.strftime(\\\"%m\\\")) ## 200707 for July 2007 file\\n df['data_monthid'] = curr_monthid\\n df.dropna(subset=[col_name_2], inplace=True)\\n df.dropna(subset=['State'], inplace=True)\\n df = df[~df.State.str.contains(\\\"subtotal\\\")] ### causes problems on joins, there in most files\\n df = df[df.State != \\\"total\\\"] ## causes problems on joins, is there only in specific files\\n df['State'] = df.State.str.strip() ## removes leading and lagging white spaces if any\\n df2 = pd.melt(df,id_vars=['State','data_monthid'],var_name=['category'], value_name='Million_Vehicle_Miles')\\n return df2\\n except:\\n print(\\\"error in file \\\",os.path.basename(file_path))\",\n \"def batch(self, xls):\\n \\n workbook = xlrd.open_workbook(xls)\\n sheet = workbook.sheet_by_name(workbook.sheet_names()[0])\\n self.headers = sheet.row(0)\\n self.index = self._getHeaders([x.value for x in sheet.row(0)])\\n self.__create_batch([self.parseRow(sheet.row(i)) \\n for i in range(1, (sheet.nrows))])\",\n \"def read_elia_imbalanceprices(filename,status):\\r\\n \\r\\n df = pd.read_excel(filename,skiprows=1,parse_dates=False)\\r\\n df[\\\"Timestamp\\\"] = df[\\\"Date\\\"]+\\\" \\\"+df['Quarter'].map(lambda x: str(x)[:-9])\\r\\n pd.to_datetime(df[\\\"Timestamp\\\"])\\r\\n df.set_index(\\\"Timestamp\\\",inplace=True)\\r\\n if ((status == \\\"validated\\\") | (status == \\\"valid\\\")):\\r\\n df = df.drop(df[df.Status != \\\"Validated\\\"].index)\\r\\n df = df.drop([\\\"Date\\\",\\\"Quarter\\\",\\\"Status\\\"], axis=1)\\r\\n \\r\\n if len(df.columns) == 3:\\r\\n df.columns.values[0:3] = [\\\"NRV in MW\\\",\\\"POS in euro/MWh\\\", \\\"NEG in euro/MWh\\\"]\\r\\n \\r\\n if len(df.columns) == 7:\\r\\n df.columns.values[0:7] = [\\\"NRV in MW\\\",\\\"SI in MW\\\",\\\"alpha in euro/MWh\\\",\\\"MIP in euro/MWh\\\", \\\"MDP in euro/MWh\\\",\\\"POS in euro/MWh\\\", \\\"NEG in euro/MWh\\\"]\\r\\n \\r\\n if len(df.columns) == 8:\\r\\n df.columns.values[0:8] = [\\\"NRV in MW\\\",\\\"SI in MW\\\",\\\"alpha in euro/MWh\\\",\\\"MIP in euro/MWh\\\", \\\"MDP in euro/MWh\\\",\\\"SR in euro/MWh\\\",\\\"POS in euro/MWh\\\", \\\"NEG in euro/MWh\\\"]\\r\\n\\r\\n return df\",\n \"def read_data(self, filepath, agg_type):\\n\\n data = pd.read_excel(filepath)\\n data['date'] = data.activity_date.apply(lambda x: x.date())\\n data['year'] = data.date.apply(lambda x: x.year)\\n data['month'] = data.date.apply(lambda x: x.month)\\n data['week'] = data.date.apply(lambda x: x.strftime('%U'))\\n data['dom'] = data.date.apply(lambda x: x.day)\\n data['day'] = data.date.apply(lambda x: x.isoweekday())\\n data['last_dom'] = data.date.apply(lambda x: calendar.monthrange(x.year, x.month)[1])\\n data['is_last_dom'] = np.where(data.dom == data.last_dom, 1, 0)\\n data['quarter'] = data.month.apply(lambda x: (x-1) // 3 + 1)\\n data['is_last_day_of_quarter'] = np.where(((data.month == 3) & (data.dom == 31)) | ((data.month == 6) & (data.dom == 30)) |\\n ((data.month == 9) & (data.dom == 30)) | ((data.month == 12) & (data.dom == 31)), 1, 0)\\n return data\",\n \"def parse_columns():\\n # Fetch columns letters\\n old_column_letter = get_old_numbers_column()\\n new_columns_letters = get_new_numbers_columns()\\n\\n # Fetch old numbers\\n old_column_cells = sheet[f'{old_column_letter}15':f'{old_column_letter}120']\\n old_numbers_cells = []\\n for ii in old_column_cells:\\n if re.match('[0-9]{7}', str(ii[0].value)):\\n old_numbers_cells.append(ii)\\n print(old_numbers_cells)\\n\\n ##----- WORKING UNTIL HERE -----##\\n \\n # Fetch all new numbers (for each format)\\n # Creates an array of arrays of cells ([[CellA, CellB], [CellC, CellD]])\\n for ii in old_numbers_cells:\\n new_numbers_cells_array = []\\n for ij in new_columns_letters:\\n new_columns_cells = [f'{ij}15', f'{ij}120']\\n new_numbers_cells = []\\n for jj in new_columns_cells:\\n if re.search('[0-9]{7}'):\\n new_numbers_cells.append(ii)\\n new_numbers_cells_array.append(new_numbers_cells)\\n\\n # Combines all the cells :\\n # Creates an array of tuples, easier to work with..\\n work_tuples = []\\n for ii in old_numbers_cells:\\n # First we create an array..\\n work_array = [int(ii.value)]\\n # Then we fill it..\\n for ij in new_numbers_cells_array:\\n # Using the current position in the old cells array...\\n work_array.append(ij[old_numbers_cells.index(ii)])\\n # Finally, the array is parsed as a tuple and added to the list\\n work_tuples.append(tuple(work_array))\\n\\n return work_tuples\",\n \"def get_arterial(file_path,category):\\n book = xlrd.open_workbook(file_path)\\n file_name = os.path.basename(file_path)\\n year = str(20) + \\\"\\\".join([str(s) for s in file_name if s.isdigit()]) ## gets the year from filename\\n Month = strptime(file_name[2:5],'%b').tm_mon ## gets month no\\n mydate = datetime.date(int(year),Month, 1) ## first day of the month and year\\n #mydate_1 = mydate - datetime.timedelta(days=1) ## interested in last month of this year as data corresponds to last month and same year\\n mydate_2 = mydate - datetime.timedelta(days=368) ## interested in last month of last year as data corresponds to last month and last year \\n #monthid1 = str(mydate_1.strftime(\\\"%Y\\\")) + str(mydate_1.strftime(\\\"%m\\\")) ## 200706 for July 2007 file\\n monthid2 = str(mydate_2.strftime(\\\"%Y\\\")) + str(mydate_2.strftime(\\\"%m\\\")) ## 200606 for July 2007 file\\n try:\\n if category.lower() == \\\"rural\\\":\\n index = 3\\n elif category.lower() == \\\"urban\\\":\\n index = 4\\n else:\\n index = 5\\n sheet = book.sheet_by_index(index)\\n list_states = sheet.col_values(0)\\n xstart = list_states.index('Connecticut')\\n xend = list_states.index('TOTALS')\\n #list1 = sheet.col_slice(colx= 6,start_rowx=xstart,end_rowx= xend - 1)\\n #list1 = [w.value for w in list1]\\n list2 = sheet.col_slice(colx= 7,start_rowx=xstart,end_rowx= xend - 1)\\n list2 = [w.value for w in list2]\\n list3 = sheet.col_slice(colx= 0,start_rowx=xstart,end_rowx= xend - 1)\\n list3 = [w.value.lower() for w in list3] ## take lowercase for direct match later\\n df = pd.concat([pd.DataFrame(list3),pd.DataFrame(list2)], axis = 1) # pd.DataFrame(list1),\\n #col_name_1 = category + '_Arterial_' + monthid1\\n col_name_2 = category + '_Arterial_' + monthid2\\n df.columns = ['State', col_name_2 ] ## col_name_1,\\n df[col_name_2].replace('', np.nan, inplace=True) ## removes rows with blank records ( zonal categories)\\n df['State'].replace('', np.nan, inplace=True)\\n curr_monthid = str(mydate.strftime(\\\"%Y\\\")) + str(mydate.strftime(\\\"%m\\\")) ## 200707 for July 2007 file\\n df['data_monthid'] = curr_monthid\\n df.dropna(subset=[col_name_2], inplace=True)\\n df.dropna(subset=['State'], inplace=True)\\n df = df[~df.State.str.contains(\\\"subtotal\\\")] ### causes problems on joins, there in most files\\n df = df[df.State != \\\"total\\\"] ## causes problems on joins, is there only in specific files\\n df['State'] = df.State.str.strip() ## removes leading and lagging white spaces if any\\n df2 = pd.melt(df,id_vars=['State','data_monthid'],var_name=['category'], value_name='Million_Vehicle_Miles')\\n return df2\\n except:\\n print(\\\"error in file \\\",os.path.basename(file_path))\",\n \"def get_context_from_xlsx(self):\\n if re.search('^(http|https)://', self.project.CONTEXT_SOURCE_FILE):\\n resp = requests.get(self.project.CONTEXT_SOURCE_FILE)\\n content = resp.content\\n else:\\n try:\\n with open(self.project.CONTEXT_SOURCE_FILE) as xlsxfile:\\n content = xlsxfile.read()\\n except IOError:\\n filepath = \\\"%s/%s\\\" % (\\n os.path.abspath(self.path),\\n self.project.CONTEXT_SOURCE_FILE)\\n with open(filepath) as xlsxfile:\\n content = xlsxfile.read()\\n\\n data = process_xlsx(content)\\n if 'values' in data:\\n data = copy_global_values(data)\\n\\n return data\",\n \"def test_read_xls(self):\\r\\n my_tape = Tape()\\r\\n input_xls = os.path.join(test_files_dir, 'test_tape.xlsx')\\r\\n my_tape.read_xls(input_xls)\\r\\n assert_frame_equal(self.test_df, my_tape.dataframe)\",\n \"def _parse_cells(self):\\n self.cells_with_solutions = []\\n self.cells_without_solutions = []\\n for cell in self.original_cells:\\n if is_test_cell(cell):\\n self.tests.append(read_test(cell))\\n else:\\n self.cells_with_solutions.append(cell)\\n self.cells_without_solutions.append(replace_cell_solutions(cell))\",\n \"def normalize_excelSheet(self, sheetname, conversion_dictionary):\\n\\n sheet = self.wb.sheet_by_name(sheetname)\\n\\n ami_data = []\\n\\n date_headers = [\\\"bibliographic.date\\\", \\\"technical.dateCreated\\\"]\\n time_headers = [\\\"technical.durationHuman\\\"]\\n\\n #copy everything from the 3rd row to the last row with a filename\\n for rownum in range(2, sheet.nrows):\\n if sheet.cell(rownum, 0):\\n ami_data.append(sheet.row_values(rownum))\\n\\n for i in range(0, sheet.ncols):\\n #normalize header\\n header_entry = self.get_headerEntryAsString(sheetname, i)\\n ami_data[0][i] = self.normalize_headerEntry(\\n header_entry,\\n conversion_dictionary)\\n\\n #convert excel dates\\n if ami_data[0][i] in date_headers:\\n for j in range(3, sheet.nrows):\\n if sheet.cell(j, i).ctype == 3:\\n value = sheet.cell(j, i).value\\n ami_data[j-2][i] = self.convert_excelDateTime(value, \\\"date\\\")\\n\\n #convert excel times\\n if ami_data[0][i] in time_headers:\\n for j in range(3, sheet.nrows):\\n if sheet.cell(j, i).ctype == 3:\\n value = sheet.cell(j, i).value\\n ami_data[j-2][i] = self.convert_excelDateTime(value, \\\"time\\\")\\n\\n ami_df = self.normalize_values(ami_data)\\n\\n return ami_df\",\n \"def load_plothrm_detailed(filename):\\n\\n filename = Path(filename)\\n\\n book = xlrd.open_workbook(filename)\\n xlsx_file = pd.ExcelFile(filename)\\n\\n df_seq = None\\n df_meta = None\\n\\n for sheetidx, sheetname in enumerate(xlsx_file.sheet_names):\\n\\n print(f'Parsing \\\"{filename}\\\" sheet \\\"{sheetname}\\\"', flush=True)\\n\\n try:\\n\\n sheetnumber = sheetidx + 1\\n worksheet = book.sheet_by_name(sheetname)\\n\\n # try to load a value from the row and column\\n def value_default(row, col, d):\\n if row >= worksheet.nrows or col >= worksheet.ncols:\\n return d\\n s = worksheet.cell_value(row, col)\\n if type(s) is str and len(s) == 0:\\n return d\\n else:\\n return s\\n\\n # load metadata\\n meta = dict()\\n meta['sheetname'] = sheetname\\n meta['sheetnumber'] = sheetnumber\\n meta['plothrm_version'] = str(worksheet.cell_value(0, 1))\\n meta['data_filename'] = str(worksheet.cell_value(1, 1))\\n meta['seq_filename'] = str(worksheet.cell_value(2, 1))\\n meta['nchan'] = int(worksheet.cell_value(3, 1))\\n meta['nsamp'] = int(worksheet.cell_value(4, 1))\\n meta['sampling_hz'] = float(worksheet.cell_value(5, 1))\\n meta['opt_zero_above'] = float(value_default(6, 2, np.nan))\\n meta['opt_remove_baselines'] = bool (value_default(6, 4, 0))\\n meta['opt_remove_sync'] = bool (value_default(6, 6, 0))\\n meta['opt_channel_smooth'] = bool (value_default(6, 8, 0))\\n meta['opt_sample_smooth'] = float(value_default(6, 10, np.nan))\\n meta['height_res'] = float(worksheet.cell_value(7, 1))\\n meta['sync_bound'] = float(worksheet.cell_value(8, 1))\\n # TODO load region data at rows 9, 10, 11 (Excel 1-based index rows 10-12)\\n\\n for k, v in meta.items():\\n meta[k] = [v]\\n meta = pd.DataFrame(meta)\\n\\n if df_meta is None:\\n df_meta = meta\\n else:\\n df_meta = df_meta.append(meta)\\n\\n # load sequence data\\n df = pd.read_excel(filename, sheetname, header=13, na_values=['ERROR', 'Infinity'])\\n df['sheetname'] = sheetname\\n df['sheetnumber'] = sheetnumber\\n if df_seq is None:\\n df_seq = df\\n else:\\n df_seq = df_seq.append(df)\\n\\n except Exception as e:\\n print(f' error parsing worksheet \\\"{sheetname}\\\": {e}')\\n continue\\n\\n return df_seq.reset_index(drop=True), df_meta.reset_index(drop=True)\",\n \"def read_elia_activated_energy_prices(filename,status):\\r\\n \\r\\n df = pd.read_excel(filename,skiprows=2,parse_dates=False)\\r\\n df[\\\"Timestamp\\\"] = df[\\\"Date\\\"]+\\\" \\\"+df['Quarter'].map(lambda x: str(x)[:-9])\\r\\n pd.to_datetime(df[\\\"Timestamp\\\"])\\r\\n df.set_index(\\\"Timestamp\\\",inplace=True)\\r\\n if ((status == \\\"validated\\\") | (status == \\\"valid\\\")):\\r\\n df = df.drop(df[df.Status != \\\"Validated\\\"].index)\\r\\n df = df.drop([\\\"Date\\\",\\\"Quarter\\\",\\\"Status\\\"], axis=1)\\r\\n \\r\\n if len(df.columns)>14:\\r\\n df.columns.values[0:16] = [\\\"NRV in MW\\\",\\\"SR in euro/MWh\\\",\\\"MIP in euro/MWh\\\",\\\"IGGC+ in euro/MWh\\\", \\\"R2+ in euro/MWh\\\",\\\"Bids+ in euro/MWh\\\",\\\"R3 std in euro/MWh\\\", \\\"R3 flex in euro/MWh\\\", \\\"ICH in euro/MWh\\\", \\\"inter TSO import in euro/MWh\\\", \\\"MDP in euro/MWh\\\", \\\"IGCC- in euro/MWh\\\", \\\"R2- in euro/MWh\\\", \\\"Bids- in euro/MWh\\\", \\\"R3- in euro/MWh\\\"]\\r\\n\\r\\n if len(df.columns)<12:\\r\\n df.columns.values[0:12] = [\\\"NRV in MW\\\",\\\"MIP in euro/MWh\\\",\\\"IGGC+ in euro/MWh\\\", \\\"R2+ in euro/MWh\\\",\\\"Bids+ in euro/MWh\\\", \\\"R3+ in euro/MWh\\\", \\\"MDP in euro/MWh\\\", \\\"IGCC- in euro/MWh\\\", \\\"R2- in euro/MWh\\\", \\\"Bids- in euro/MWh\\\", \\\"R3- in euro/MWh\\\"]\\r\\n\\r\\n return df\",\n \"def read_elia_cap(filename):\\r\\n df = pd.read_excel(filename,skiprows=0,parse_dates=False)\\r\\n \\r\\n #standaard datetime vorm omzetten\\r\\n df[\\\"Tendering Periodneww\\\"] = pd.to_datetime(df[\\\"Tendering Period\\\"],errors='coerce')\\r\\n df[\\\"Delivery Periodneww\\\"] = pd.to_datetime(df[\\\"Delivery Period\\\"],errors='coerce')\\r\\n \\r\\n #de 'weekvorm' van datetime omzetten\\r\\n df[\\\"Tendering Period\\\"]=df[\\\"Tendering Period\\\"].astype(str).map(lambda x: x.lstrip('W'))\\r\\n df[\\\"Delivery Period\\\"]=df[\\\"Delivery Period\\\"].astype(str).map(lambda x: x.lstrip('W'))\\r\\n df[\\\"Tendering Period\\\"]=df[\\\"Tendering Period\\\"].replace('\\\\s+', '_',regex=True)\\r\\n df[\\\"Delivery Period\\\"]=df[\\\"Delivery Period\\\"].replace('\\\\s+', '_',regex=True)\\r\\n df[\\\"Tendering Periodnew\\\"] = pd.to_datetime(df[\\\"Tendering Period\\\"][df[\\\"Delivery Periodneww\\\"].isnull()].astype(str).add('-1'), format=\\\"%W_%Y-%w\\\", errors='coerce')\\r\\n df[\\\"Delivery Periodnew\\\"] = pd.to_datetime(df[\\\"Delivery Period\\\"][df[\\\"Delivery Periodneww\\\"].isnull()].astype(str).add('-1'), format=\\\"%W_%Y-%w\\\", errors='coerce')\\r\\n \\r\\n #datumkolommen samenvoegen en overbodige kolommen verwijderen\\r\\n df[\\\"Tendering Period Combined\\\"] = df['Tendering Periodnew'].fillna(df['Tendering Periodneww'])\\r\\n df[\\\"Delivery Period Combined\\\"] = df['Delivery Periodnew'].fillna(df['Delivery Periodneww'])\\r\\n df=df.drop(columns=['Tendering Period', 'Delivery Period','Tendering Periodneww', 'Delivery Periodneww','Tendering Periodnew', 'Delivery Periodnew',])\\r\\n df.columns=[\\\"duration\\\",\\\"reserve type\\\",\\\"service type\\\",\\\"total contracted volume in MW\\\", \\\"average price in euro/MW/h\\\",\\\"forecasted average price in euro/MW/h\\\",\\\"total offered volume in MW\\\",\\\"tariff period\\\", \\\"symmetry type\\\", \\\"country\\\",\\\"tendering period\\\",\\\"delivery period\\\"] \\r\\n \\r\\n #multi index & sort\\r\\n df=df.set_index([\\\"delivery period\\\"])\\r\\n df=df.sort_index(ascending=False);\\r\\n \\r\\n return df\",\n \"def read_elia_activated_energy_volumes(filename,status):\\r\\n df = pd.read_excel(filename,skiprows=2,parse_dates=False)\\r\\n df[\\\"Timestamp\\\"] = df[\\\"Date\\\"]+\\\" \\\"+df['Quarter'].map(lambda x: str(x)[:-9])\\r\\n pd.to_datetime(df[\\\"Timestamp\\\"])\\r\\n df.set_index(\\\"Timestamp\\\",inplace=True)\\r\\n if ((status == \\\"validated\\\") | (status == \\\"valid\\\")):\\r\\n df = df.drop(df[df.Status != \\\"Validated\\\"].index)\\r\\n df = df.drop([\\\"Date\\\",\\\"Quarter\\\",\\\"Status\\\"], axis=1)\\r\\n \\r\\n if ((len(df.columns)<13) & (len(df.columns)>11)) :\\r\\n df.columns.values[0:13] = [\\\"NRV in MW\\\", \\\"GUV in MW\\\", \\\"IGCC+ in MW\\\", \\\"R2+ in MW\\\", \\\"Bids+ in MW\\\", \\\"R3+ in MW\\\", \\\"R3DP+ in MW\\\", \\\"GDV in MW\\\", \\\"IGCC- in MW\\\", \\\"R2- in MW\\\", \\\"Bids- in MW\\\", \\\"R3- in MW\\\"]\\r\\n if len(df.columns)<= 11:\\r\\n df.columns.values[0:12] = [\\\"NRV in MW\\\", \\\"GUV in MW\\\", \\\"IGCC+ in MW\\\", \\\"R2+ in MW\\\", \\\"Bids+ in MW\\\", \\\"R3+ in MW\\\", \\\"GDV in MW\\\", \\\"IGCC- in MW\\\", \\\"R2- in MW\\\", \\\"Bids- in MW\\\", \\\"R3- in MW\\\"]\\r\\n if len(df.columns)>14:\\r\\n df.columns.values[0:16] = [\\\"NRV in MW\\\", \\\"SR in MW\\\",\\\"GUV in MW\\\", \\\"IGCC+ in MW\\\",\\\"R2+ in MW\\\",\\\"Bids+ in MW\\\",\\\"R3 std in MW\\\",\\\"R3 flex in MW\\\",\\\"ICH in MW\\\",\\\"inter TSO import in MW\\\",\\\"GDV in MW\\\",\\\"IGCC- in MW\\\",\\\"R2- in MW\\\",\\\"Bids- in MW\\\",\\\"inter TSO export in MW\\\"]\\r\\n \\r\\n return df\",\n \"def import_heat_data(self):\\n worksheet = (\\n xlrd.open_workbook(filename=self.filename_heat).sheet_by_index(0)\\n ) \\n self.exh.corrected_reading = np.array(worksheet.col_values(0,\\n start_rowx=self.start_rowx, end_rowx=self.end_rowx)) \\n self.exh.datum = worksheet.cell_value(2,4) # manometer datum (in) \\n self.exh.pressure_drop = ( (self.exh.corrected_reading -\\n self.exh.datum) * 2. * self.H2O_kPa ) \\n # pressure drop across heat exchanger (kPa)\\n self.cummins.torque = np.array(worksheet.col_values(1,\\n start_rowx=self.start_rowx, end_rowx=self.end_rowx))\\n self.exh.T_inlet_array = np.array(worksheet.col_values(2,\\n start_rowx=self.start_rowx, end_rowx=self.end_rowx)) \\n self.exh.T_outlet_array = np.array(worksheet.col_values(3,\\n start_rowx=self.start_rowx, end_rowx=self.end_rowx)) \\n self.cool.T_inlet_array = np.array(worksheet.col_values(5,\\n start_rowx=self.start_rowx, end_rowx=self.end_rowx)) \\n self.cool.T_outlet_array = np.array(worksheet.col_values(4,\\n start_rowx=self.start_rowx, end_rowx=self.end_rowx))\",\n \"def _read_xls(self, options, datas):\\n book = xlrd.open_workbook(file_contents=datas)\\n return self._read_xls_book(book)\",\n \"def test_from_file_xlsx(self):\\n with TemporaryDirectory() as tmp:\\n fp, df_test = save_simple_dataframe(tmp, 'test.xlsx')\\n df_read = BaseDataClass.from_file(fp).df\\n self.assertEqual(\\n pd.testing.assert_frame_equal(df_test, df_read),\\n None,\\n )\",\n \"def load_data_from_xsl(file_name):\\n\\tnlp_data = pd.read_excel(file_name, sheet_name=0, header=0, usecols=[1, 2, 3],\\n\\t converters={'bug_id': str, 'summary': str, 'description': str})\\n\\tnlp_data.fillna(' ', inplace=True)\\n\\n\\t# nlp_data['description'] = nlp_data['description'].map(lambda x: clean_str(x+''))\\n\\n\\treturn nlp_data\",\n \"def main(url):\\n\\n return excel_parser(\\n url,\\n extract_product_from_data\\n )\",\n \"def _handleLoadFile(self) -> None:\\n\\n dialog: ChooseFileDialog = self._makeChooseFileDialog()\\n result: DialogResult = dialog.show()\\n if result == DialogResult.Ok:\\n file: str = dialog.getSelectedFile()\\n self._setWindowTitle(file)\\n data: List[List[Any]] = csvReader.readFile(file)\\n self.__spreadsheet.setData(data)\",\n \"def parse_cases(raw_data_file: str, source_id: str, source_url: str):\\n with open(raw_data_file, \\\"r\\\") as f:\\n reader = csv.DictReader(f)\\n for row in reader:\\n case = {\\n \\\"caseReference\\\": {\\n \\\"sourceId\\\": source_id,\\n \\\"sourceUrl\\\": source_url,\\n },\\n \\\"location\\\": {\\n \\\"query\\\": \\\"Some district, Some country\\\"\\n },\\n \\\"events\\\": [\\n {\\n \\\"name\\\": \\\"confirmed\\\",\\n \\\"dateRange\\\":\\n {\\n \\\"start\\\": \\\"03/06/2020Z\\\",\\n \\\"end\\\": \\\"03/06/2020Z\\\",\\n },\\n },\\n ],\\n }\\n yield case\",\n \"def _read_excel(file: str, semester: str, users: set, courses: set, users_to_courses: dict):\\n course_parts = file.split('/')[-1].split('_')\\n course_name = '{}{}'.format(course_parts[0], course_parts[1])\\n courses.add((course_name, semester))\\n\\n book = xlrd.open_workbook(file)\\n sheet = book.sheet_by_index(0)\\n skip = True\\n\\n for row in sheet.get_rows():\\n first_column = row[0].value\\n if skip:\\n skip = not first_column.startswith(\\\"Name\\\")\\n continue\\n elif first_column == \\\"\\\" or first_column is None:\\n continue\\n\\n full_name = first_column\\n name_parts = [name.strip() for name in full_name.split(', ')]\\n\\n email = row[1].value + '@ithaca.edu'\\n users.add((email, name_parts[0], name_parts[1]))\\n\\n users_to_courses[email].append([course_name, semester])\",\n \"def read_file(path,filename,sheet_name = None, delimiter = None):\\n os.chdir(path)\\n filetype = file.split('.')[1] #splits filename by delimeter '.' to give 'csv' 'xls' or 'xlsx'\\n \\n if filetype == 'csv':\\n if delimiter == None: delimiter = ',' #csv default delimeter should be a comma, but may often be a semi-colon!\\n df = pd.read_csv(file,delimiter)\\n \\n else:\\n df = pd.read_excel(file,sheet_name)\\n \\n return df\",\n \"def __init__(self, input_file):\\n self.file_name = input_file\\n # Import the excel file:\\n self.xlfile = ExcelFile(self.file_name) # to retrieve & work w/ input\",\n \"def _read_workbook_97(maldoc):\\n\\n # Run olevba on the file and extract the XLM macro code lines.\\n color_print.output('g', \\\"Analyzing Excel 97 file ...\\\")\\n xlm_code = _extract_xlm(maldoc)\\n color_print.output('g', \\\"Extracted XLM with olevba.\\\")\\n if debug:\\n print(\\\"=========== START RAW XLM ==============\\\")\\n print(xlm_code)\\n print(\\\"=========== DONE RAW XLM ==============\\\")\\n if (xlm_code is None):\\n color_print.output('r', \\\"ERROR: Unable to extract XLM. Emulation aborted.\\\")\\n return (None, None, None)\\n\\n # Parse the XLM text and get XLM objects that can be emulated.\\n xlm_cells = XLM.stack_transformer.parse_olevba_xlm(xlm_code)\\n color_print.output('g', \\\"Parsed olevba XLM macros.\\\")\\n if (xlm_cells is None):\\n color_print.output('r', \\\"ERROR: Parsing of XLM failed. Emulation aborted.\\\")\\n return (None, None, None)\\n\\n # Merge the XLM cells with the value cells into a single unified spereadsheet\\n # object.\\n workbook, xlm_cell_indices, xlm_sheet = _merge_XLM_cells(maldoc, xlm_cells)\\n if (workbook is None):\\n color_print.output('r', \\\"ERROR: Merging XLM cells failed. Emulation aborted.\\\")\\n return (None, None, None)\\n\\n # Done. \\n return (workbook, xlm_cell_indices, xlm_sheet)\",\n \"def get_entities(self, xlsx_file):\\n \\n self.logger.info(\\\"Loading workbook: {}\\\".format(xlsx_file))\\n\\n # report on total rows.\\n total_rows = sum(1 for row in self._get_rows(xlsx_file))\\n self.logger.info(\\\"Found {} rows.\\\".format(total_rows))\\n \\n # get row data and modified checksum.\\n entity_rows = self._get_rows(xlsx_file)\\n hash_prefix = self._get_hash_prefix(xlsx_file)\\n\\n # get header.\\n row = next(entity_rows)\\n header = [cell.value for cell in row]\\n header= tuple(header)\\n\\n # if header is invalid, return empty generator.\\n if not self._validate_header(header):\\n msg = \\\"Invalid header row: {}.\\\".format(header)\\n raise self.SchemaError(msg)\\n\\n # create generator for each row.\\n def entities():\\n \\n # start numbering at 2 because the header has already been read.\\n row_number = 2\\n \\n # yield a dict for each non-header row.\\n header_range = range(0,len(header))\\n for row in entity_rows:\\n\\n self.logger.info(\\\"Processing row {}.\\\".format(row_number))\\n \\n # get row values.\\n row = [cell.value for cell in row]\\n row = [cell.strip() if isinstance(cell, str) else cell for cell in row]\\n row = [(header[i], row[i]) for i in header_range]\\n row = dict(row)\\n\\n # run row validator.\\n row_valid = self._validate_row(row)\\n if not row_valid:\\n self.logger.warning(\\\"Skipping row {}; row is invalid.\\\".format(\\n row_number))\\n row_number += 1\\n continue\\n \\n # alter data as needed and create dict for row.\\n row[\\\"identifier\\\"] = hash_prefix + row[\\\"identifier\\\"]\\n manifestations = self.get_manifestations(row[\\\"pattern\\\"], \\n row[\\\"case_sensitive\\\"], row_number)\\n row[\\\"manifestations\\\"] = [\\\"\\\".join(m) for m in manifestations]\\n \\n # yield row as dict.\\n row_number += 1\\n yield(row)\\n\\n return entities()\",\n \"def read_meth(filename, name, window, smoothen=5):\\n file_type = file_sniffer(filename)\\n logging.info(\\\"File is of type {}\\\".format(file_type))\\n try:\\n if file_type.startswith(\\\"nanopolish\\\"):\\n return parse_nanopolish(filename, file_type, name, window, smoothen=smoothen)\\n elif file_type == \\\"nanocompore\\\":\\n return parse_nanocompore(filename, name, window)\\n elif file_type == \\\"ont-cram\\\":\\n return parse_ont_cram(filename, name, window)\\n except Exception:\\n sys.stderr.write(\\\"\\\\n\\\\n\\\\nInput file {} not recognized!\\\\n\\\".format(filename))\\n sys.stderr.write(\\\"\\\\n\\\\n\\\\nDetailed error:\\\\n\\\")\\n raise\",\n \"def read_ep_data(path=None):\\n if path is None:\\n path = \\\"\\\"\\\"C:/Users/Brendan/Downloads/ExodusPoint - Assignment Data (Rates Quantitative Strategist) - New York.xlsx\\\"\\\"\\\"\\n \\n xls = pd.ExcelFile(path)\\n legacy_sheets = ['TU - Com; NonCom','FV - Com;NonCom', 'TY - Com;NonCom', 'US - Com;NonCom ', 'WN - Com;NonCom']\\n tff_sheets = ['TU - Sectorial','FV - Sectorial', 'TY - Sectorial', 'US - Sectorial', 'WN - Sectorial']\\n \\n a, b = {}, {}\\n for s in legacy_sheets:\\n d = pd.read_excel(xls, sheet_name=s, index_col=0, header=3, skipfooter=1, parse_dates=True)\\n d = d.rename(rename_legacy_cols, axis=1).drop('Total', axis=1)\\n ct = s[0:2]\\n a[ct] = d\\n legacy_raw = pd.concat(a, axis=1)\\n \\n for s in tff_sheets:\\n d = pd.read_excel(xls, sheet_name=s, index_col=0, header=3, skipfooter=1, parse_dates=True)\\n d = d.rename(rename_tff_cols, axis=1)\\n ct = s[0:2]\\n b[ct] = d\\n tff_raw = pd.concat(b, axis=1)\\n \\n futures_raw = pd.read_excel(xls, sheet_name=\\\"Futures Price and Duration Data\\\",\\n index_col=0, header=[3,4,5], skipfooter=1, parse_dates=True)\\n futures_raw.columns = futures_raw.columns.droplevel(1)\\n futures_raw.columns.set_levels([s[0:2] for s in futures_raw.columns.levels[0]], \\n level=0, inplace=True)\\n futures_raw.columns.set_names(['ct', 'field'], inplace=True)\\n \\n swaps_raw = pd.read_excel(xls, sheet_name=\\\"Swap Prices\\\",\\n index_col=0, header=3, skipfooter=1, parse_dates=True)\\n \\n return legacy_raw, tff_raw, futures_raw, swaps_raw\",\n \"def __init__(self, filepath):\\n self._column_names = []\\n self._row_list = []\\n self._workbook = None\\n\\n try:\\n self._workbook = xlrd.open_workbook(filepath)\\n except:\\n raise Exception('Nie można otworzyć pliku lub nieprawidłowy rodzaj pliku.')\",\n \"def load_excel_file(fname, sheet_name='Sheet1', cell_range=None):\\n #DEPRICATED CODE\\n #d = cell_range.split(:))\\n #row_size = int(d[1][1:]) - int(d[0][1:]) + 1\\n #col_size = (ord(d[1][0].lower()) - 96) - (ord(d[0][0].lower()) - 96) + 1\\n #cell_data = np.zeros([row_size, col_size])\\n\\n wb = openpyxl.load_workbook(fname)\\n sheet = wb[sheet_name]\\n\\n big_list = []\\n for row in sheet[cell_range]:\\n small_list = []\\n for cell in row:\\n #print(cell.coordinate, cell.value)\\n small_list.append(cell.value)\\n big_list.append(small_list)\\n\\n return np.array(big_list)\",\n \"def process(workbook: Any, content: str) -> None:\\n sheets = ['SMB', 'NFS', 'Multiprotocol']\\n\\n row_tuples = dict()\\n row_tuples['SMB'] = [\\n 'ArrayName', 'DataMover', 'ShareName', 'SharePath',\\n 'RootPath', 'Type', 'umask', 'maxusr', 'netbios', 'comment'\\n ]\\n\\n row_tuples['NFS'] = [\\n 'Hostname', 'Server', 'MountedPath', 'FileSystem',\\n 'Type', 'rw', 'root', 'access'\\n ]\\n\\n row_tuples['Multiprotocol'] = [\\n 'Hostname', 'Server',\\n 'MountedPath', 'Type'\\n ]\\n\\n server_export_out = run_parser_over(content, SERVER_EXPORT_TMPL)\\n server_export_grouped = groupby(itemgetter(3), server_export_out)\\n share, export, multi = classify_rows(server_export_grouped)\\n\\n for sheet, data_list in zip(sheets, [share, export, multi]):\\n worksheet = workbook.get_sheet_by_name(sheet)\\n build_header(worksheet, row_tuples[sheet])\\n RowTuple = namedtuple('RowTuple', row_tuples[sheet])\\n\\n final_col, final_row = 0, 0\\n for row_n, row_tuple in enumerate(map(RowTuple._make, data_list), 2):\\n for col_n, col_value in \\\\\\n enumerate(row_tuple._asdict().values(), ord('A')):\\n cell = worksheet['{}{}'.format(column_format(col_n), row_n)]\\n if isinstance(col_value, str):\\n cell.value = str.strip(col_value)\\n else:\\n cell.alignment = Alignment(wrapText=True)\\n cell.value = '\\\\n'.join(col_value)\\n style_value_cell(cell)\\n set_cell_to_number(cell)\\n final_col = col_n\\n final_row = row_n\\n\\n sheet_process_output(\\n worksheet,\\n '{}Table'.format(sheet),\\n sheet,\\n final_col,\\n final_row)\",\n \"def load_data(self) -> pd.DataFrame:\\n\\n if not os.path.exists(self.file_name):\\n raise FileNotFoundError(f\\\"File does not exist: {self.file_name}\\\")\\n\\n _, ext = os.path.splitext(self.file_name)\\n assert ext == \\\".xls\\\", \\\"Invalid filetype attempted to load\\\"\\n\\n return pd.read_excel(self.file_name)\",\n \"def read_from_xlsx(filename='Infosys.xlsx', sheet='Profit & Loss', cell_range=OrderedDict([('A14','J14'), ('A15','J15')])):\\n xl = win32com.client.Dispatch('Excel.Application')\\n try:\\n filename = env.DOWNLOAD_DIR + '\\\\\\\\' + filename\\n wb = xl.Workbooks.Open(Filename=filename, ReadOnly=1, Editable=True)\\n ws = wb.Worksheets(sheet)\\n for k, val in cell_range.items():\\n print (ws.Range(k + ':' + val).Value)\\n\\n except Exception as e:\\n logger.exception(e)\\n\\n else:\\n wb.Close(True)\",\n \"def read(f):\\n book = openpyxl.load_workbook(f) \\n sheet = book.active \\n items_list =[]\\n n = sheet.cell(row = 2, column = 1).value\\n c = sheet.cell(row = 2, column = 2).value\\n for i in range(2,n+2): \\n cell_obj = sheet.cell(row = i, column = 3)\\n items_list.append(cell_obj.value) \\n return items_list,c\",\n \"def parse_input(file_handle):\\n\\tcases = []\\n\\tdata = file_handle.read().split('\\\\n')[1:]\\n\\t# remove empty lines\\n\\tdata = [x.split(' ') for x in data if x != '']\\n\\tdata = [[int(x) for x in y] for y in data]\\n\\t[cases.append(case(data[x])) for x in range(len(data))]\\n\\treturn cases\",\n \"def loadData(self, file, sheet, cols, skip):\\n df = pd.read_excel(io=file, sheetname=sheet, header=0, parse_cols=cols, skiprows=skip).values\\n return df\",\n \"def loadData(fileName, fileType):\\n try:\\n if (fileType == 'xlsx' or fileType == 'xls' or fileType == 'excel'):\\n temp = pd.read_excel(fileName)\\n elif fileType == 'csv':\\n temp = pd.read_csv(fileName)\\n else:\\n return\\n except FileNotFoundError:\\n return 'FileNotFoundError'\\n else:\\n return temp\",\n \"def read_lines(the_file, worksheet, w):\\n ListOfData = []\\n Cpu_Usage = 'usr', 'sys', 'idl', 'wai', 'hiq', 'siq'\\n Cpu_bool = False\\n Mem_Usage = 'used', 'buff', 'cach', 'free'\\n Mem_bool = False\\n Disk_Usage = 'read', 'writ'\\n Disk_bool = False\\n Net_Usage = 'recv', 'send'\\n Net_bool = False\\n rowNum = 7\\n lineCount = 8\\n\\n #with open(the_file) as input_data:\\n for line in the_file:\\n if \\\"failed\\\" in line:\\n error_mssg = line\\n print \\\"Error message found in log: \\\", error_mssg\\n worksheet[w].write(0, 0, 'Error Message in log: ' + error_mssg)\\n continue\\n if \\\"total-cpu-usage\\\" in line:\\n ListOfData.append(Cpu_Usage)\\n worksheet[w].write(6, 0, 'Total CPU Usage')\\n Cpu_bool = True\\n if \\\"memory-usage\\\" in line:\\n ListOfData.append(Mem_Usage)\\n worksheet[w].write(6, 6, 'Memory Usage')\\n Mem_bool = True\\n if \\\"dsk/sd\\\" in line:\\n ListOfData.append(Disk_Usage)\\n worksheet[w].write(6, 10, 'Disk Usage')\\n Disk_bool = True\\n if \\\"net/eth\\\" in line:\\n ListOfData.append(Net_Usage)\\n worksheet[w].write(6, 12, 'Network Usage')\\n Net_bool = True\\n continue\\n continue\\n else:\\n line = line.replace(\\\"|\\\", \\\" \\\")\\n line = line.replace(\\\"\\\\n\\\", \\\"\\\")\\n line = re.sub(\\\" +\\\", \\\" \\\", line)\\n lineCount = lineCount + 1\\n if line[0] == \\\" \\\":\\n line = line[1:]\\n else:\\n line = line[0:]\\n #print line\\n for a in ListOfData:\\n colNum = 0\\n a = [[y] for y in line.split(\\\" \\\")]\\n #print \\\"This is an a: \\\", a\\n for i in a:\\n #print \\\"This is i:\\\", i[0]\\n if \\\"M\\\" in i[0]:\\n i[0] = (float(i[0].replace(\\\"M\\\", \\\"\\\"))*1048576)\\n elif \\\"k\\\" in i[0] and not \\\"dsk\\\" in i[0] and not \\\"ticks\\\" in i[0]:\\n i[0] = (float(i[0].replace(\\\"k\\\", \\\"\\\"))*1024)\\n elif \\\"B\\\" in i[0]:\\n i[0] = (float(i[0].replace(\\\"B\\\", \\\"\\\")))\\n elif \\\"G\\\" in i[0]:\\n i[0] = (float(i[0].replace(\\\"G\\\", \\\"\\\"))*1073741824)\\n try:\\n i = float(i[0])\\n #print \\\"Converting to float!\\\"\\n worksheet[w].write_number(rowNum, colNum, i)\\n colNum = colNum + 1\\n except:\\n worksheet[w].write_row(rowNum, colNum, i)\\n colNum = colNum + 1\\n rowNum = rowNum + 1\\n continue\\n return Cpu_bool, Mem_bool, Disk_bool, Net_bool, worksheet, lineCount\",\n \"def read_xls_csv(self):\\n filename = str(self.filename)\\n location_stock_id = self.location\\n vals = []\\n inventory_create = self.env['stock.inventory']\\n\\n if (filename.endswith('xls') or filename.endswith('xlsx')):\\n wb = xlrd.open_workbook(\\n file_contents=base64.decodestring(self.xls_file))\\n sheet = wb.sheet_by_index(0)\\n\\n for i in range(1, sheet.nrows):\\n row = sheet.row_values(i)\\n firstrow = sheet.row_values(0)\\n firstrow = [str(item).lower() for item in firstrow]\\n pid = row[firstrow.index('id')]\\n quantity = row[firstrow.index('quantity')]\\n product_obj = self.env['product.product'].search(\\n [('id', '=', pid)])\\n vals.append({\\n 'product_code': product_obj.default_code,\\n 'product_qty': quantity,\\n 'location_id': location_stock_id.id,\\n 'product_id': product_obj.id\\n })\\n inv = inventory_create.create({'name': self.inventory_name,\\n 'location_id': location_stock_id.id,\\n 'filter': 'partial'})\\n stock_inventory_line = self.env['stock.inventory.line']\\n # inv.prepare_inventory()\\n for record in vals:\\n record.update({'inventory_id': inv.id})\\n stock_inventory_line.create(record)\\n inv.action_done()\\n\\n else:\\n xls_file = base64.b64decode(self.xls_file)\\n file_input = cStringIO.StringIO(xls_file)\\n file_input.seek(0)\\n rows = []\\n delimeter = ','\\n reader = csv.reader(file_input, delimiter=delimeter,\\n lineterminator='\\\\r\\\\n')\\n for row in reader:\\n rows.append(row)\\n for row in rows[1:]:\\n rows[0] = [str(item).lower() for item in rows[0]]\\n product_obj = self.env['product.product'].search(\\n [('id', '=', row[rows[0].index('id')])])\\n vals.append({\\n 'product_code': row[rows[0].index('id')],\\n 'product_qty': row[rows[0].index('quantity')],\\n 'location_id': location_stock_id.id,\\n 'product_id': product_obj.id\\n })\\n inv = inventory_create.create({'name': self.inventory_name,\\n 'location_id': location_stock_id.id,\\n 'filter': 'partial'})\\n stock_inventory_line = self.env['stock.inventory.line']\\n # inv.prepare_inventory()\\n for record in vals:\\n record.update({'inventory_id': inv.id})\\n stock_inventory_line.create(record)\\n inv.action_done()\\n return {\\n 'name': 'Stock import',\\n 'type': 'ir.actions.act_window',\\n 'view_type': 'form',\\n 'res_id': self.id,\\n 'view_mode': 'tree,form',\\n 'res_model': 'stock.inventory',\\n 'target': 'current',\\n }\",\n \"def parse_result_file(self, filepath: str):\\n\\n raise NotImplementedError\",\n \"def read_elia_freq_R1(filename):\\r\\n df = pd.read_excel(filename,skiprows=4,parse_dates=True,index_col=0,dayfirst=True)\\r\\n df=df.drop(df.index[[0]])\\r\\n df.columns.values[0:3] = [\\\"Frequency\\\",\\\"ObligationR1\\\",\\\"RequestedR1\\\"]\\r\\n \\r\\n return df\",\n \"def _parse_ach_file(self, contents):\\n file_length = len(contents)\\n\\n for index in range(0, file_length, self.LINE_LENGTH):\\n line = contents[index:index + self.LINE_LENGTH]\\n\\n if line.startswith('1'):\\n self._read_header(line)\\n elif line.startswith('5'):\\n self._read_batch_header(line)\\n elif line.startswith('6'):\\n self._read_entry_detail(line)\\n elif line.startswith('7'):\\n self._read_addenda_record(line)\\n elif line.startswith('8'):\\n self._read_batch_control_record(line)\\n elif line.startswith('9'):\\n if line == '9' * 94:\\n continue\\n self._read_file_control_record(line)\",\n \"def import_excel(self):\\n self.ensure_one()\\n if self.file_import:\\n filecontent = base64.b64decode(self.file_import)\\n try:\\n # Todo: import excel\\n input = cStringIO.StringIO()\\n input.write(filecontent)\\n wb = open_workbook(file_contents=input.getvalue())\\n problem_emails = {\\\"inserted_names\\\": [],\\n \\\"inserted_emails\\\": [],\\n \\\"invalid_emails\\\": [],\\n \\\"duplicate_names\\\": [],\\n \\\"duplicate_emails\\\": []}\\n for sheet in wb.sheets():\\n try:\\n self.insert_db(sheet, wb, problem_emails)\\n except Exception as e:\\n raise (str(e))\\n\\n except:\\n # todo: import csv\\n wb = filecontent.split('\\\\r\\\\n')\\n for line in range(1, len(wb) - 1):\\n line_data = wb[line].split(',')\\n self.crete_line(line_data[0], line_data[1])\\n\\n if problem_emails['invalid_emails']:\\n raise except_orm(_('Invalid Email Format Found!'),\\n _( '\\\\n'.join(map(str, list(item for item in problem_emails['invalid_emails']))) + '\\\\n\\\\n Please check and try again.'))\\n if problem_emails['duplicate_names']:\\n raise except_orm(_('Duplicate Name Found!'),\\n _( '\\\\n'.join(map(str, list(item for item in problem_emails['duplicate_names']))) + '\\\\n\\\\n Please check and try again.'))\\n if problem_emails['duplicate_emails']:\\n raise except_orm(_('Duplicate Email Found!'),\\n _( '\\\\n'.join(map(str, list(item for item in problem_emails['duplicate_emails']))) + '\\\\n\\\\n Please check and try again.'))\\n\\n return {\\n 'view_type': 'form',\\n 'view_mode': 'form',\\n 'res_model': 'shipmaster.invitation',\\n 'res_id': self.id,\\n 'view_id': False,\\n 'type': 'ir.actions.act_window',\\n 'target': 'new',\\n }\",\n \"def test_assemble_xml_file_A1(self):\\n self.maxDiff = None\\n\\n fh = StringIO()\\n worksheet = Worksheet()\\n worksheet._set_filehandle(fh)\\n cell_format = Format({\\\"xf_index\\\": 1})\\n\\n # No format. Should be ignored.\\n worksheet.write_blank(\\\"A1\\\", None)\\n\\n worksheet.write_blank(\\\"C2\\\", None, cell_format)\\n\\n worksheet.select()\\n worksheet._assemble_xml_file()\\n\\n exp = _xml_to_list(\\n \\\"\\\"\\\"\\n <?xml version=\\\"1.0\\\" encoding=\\\"UTF-8\\\" standalone=\\\"yes\\\"?>\\n <worksheet xmlns=\\\"http://schemas.openxmlformats.org/spreadsheetml/2006/main\\\" xmlns:r=\\\"http://schemas.openxmlformats.org/officeDocument/2006/relationships\\\">\\n <dimension ref=\\\"C2\\\"/>\\n <sheetViews>\\n <sheetView tabSelected=\\\"1\\\" workbookViewId=\\\"0\\\"/>\\n </sheetViews>\\n <sheetFormatPr defaultRowHeight=\\\"15\\\"/>\\n <sheetData>\\n <row r=\\\"2\\\" spans=\\\"3:3\\\">\\n <c r=\\\"C2\\\" s=\\\"1\\\"/>\\n </row>\\n </sheetData>\\n <pageMargins left=\\\"0.7\\\" right=\\\"0.7\\\" top=\\\"0.75\\\" bottom=\\\"0.75\\\" header=\\\"0.3\\\" footer=\\\"0.3\\\"/>\\n </worksheet>\\n \\\"\\\"\\\"\\n )\\n\\n got = _xml_to_list(fh.getvalue())\\n\\n self.assertEqual(got, exp)\",\n \"def process_files(geodata_name, inp_dict):\\n input_paths = inp_dict[\\\".xls\\\"][:]\\n try:\\n data = geodata(geodata_name)\\n except UnicodeDecodeError:\\n showerror(\\\"Ошибка кодирования\\\", \\\"Файл данных должен быть закодирован в utf-8\\\")\\n data = geodata(askopenfilenames(initialdir=os.path.abspath(os.getcwd()), filetypes=[(\\\"Файл данных txt\\\", \\\".txt\\\")], title=\\\"Выберите файл данных txt\\\")[0])\\n\\n\\n for book in input_paths:\\n book_flag = False\\n with open_workbook(book, formatting_info=True) as rb:\\n header = False\\n wb = copy(rb)\\n for numb, sheet in enumerate(rb.sheets()):\\n column = \\\"False\\\"\\n for row in range(sheet.nrows):\\n if column != \\\"False\\\":\\n for data_row in data:\\n if sheet.cell(row, column).value == data_row[0]:\\n sheet_wb = wb.get_sheet(numb)\\n sheet_wb.write(row, sheet.ncols, data_row[1])\\n sheet_wb.write(row, sheet.ncols+1, data_row[2])\\n break\\n else:\\n for col in range(sheet.ncols):\\n for data_row in data:\\n if sheet.cell(row, col).value == data_row[0]:\\n column = col\\n book_flag = True\\n sheet_wb = wb.get_sheet(numb)\\n sheet_wb.write(row, sheet.ncols, data_row[1])\\n sheet_wb.write(row, sheet.ncols+1, data_row[2])\\n if not header:\\n header = True\\n style_list = get_xlwt_style_list(rb)\\n wb.get_sheet(numb).write(0, sheet.ncols, u\\\"Широта\\\", style=style_list[sheet.cell_xf_index(0, 0)])\\n wb.get_sheet(numb).write(0, sheet.ncols+1, u\\\"Долгота\\\", style=style_list[sheet.cell_xf_index(0, 0)])\\n break\\n if book_flag:\\n if not os.path.isdir(\\\"out\\\"):\\n os.mkdir(\\\"out\\\")\\n f_out = get_output_name(book)\\n wb.save(f_out)\\n inp_dict[\\\"del\\\"].append(f_out)\\n inp_dict[\\\"out\\\"].append(f_out)\\n return inp_dict\",\n \"def file_loading():\\r\\n print(\\\"Loading the three excel files.\\\")\\r\\n\\r\\n elec_data1 = pd.read_excel(ELEC_FILE, sheet_name=ELEC_SHEET1)\\r\\n elec_data2 = pd.read_excel(ELEC_FILE, sheet_name=ELEC_SHEET2,\\r\\n skiprows=1)\\r\\n\\r\\n strp_elec1 = elec_data1[['Table', 'Column', 'SAP required']]\\r\\n strp_elec1 = strp_elec1.rename(columns={'Table': 'TABLE',\\r\\n 'Column': 'COLUMN',\\r\\n 'SAP required': 'SAP'})\\r\\n\\r\\n strp_elec2 = elec_data2[['Source Table', 'Source Column', 'SAP required']]\\r\\n strp_elec2 = strp_elec2.rename(columns={'Source Table': 'TABLE',\\r\\n 'Source Column': 'COLUMN',\\r\\n 'SAP required': 'SAP'})\\r\\n return strp_elec1, strp_elec2\",\n \"def import_building_from_excel(\\n project, building_name, construction_age, path_to_excel, sheet_names\\n):\\n\\n def warn_constructiontype(element):\\n \\\"\\\"\\\"Generic warning function\\\"\\\"\\\"\\n if element.construction_type is None:\\n warnings.warn(\\n 'In zone \\\"%s\\\" the %s construction \\\"%s\\\" could not be loaded from the TypeBuildingElements.json, '\\n \\\"an error will occur due to missing data for calculation.\\\"\\n \\\"Check for spelling and the correct combination of building age and construction type.\\\"\\n \\\"Here is the list of faulty entries:\\\\n%s\\\"\\n \\\"\\\\nThese entries can easily be found checking the stated index in the produced ZonedInput.xlsx\\\"\\n % (\\n group[\\\"zone\\\"].iloc[0],\\n element.name,\\n group[\\\"OuterWallConstruction\\\"].iloc[0],\\n group,\\n )\\n )\\n\\n bldg = Building(parent=project)\\n bldg.name = building_name\\n bldg.year_of_construction = construction_age\\n bldg.with_ahu = True # HardCodedInput\\n if bldg.with_ahu is True:\\n bldg.central_ahu.heat_recovery = True # HardCodedInput\\n bldg.central_ahu.efficiency_recovery = 0.35 # HardCodedInput\\n bldg.central_ahu.temperature_profile = 25 * [273.15 + 18] # HardCodedInput\\n bldg.central_ahu.min_relative_humidity_profile = 25 * [0] # HardCodedInput\\n bldg.central_ahu.max_relative_humidity_profile = 25 * [1] # HardCodedInput\\n bldg.central_ahu.v_flow_profile = 25 * [1] # HardCodedInput\\n\\n # Parameters that need hard coding in teasers logic classes\\n # 1. \\\"use_set_back\\\" needs hard coding at aixlib.py in the init; defines\\n # if the in the useconditions stated\\n # heating_time with the respective set_back_temp should be applied.\\n # use_set_back = false -> all hours of the day\\n # have same set_temp_heat actual value: use_set_back = Check your current version!\\n # 2. HeaterOn, CoolerOn, hHeat, lCool, etc. can be hard coded in the text\\n # file\\n # \\\"teaser / data / output / modelicatemplate / AixLib /\\n # AixLib_ThermalZoneRecord_TwoElement\\\"\\n # actual changes: Check your current version!\\n\\n # Parameters to be set for each and every zone (#HardCodedInput)\\n # -----------------------------\\n out_wall_tilt = 90\\n window_tilt = 90\\n ground_floor_tilt = 0\\n floor_tilt = 0\\n ceiling_tilt = 0\\n rooftop_tilt = 0\\n ground_floor_orientation = -2\\n floor_orientation = -2\\n rooftop_orientation = -1\\n ceiling_orientation = -1\\n # -----------------------------\\n\\n # load_building_data from excel_to_pandas DataFrame:\\n data = import_data(path_to_excel, sheet_names)\\n\\n # informative print\\n usage_types = get_list_of_present_entries(data[\\\"UsageType\\\"])\\n print(\\\"List of present usage_types in the original Data set: \\\\n%s\\\" % usage_types)\\n\\n # define the zoning methodology/function\\n data = zoning_example(data)\\n\\n # informative print\\n usage_types = get_list_of_present_entries(data[\\\"Zone\\\"])\\n print(\\\"List of zones after the zoning is applied: \\\\n%s\\\" % usage_types)\\n\\n # aggregate all rooms of each zone and for each set general parameter,\\n # boundary conditions\\n # and parameter regarding the building physics\\n zones = data.groupby([\\\"Zone\\\"])\\n for name, zone in zones:\\n\\n # Block: Thermal zone (general parameter)\\n tz = ThermalZone(parent=bldg)\\n tz.name = str(name)\\n tz.area = zone[\\\"NetArea[m²]\\\"].sum()\\n # room vice calculation of volume plus summing those\\n tz.volume = (\\n np.array(zone[\\\"NetArea[m²]\\\"]) * np.array(zone[\\\"HeatedRoomHeight[m]\\\"])\\n ).sum()\\n\\n # Block: Boundary Conditions\\n # load UsageOperationTime, Lighting, RoomClimate and InternalGains\\n # from the \\\"UseCondition.json\\\"\\n tz.use_conditions = UseConditions(parent=tz)\\n tz.use_conditions.load_use_conditions(zone[\\\"Zone\\\"].iloc[0], project.data)\\n\\n # Block: Building Physics\\n # Grouping by orientation and construction type\\n # aggregating and feeding to the teaser logic classes\\n grouped = zone.groupby([\\\"OuterWallOrientation[°]\\\", \\\"OuterWallConstruction\\\"])\\n for name, group in grouped:\\n # looping through a groupby object automatically discards the\\n # groups where one of the attributes is nan\\n # additionally check for strings, since the value must be of type\\n # int or float\\n if not isinstance(group[\\\"OuterWallOrientation[°]\\\"].iloc[0], str):\\n out_wall = OuterWall(parent=tz)\\n out_wall.name = (\\n \\\"outer_wall_\\\"\\n + str(int(group[\\\"OuterWallOrientation[°]\\\"].iloc[0]))\\n + \\\"_\\\"\\n + str(group[\\\"OuterWallConstruction\\\"].iloc[0])\\n )\\n out_wall.area = group[\\\"OuterWallArea[m²]\\\"].sum()\\n out_wall.tilt = out_wall_tilt\\n out_wall.orientation = group[\\\"OuterWallOrientation[°]\\\"].iloc[0]\\n # load wall properties from \\\"TypeBuildingElements.json\\\"\\n out_wall.load_type_element(\\n year=bldg.year_of_construction,\\n construction=group[\\\"OuterWallConstruction\\\"].iloc[0],\\n )\\n warn_constructiontype(out_wall)\\n else:\\n warnings.warn(\\n 'In zone \\\"%s\\\" the OuterWallOrientation \\\"%s\\\" is '\\n \\\"neither float nor int, \\\"\\n \\\"hence this building element is not added.\\\\nHere is the \\\"\\n \\\"list of faulty entries:\\\\n%s\\\"\\n \\\"\\\\n These entries can easily be found checking the stated \\\"\\n \\\"index in the produced ZonedInput.xlsx\\\"\\n % (\\n group[\\\"Zone\\\"].iloc[0],\\n group[\\\"OuterWallOrientation[°]\\\"].iloc[0],\\n group,\\n )\\n )\\n\\n grouped = zone.groupby([\\\"WindowOrientation[°]\\\", \\\"WindowConstruction\\\"])\\n for name, group in grouped:\\n # looping through a groupby object automatically discards the\\n # groups where one of the attributes is nan\\n # additionally check for strings, since the value must be of type\\n # int or float\\n if not isinstance(group[\\\"OuterWallOrientation[°]\\\"].iloc[0], str):\\n window = Window(parent=tz)\\n window.name = (\\n \\\"window_\\\"\\n + str(int(group[\\\"WindowOrientation[°]\\\"].iloc[0]))\\n + \\\"_\\\"\\n + str(group[\\\"WindowConstruction\\\"].iloc[0])\\n )\\n window.area = group[\\\"WindowArea[m²]\\\"].sum()\\n window.tilt = window_tilt\\n window.orientation = group[\\\"WindowOrientation[°]\\\"].iloc[0]\\n # load wall properties from \\\"TypeBuildingElements.json\\\"\\n window.load_type_element(\\n year=bldg.year_of_construction,\\n construction=group[\\\"WindowConstruction\\\"].iloc[0],\\n )\\n warn_constructiontype(window)\\n else:\\n warnings.warn(\\n 'In zone \\\"%s\\\" the window orientation \\\"%s\\\" is neither '\\n \\\"float nor int, \\\"\\n \\\"hence this building element is not added. Here is the \\\"\\n \\\"list of faulty entries:\\\\n%s\\\"\\n \\\"\\\\nThese entries can easily be found checking the stated \\\"\\n \\\"index in the produced ZonedInput.xlsx\\\"\\n % (\\n group[\\\"Zone\\\"].iloc[0],\\n group[\\\"WindowOrientation[°]\\\"].iloc[0],\\n group,\\n )\\n )\\n\\n grouped = zone.groupby([\\\"IsGroundFloor\\\", \\\"FloorConstruction\\\"])\\n for name, group in grouped:\\n if group[\\\"NetArea[m²]\\\"].sum() != 0: # to avoid devision by 0\\n if group[\\\"IsGroundFloor\\\"].iloc[0] == 1:\\n ground_floor = GroundFloor(parent=tz)\\n ground_floor.name = \\\"ground_floor\\\" + str(\\n group[\\\"FloorConstruction\\\"].iloc[0]\\n )\\n ground_floor.area = group[\\\"NetArea[m²]\\\"].sum()\\n ground_floor.tilt = ground_floor_tilt\\n ground_floor.orientation = ground_floor_orientation\\n # load wall properties from \\\"TypeBuildingElements.json\\\"\\n ground_floor.load_type_element(\\n year=bldg.year_of_construction,\\n construction=group[\\\"FloorConstruction\\\"].iloc[0],\\n )\\n warn_constructiontype(ground_floor)\\n elif group[\\\"IsGroundFloor\\\"].iloc[0] == 0:\\n floor = Floor(parent=tz)\\n floor.name = \\\"floor\\\" + str(group[\\\"FloorConstruction\\\"].iloc[0])\\n floor.area = group[\\\"NetArea[m²]\\\"].sum() / 2 # only half of\\n # the floor belongs to this story\\n floor.tilt = floor_tilt\\n floor.orientation = floor_orientation\\n # load wall properties from \\\"TypeBuildingElements.json\\\"\\n floor.load_type_element(\\n year=bldg.year_of_construction,\\n construction=group[\\\"FloorConstruction\\\"].iloc[0],\\n )\\n warn_constructiontype(floor)\\n else:\\n warnings.warn(\\n \\\"Values for IsGroundFloor have to be either 0 or 1, \\\"\\n \\\"for no or yes respectively\\\"\\n )\\n else:\\n warnings.warn(\\n 'zone \\\"%s\\\" with IsGroundFloor \\\"%s\\\" and construction '\\n 'type \\\"%s\\\" '\\n \\\"has no floor nor groundfloor, since the area equals 0.\\\"\\n % (\\n group[\\\"Zone\\\"].iloc[0],\\n group[\\\"IsGroundFloor\\\"].iloc[0],\\n group[\\\"FloorConstruction\\\"].iloc[0],\\n )\\n )\\n\\n grouped = zone.groupby([\\\"IsRooftop\\\", \\\"CeilingConstruction\\\"])\\n for name, group in grouped:\\n if group[\\\"NetArea[m²]\\\"].sum() != 0: # to avoid devision by 0\\n if group[\\\"IsRooftop\\\"].iloc[0] == 1:\\n rooftop = Rooftop(parent=tz)\\n rooftop.name = \\\"rooftop\\\" + str(group[\\\"CeilingConstruction\\\"].iloc[0])\\n rooftop.area = group[\\n \\\"NetArea[m²]\\\"\\n ].sum() # sum up area of respective\\n # rooftop parts\\n rooftop.tilt = rooftop_tilt\\n rooftop.orientation = rooftop_orientation\\n # load wall properties from \\\"TypeBuildingElements.json\\\"\\n rooftop.load_type_element(\\n year=bldg.year_of_construction,\\n construction=group[\\\"CeilingConstruction\\\"].iloc[0],\\n )\\n warn_constructiontype(rooftop)\\n elif group[\\\"IsRooftop\\\"].iloc[0] == 0:\\n ceiling = Ceiling(parent=tz)\\n ceiling.name = \\\"ceiling\\\" + str(group[\\\"CeilingConstruction\\\"].iloc[0])\\n ceiling.area = group[\\\"NetArea[m²]\\\"].sum() / 2 # only half\\n # of the ceiling belongs to a story,\\n # the other half to the above\\n ceiling.tilt = ceiling_tilt\\n ceiling.orientation = ceiling_orientation\\n # load wall properties from \\\"TypeBuildingElements.json\\\"\\n ceiling.load_type_element(\\n year=bldg.year_of_construction,\\n construction=group[\\\"CeilingConstruction\\\"].iloc[0],\\n )\\n warn_constructiontype(ceiling)\\n else:\\n warnings.warn(\\n \\\"Values for IsRooftop have to be either 0 or 1, \\\"\\n \\\"for no or yes respectively\\\"\\n )\\n else:\\n warnings.warn(\\n 'zone \\\"%s\\\" with IsRooftop \\\"%s\\\" and construction type '\\n '\\\"%s\\\" '\\n \\\"has no ceiling nor rooftop, since the area equals 0.\\\"\\n % (\\n group[\\\"Zone\\\"].iloc[0],\\n group[\\\"IsRooftop\\\"].iloc[0],\\n group[\\\"CeilingConstruction\\\"].iloc[0],\\n )\\n )\\n\\n grouped = zone.groupby([\\\"InnerWallConstruction\\\"])\\n for name, group in grouped:\\n if group[\\\"InnerWallArea[m²]\\\"].sum() != 0: # to avoid devision by 0\\n in_wall = InnerWall(parent=tz)\\n in_wall.name = \\\"inner_wall\\\" + str(\\n group[\\\"InnerWallConstruction\\\"].iloc[0]\\n )\\n in_wall.area = group[\\\"InnerWallArea[m²]\\\"].sum() / 2 # only\\n # half of the wall belongs to each room,\\n # the other half to the adjacent\\n # load wall properties from \\\"TypeBuildingElements.json\\\"\\n in_wall.load_type_element(\\n year=bldg.year_of_construction,\\n construction=group[\\\"InnerWallConstruction\\\"].iloc[0],\\n )\\n warn_constructiontype(in_wall)\\n else:\\n warnings.warn(\\n 'zone \\\"%s\\\" with inner wall construction \\\"%s\\\" has no '\\n \\\"inner walls, since area = 0.\\\"\\n % (group[\\\"Zone\\\"].iloc[0], group[\\\"InnerWallConstructio\\\" \\\"n\\\"].iloc[0])\\n )\\n\\n # Block: AHU and infiltration #Attention hard coding\\n # set the supply volume flow of the AHU per zone\\n ahu_dict = {\\n \\\"Bedroom\\\": [15.778, 15.778],\\n \\\"Corridorsinthegeneralcarearea\\\": [5.2941, 5.2941],\\n \\\"Examinationortreatmentroom\\\": [15.743, 15.743],\\n \\\"MeetingConferenceseminar\\\": [16.036, 16.036],\\n \\\"Stocktechnicalequipmentarchives\\\": [20.484, 20.484],\\n \\\"WCandsanitaryroomsinnonresidentialbuildings\\\": [27.692, 27.692],\\n }\\n _i = 0\\n for key in ahu_dict:\\n if tz.name == key:\\n tz.use_conditions.min_ahu = ahu_dict[key][0]\\n tz.use_conditions.max_ahu = ahu_dict[key][1]\\n _i = 1\\n if _i == 0:\\n warnings.warn(\\n \\\"The zone %s could not be found in your ahu_dict. Hence, \\\"\\n \\\"no AHU flow is defined. The default value is \\\"\\n \\\"0 (min_ahu = 0; max_ahu=0\\\" % tz.name\\n )\\n\\n return project, data\",\n \"def read_sheet(workbook, name):\\n\\n sheet = workbook.sheet_by_name(name)\\n\\n # Number of written Rows in sheet\\n r = sheet.nrows\\n # Number of written Columns in sheet\\n c = sheet.ncols\\n\\n data = np.zeros([r - 1, c])\\n # Reading each cell in excel sheet 'BC'\\n for i in range(1, r):\\n for j in range(c):\\n data[i - 1, j] = float(sheet.cell_value(i, j))\\n\\n return data\",\n \"def __load( self, raw_content ):\\n return( pd.read_excel( BytesIO( raw_content ) ) )\",\n \"def test_parse_samplesheet(self):\\n run_dir = 'data/nanopore_data/run4/done_demuxing/20200104_1412_MN19414_AAU644_68125dc2'\\n run = MinIONqc(run_dir, None, None)\\n run.lims_samplesheet = 'data/nanopore_samplesheets/2020/DELIVERY_SQK-LSK109_AAU644_Samplesheet_24-594126.csv'\\n run._parse_samplesheet()\\n self.assertTrue(filecmp.cmp(run.nanoseq_sample_sheet, 'data/nanopore_samplesheets/expected/SQK-LSK109_sample_sheet.csv'))\\n self.assertTrue(filecmp.cmp(run.anglerfish_sample_sheet, 'data/nanopore_samplesheets/expected/anglerfish_sample_sheet.csv'))\",\n \"def parse_file(filename):\\r\\n print(filename)\\r\\n fh = open(filename)\\r\\n header = next(fh)\\r\\n output_file = open(\\\"Sex\\\" + \\\"1_\\\" + filename, \\\"a\\\")\\r\\n output_file.write(header)\\r\\n output_file2 = open(\\\"Sex\\\" + \\\"2_\\\" + filename, \\\"a\\\")\\r\\n output_file2.write(header)\\r\\n\\r\\n for line in fh:\\r\\n line = line.strip().split(\\\",\\\") # split by \\\",\\\" because it is a csv file\\r\\n line = pre_process_data(line)\\r\\n if int(line[2]) == 1:\\r\\n print(line)\\r\\n output_file.write(\\\",\\\".join(line) + \\\"\\\\n\\\")\\r\\n else:\\r\\n output_file2.write(\\\",\\\".join(line) + \\\"\\\\n\\\")\\r\\n output_file.close()\\r\\n output_file2.close()\\r\\n fh.close()\",\n \"def extract(fileName, sheetName,\\n rangeSpec=None, rangeName=None,\\n maxRows=None, maxCols=None):\\n from rlextra.thirdparty.xlrd.biffh import \\\\\\n XL_CELL_EMPTY, XL_CELL_DATE#, XL_CELL_TEXT, XL_CELL_NUMBER, XL_CELL_BOOLEAN, XL_CELL_ERROR\\n\\n if rangeName is not None:\\n raise NotImplementedError('rangeName not yet implemented')\\n\\n book = xlrd.open_workbook(fileName, verbosity=0)\\n sheet = book.sheet_by_name(sheetName)\\n\\n if rangeSpec is not None:\\n if rangeSpec.count(':') != 1:\\n raise ValueError(\\\"Bad Excel cell range: %r\\\" % rangeSpec)\\n cell1, cell2 = [xlCellSpecToCoord(cellSpec) for cellSpec in rangeSpec.split(\\\":\\\")]\\n cols = cell1[0], cell2[0]\\n rows = cell1[1], cell2[1]\\n colMin, colMax = min(cols), max(cols)+1\\n rowMin, rowMax = min(rows), max(rows)+1\\n\\n if rangeSpec is None and rangeName is None:\\n rowMin = colMin = 0\\n rowMax = sheet.nrows+1\\n colMax = sheet.ncols+1\\n\\n if maxCols is not None:\\n colMax = min(colMax, maxCols)\\n if maxRows is not None:\\n rowMax = min(rowMax, maxRows)\\n\\n out = []\\n for rowx in range(rowMin, rowMax):\\n row = []\\n for colx in range(colMin, colMax):\\n cellType = sheet.cell_type(rowx, colx)\\n cellValue = sheet.cell_value(rowx, colx)\\n\\n if cellType is XL_CELL_EMPTY:\\n cellValue = None\\n elif cellType is XL_CELL_DATE:\\n #convert\\n yyyy,mm,dd,hh,nn,ss = xlrd.xldate_as_tuple(cellValue, book.datemode)\\n cellValue = datetime.date(yyyy,mm,dd)\\n else:\\n pass #native value is OK\\n\\n row.append(cellValue)\\n #now trim empties off the row - we don't want extra stuff on the\\n #right, which might be hundreds of rows.\\n \\n while row and row[-1] is None:\\n row.pop()\\n\\n out.append(row)\\n\\n #now trim off any blank rows at the end\\n while out[-1:] == []:\\n out.pop()\\n return out\",\n \"def parse(filename):\\n if filename.endswith('.tsv'):\\n # Horrible filename-based hack; in future examine contents of file here\\n return parse_separated(filename, '\\\\t')\\n if filename.endswith('.xlsx'):\\n return parse_xlsx(filename)\\n # fallback to old assume-csv behavior\\n return parse_separated(filename, ',')\",\n \"def main():\\n data_dir = \\\".\\\\\\\\excel\\\\\\\\data\\\\\\\\\\\"\\n archive_dir = \\\".\\\\\\\\excel\\\\\\\\archive\\\\\\\\\\\"\\n xl_list = glob.glob(data_dir + \\\"*.xlsx\\\")\\n\\n try:\\n for xl_file in xl_list:\\n workbook = pd.ExcelFile(xl_file)\\n\\n if fnmatch.fnmatch(xl_file.lower(), \\\"*base*.xlsx\\\") == True:\\n print(f\\\"Creating DataFrame for '{xl_file}'...\\\")\\n \\n df_base = workbook.parse(0, skiprows=1, header=None)\\n df_base.columns = [\\\"dept\\\", \\n \\\"category\\\", \\n \\\"itemDesc\\\", \\n \\\"itemCode\\\", \\n \\\"itemSize\\\", \\n \\\"pvtLblFlag\\\", \\n \\\"buyerCode\\\", \\n \\\"invUnitShipped\\\", \\n \\\"invCaseShipped\\\", \\n \\\"storeOrdProdQty\\\", \\n \\\"shortedQty\\\", \\n \\\"grossSvcLvl\\\", \\n \\\"netSvcLvl\\\"]\\n df_base[\\\"itemCode\\\"] = df_base[\\\"itemCode\\\"].map('{:0>6}'.format)\\n df_base[\\\"buyerCode\\\"] = df_base[\\\"buyerCode\\\"] * 10\\n df_base[\\\"itemDesc\\\"] = df_base[\\\"itemDesc\\\"] + \\\" \\\" + df_base[\\\"itemSize\\\"]\\n \\n print(f\\\"'{xl_file}' Successfully processed\\\\n\\\") \\n elif fnmatch.fnmatch(xl_file.lower(), \\\"*short*.xlsx\\\") == True:\\n print(f\\\"Creating DataFrame for '{xl_file}'...\\\")\\n \\n df_shorts = workbook.parse(0, skiprows=1, header=None)\\n df_shorts.columns = [\\\"itemDesc\\\", \\n \\\"itemCode\\\", \\n \\\"yesterdayOOS\\\"]\\n df_shorts[\\\"itemCode\\\"] = df_shorts[\\\"itemCode\\\"].map('{:0>6}'.format)\\n df_shorts.drop(columns=[\\\"itemDesc\\\"], inplace=True)\\n \\n print(f\\\"'{xl_file}' Successfully processed\\\\n\\\") \\n elif fnmatch.fnmatch(xl_file.lower(), \\\"*reason*.xlsx\\\") == True:\\n print(f\\\"Creating DataFrame for '{xl_file}'...\\\")\\n \\n df_reason = workbook.parse(0, skiprows=2, header=None)\\n df_reason.columns = [\\\"dept\\\", \\n \\\"category\\\", \\n \\\"itemDesc\\\", \\n \\\"itemCode\\\", \\n \\\"outOfStock\\\", \\n \\\"manufacIssue\\\",\\n \\\"disc\\\",\\n \\\"other\\\",\\n \\\"newItemIssue\\\"]\\n df_reason[\\\"itemCode\\\"] = df_reason[\\\"itemCode\\\"].map('{:0>6}'.format)\\n df_reason[\\\"max\\\"] = df_reason[[df_reason.columns[4], \\n df_reason.columns[5], \\n df_reason.columns[6], \\n df_reason.columns[7], \\n df_reason.columns[8]]].max(axis=1)\\n df_reason.loc[df_reason[\\\"max\\\"] == df_reason[\\\"outOfStock\\\"], \\\"primaryReason\\\"] = \\\"Out Of Stock\\\"\\n df_reason.loc[df_reason[\\\"max\\\"] == df_reason[\\\"manufacIssue\\\"], \\\"primaryReason\\\"] = \\\"Manufacturer Issue\\\"\\n df_reason.loc[df_reason[\\\"max\\\"] == df_reason[\\\"disc\\\"], \\\"primaryReason\\\"] = \\\"Discontinued\\\"\\n df_reason.loc[df_reason[\\\"max\\\"] == df_reason[\\\"other\\\"], \\\"primaryReason\\\"] = \\\"Other\\\"\\n df_reason.loc[df_reason[\\\"max\\\"] == df_reason[\\\"newItemIssue\\\"], \\\"primaryReason\\\"] = \\\"New Item Issue\\\"\\n df_reason.sort_values(by=[\\\"max\\\"], ascending=False, inplace=True)\\n df_reason.drop(columns=[\\\"dept\\\", \\n \\\"category\\\", \\n \\\"itemDesc\\\", \\n \\\"outOfStock\\\", \\n \\\"manufacIssue\\\", \\n \\\"disc\\\", \\n \\\"other\\\", \\n \\\"newItemIssue\\\", \\n \\\"max\\\"], inplace=True)\\n \\n print(f\\\"'{xl_file}' Successfully processed\\\\n\\\") \\n elif fnmatch.fnmatch(xl_file.lower(), \\\"*export*.xlsx\\\") == True:\\n print(f\\\"Creating DataFrame for '{xl_file}'...\\\")\\n \\n to_drop = [\\\"14:HATFIELD NORTH\\\", \\\"1:BRATTLEBORO\\\"]\\n \\n df_cs = workbook.parse(0, skiprows=3, skipfooter=20, header=None)\\n df_cs = df_cs[~df_cs[7].isin(to_drop)]\\n df_cs = df_cs.filter([0, 14, 15, 17, 34])\\n df_cs.columns = [\\\"custCode\\\", \\n \\\"poDueDate\\\", \\n \\\"poApptDate\\\", \\n \\\"inStock\\\", \\n \\\"daysOOS\\\"]\\n df_cs[\\\"itemCode\\\"] = df_cs[\\\"custCode\\\"].astype(str).str[9:15]\\n df_cs.drop(columns=[\\\"custCode\\\"], inplace=True)\\n df_cs.drop_duplicates(inplace=True)\\n\\n print(f\\\"'{xl_file}' Successfully processed\\\\n\\\")\\n\\n for data_file in os.listdir(data_dir):\\n if fnmatch.fnmatch(data_file, \\\"*.xlsx\\\") == True:\\n print(f\\\"Deleting '{data_file}'...\\\\n\\\")\\n os.remove(data_dir + data_file)\\n\\n df_join_1 = df_base.merge(df_reason, how=\\\"left\\\", on=\\\"itemCode\\\")\\n df_join_2 = df_join_1.merge(df_shorts, how=\\\"left\\\", on=\\\"itemCode\\\")\\n df_join_3 = df_join_2.merge(df_cs, how=\\\"left\\\", on=\\\"itemCode\\\")\\n \\n print(\\\"Exporting to Excel...\\\\n\\\")\\n df_join_3.to_excel(f\\\".\\\\\\\\excel\\\\\\\\archive\\\\\\\\oos-data-{timestamp()}.xlsx\\\", index=False)\\n\\n sys.exit(0)\\n except:\\n try:\\n df_join_1 = df_base.merge(df_reason, how=\\\"left\\\", on=\\\"itemCode\\\")\\n df_join_2 = df_join_1.merge(df_shorts, how=\\\"left\\\", on=\\\"itemCode\\\")\\n\\n df_join_2[\\\"poDueDate\\\"] = \\\"NO CS DATA\\\"\\n df_join_2[\\\"poApptDate\\\"] = \\\"NO CS DATA\\\"\\n df_join_2[\\\"inStock\\\"] = \\\"NO CS DATA\\\"\\n df_join_2[\\\"daysOOS\\\"] = \\\"NO CS DATA\\\"\\n \\n print(\\\"Exporting to Excel...\\\\n\\\")\\n df_join_2.to_excel(f\\\".\\\\\\\\excel\\\\\\\\archive\\\\\\\\oos-data-{timestamp()}.xlsx\\\", index=False)\\n except:\\n if not os.path.exists(archive_dir):\\n os.makedirs(archive_dir)\\n if not os.path.exists(data_dir):\\n os.makedirs(data_dir)\\n\\n sys.exit(1)\",\n \"def openData(self):\\n\\n\\n path = QtWidgets.QFileDialog.getOpenFileName(self, 'Open File', os.getcwd(), 'CSV, XLSX(*.csv *.xlsx)')\\n\\n # If a file was specified, load it up. If not, tell the user to pick a valid file\\n if path[0] != '':\\n\\n if os.path.exists(path[0]) and os.path.getsize(path[0]):\\n\\n filepath, filename = os.path.split(path[0])\\n pandaData = procedures.load(filename, filepath)\\n\\n self.createTab(pandaData, name=filename)\\n\\n else:\\n self.notifyUser(\\\"Please pick a valid file.\\\")\",\n \"def _read_file(self):\\n # Convert str to pathlib.Path() object.\\n if isinstance(self.file_path, str):\\n self.file_path = Path(self.file_path)\\n\\n # Check if file_path exists:\\n if not self.file_path.exists():\\n raise FileNotFoundError(f'File not found: {self.file_path}')\\n\\n # Open and read the \\\"xls\\\" file\\n with open(self.file_path, encoding='windows-1252') as f:\\n self.html_string = f.read()\",\n \"def loadData(self):\\n\\n\\n path = QtWidgets.QFileDialog.getOpenFileName(self, 'Open File', os.getcwd(), 'CSV, XLSX(*.csv *.xlsx)')\\n\\n # If a file was specified, load it up. If not, tell the user to pick a valid file\\n if path[0] != '':\\n\\n if os.path.exists(path[0]) and os.path.getsize(path[0]):\\n\\n filepath, filename = os.path.split(path[0])\\n pandaData = procedures.load(filename, filepath)\\n\\n while self.tabWidget.count() != 0:\\n self.closeTab()\\n self.createTab(pandaData)\\n\\n else:\\n self.notifyUser(\\\"Please pick a valid file.\\\")\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.66888124","0.6109369","0.61021197","0.60966265","0.5916426","0.589535","0.58326924","0.5774381","0.56844836","0.5633092","0.5630392","0.56159174","0.56018525","0.55881256","0.55868655","0.55625945","0.55516446","0.55497164","0.5522616","0.55121005","0.5487045","0.5447336","0.5432209","0.54293597","0.5405304","0.5398603","0.5397802","0.53861046","0.53714776","0.53620636","0.5346978","0.534022","0.53312105","0.53260887","0.5323375","0.5291","0.52853864","0.5283146","0.528158","0.52541137","0.5252692","0.5251004","0.52504605","0.5239431","0.52340937","0.52152604","0.52080256","0.5202422","0.5191314","0.5190419","0.5188261","0.5179996","0.51780015","0.51684326","0.51539564","0.5151963","0.51471496","0.51354754","0.51346356","0.5133578","0.5131875","0.5126813","0.5113314","0.5111622","0.51084006","0.508921","0.50861204","0.5081203","0.5078006","0.5073533","0.507295","0.5071998","0.50714654","0.5070408","0.5060768","0.5055061","0.5054418","0.5053536","0.50528705","0.5045928","0.5038717","0.50373536","0.5035226","0.502737","0.5023525","0.5019792","0.50116634","0.500969","0.50072056","0.5000325","0.49941438","0.49826783","0.49773556","0.49681708","0.49605593","0.4954908","0.49523872","0.49451852","0.49410763","0.4941075"],"string":"[\n \"0.66888124\",\n \"0.6109369\",\n \"0.61021197\",\n \"0.60966265\",\n \"0.5916426\",\n \"0.589535\",\n \"0.58326924\",\n \"0.5774381\",\n \"0.56844836\",\n \"0.5633092\",\n \"0.5630392\",\n \"0.56159174\",\n \"0.56018525\",\n \"0.55881256\",\n \"0.55868655\",\n \"0.55625945\",\n \"0.55516446\",\n \"0.55497164\",\n \"0.5522616\",\n \"0.55121005\",\n \"0.5487045\",\n \"0.5447336\",\n \"0.5432209\",\n \"0.54293597\",\n \"0.5405304\",\n \"0.5398603\",\n \"0.5397802\",\n \"0.53861046\",\n \"0.53714776\",\n \"0.53620636\",\n \"0.5346978\",\n \"0.534022\",\n \"0.53312105\",\n \"0.53260887\",\n \"0.5323375\",\n \"0.5291\",\n \"0.52853864\",\n \"0.5283146\",\n \"0.528158\",\n \"0.52541137\",\n \"0.5252692\",\n \"0.5251004\",\n \"0.52504605\",\n \"0.5239431\",\n \"0.52340937\",\n \"0.52152604\",\n \"0.52080256\",\n \"0.5202422\",\n \"0.5191314\",\n \"0.5190419\",\n \"0.5188261\",\n \"0.5179996\",\n \"0.51780015\",\n \"0.51684326\",\n \"0.51539564\",\n \"0.5151963\",\n \"0.51471496\",\n \"0.51354754\",\n \"0.51346356\",\n \"0.5133578\",\n \"0.5131875\",\n \"0.5126813\",\n \"0.5113314\",\n \"0.5111622\",\n \"0.51084006\",\n \"0.508921\",\n \"0.50861204\",\n \"0.5081203\",\n \"0.5078006\",\n \"0.5073533\",\n \"0.507295\",\n \"0.5071998\",\n \"0.50714654\",\n \"0.5070408\",\n \"0.5060768\",\n \"0.5055061\",\n \"0.5054418\",\n \"0.5053536\",\n \"0.50528705\",\n \"0.5045928\",\n \"0.5038717\",\n \"0.50373536\",\n \"0.5035226\",\n \"0.502737\",\n \"0.5023525\",\n \"0.5019792\",\n \"0.50116634\",\n \"0.500969\",\n \"0.50072056\",\n \"0.5000325\",\n \"0.49941438\",\n \"0.49826783\",\n \"0.49773556\",\n \"0.49681708\",\n \"0.49605593\",\n \"0.4954908\",\n \"0.49523872\",\n \"0.49451852\",\n \"0.49410763\",\n \"0.4941075\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.67918974"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":24992,"cells":{"query":{"kind":"string","value":"Process the \"Module\" filed."},"document":{"kind":"string","value":"def process_module_field(self, data):\n\n result = list()\n\n case_info = data['values']\n # add Module filed\n for i, v in enumerate(case_info):\n if not v['Module']:\n v['Module'] = case_info[i - 1]['Module']\n else:\n module = tuple(self.parser.split(v['Module'].lower(), '\\\\.'))\n v['Module'] = tuple((re.sub('\\\\s+', '_', i) for i in module))\n\n # brush out the test case that need to generate the script\n for i, v in enumerate(case_info):\n if not v['Step actions']:\n continue\n if (v['Execution'].lower() in ('m',)) or (v['Auto status'].lower() in ('y',)):\n if not self.for_test_link:\n continue\n result.append(v)\n\n return result"},"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 process_module_list(self, modules):","def visit_Module(self, node):\n for item in node.body:\n self.visit(item)","def visit_Module(self, node):\n for item in node.body:\n self.visit(item)","def exec_module(self, module):\n pass","def on_module_event(self, event: str, *args, **kwargs):","def process_modules(self) -> typing.NoReturn:\n\t\tfor moduleName in self.moduleNameSet:\n\t\t\tdetected_encoding = detect_encoding(moduleName)\n\n\t\t\tprint(f\"Processing {moduleName} ({detected_encoding})\")\n\n\t\t\twith open(moduleName, 'r+', encoding=detected_encoding) as fileStream:\n\t\t\t\t# Store the content of the file\n\t\t\t\tfileContent: str = fileStream.read()\n\t\t\t\t# Sets the file's current position at the offset, the position of the read/write pointer within the file\n\t\t\t\tfileStream.seek(0, 0)\n\t\t\t\t# Truncates the file's size\n\t\t\t\tfileStream.truncate()\n\n\t\t\t\t# Process regex patterns\n\t\t\t\tfor regexDict in regexDictList:\n\t\t\t\t\tfileContent = self.process_function(regexDict, fileContent)\n\n\t\t\t\t# Rewrite the processed content of the file\n\t\t\t\tfileStream.write(fileContent)","def modules():","def handleModuleMessage(self, data):\n # print (\"got a message in silverline module.\")\n (messageType, content) = self.ofxAgent.unpackModuleMessage(data)\n # print \"\\tmessage type: %s\"%messageType\n if messageType == ENABLEDECLASSIFIER:\n self.enableDeclassifier()\n elif messageType == ADDFLOWPERMISSION:\n self.addFlowPermission(content)","def processModule(newDocNode, modulename):\n filename = os.path.join(SRC, \"%s_swig.xml\" % modulename)\n print filename\n\n doc = libxml2.parseFile(filename)\n topNode = doc.getRootElement()\n\n # make a module element\n name = getAttr(topNode, \"module\")\n ##assert name == modulename # sanity check \n\n moduleNode = libxml2.newNode(\"module\")\n moduleNode.setProp(\"name\", name) \n newDocNode.addChild(moduleNode)\n\n node = topNode.children\n while node is not None:\n if node.name == \"include\":\n processInclude(moduleNode, node)\n node = node.next\n\n doc.freeDoc()","def execute_module(self):\n raise NotImplementedError","def do_modules(self, args):\n logger.debug(\"do_modules() was called\")\n \n parser = CrispyArgumentParser(description=self.do_modules.__doc__, prog=\"modules\")\n \n try:\n pargs = parser.parse_args(shlex.split(args))\n if pargs:\n print \"\\nAvailable modules:\\n===================\"\n for mod in self.srv.get_module_list():\n print \"{:<12} -- {}\".format(mod.__module__, mod.__doc__)\n fprint.success(\"Done.\")\n except MyParserException as e:\n print e","def module_info():\n pass","def setup_module(module):\n print(\"Start rishabhSetupModule of Program\")","def process_module(self, node):\n with node.stream() as stream:\n self.append_stream(self.linter.current_name, stream, node.file_encoding)","def MODULES(self):\n pass","def do_modules(self, module: Optional[str] = None):\n if module is None or module == \"\":\n self._display_available_modules()\n else:\n self._display_module(module)","def do_list_modules(self, arg):\n for module in self.reader.module_list.modules:\n if arg:\n name = GetModuleName(self.reader, module).lower()\n if name.find(arg.lower()) >= 0:\n PrintModuleDetails(self.reader, module)\n else:\n PrintModuleDetails(self.reader, module)\n print()","def visit_Module(self, node):\n self.generic_visit(node)\n return self.functions","def process_module(self, node):\n code = node.file_stream.read()\n\n try:\n tree = compile(code, node.file, \"exec\", ast.PyCF_ONLY_AST)\n except SyntaxError:\n # Pylint would have already failed\n return\n\n McCabeChecker.max_complexity = self.max_complexity\n results = McCabeChecker(tree, node.file).run()\n for lineno, _, text, _ in results:\n text = text[5:]\n self.add_message('C0901', line=lineno, args=text)","async def module_command_module(self, ctx, parsed):\n mcs = ModuleCmdStatus\n results = []\n subcmd = parsed.subcmd\n if subcmd.endswith(\"load\"): # load, reload\n mtype = parsed.args[\"mtype\"]\n if parsed.args[\"mtype\"] == \"protocol\" and subcmd == \"reload\":\n await ctx.reply_command_result(parsed, \"Reloading protocol modules is not yet implemented.\")\n return\n for mod_id in parsed.args[\"module\"]:\n try:\n module = await getattr(self, f\"{subcmd}_{mtype}\")(mod_id)\n except NoSuchModule:\n status = mcs.NO_SUCH_MOD\n except (ModuleLoadError, ModuleRegisterError) as ex:\n status = getattr(mcs, f\"{subcmd.upper()}_FAIL\")\n self.logger.exception(ex)\n except ModuleAlreadyLoaded:\n status = mcs.ALREADY_LOADED\n except ModuleNotLoaded:\n status = mcs.NOT_YET_LOADED\n else:\n status = getattr(mcs, f\"{subcmd.upper()}_OK\")\n results.append(ModuleCmdResult(mod_id, status, mtype))\n elif subcmd == \"list\":\n status = mcs.QUERY\n for category in parsed.args[\"category\"]:\n if parsed.args[\"loaded\"]:\n pool = (mod.identifier for mod in getattr(self, f\"get_loaded_{category}s\")())\n else:\n pool = getattr(self, f\"get_available_{category}s\")()\n results.extend(ModuleCmdResult(mod, status, category) for mod in pool)\n elif subcmd == \"info\":\n status = mcs.QUERY\n mtype = parsed.args[\"mtype\"]\n for mod_id in parsed.args[\"module\"]:\n info = {}\n try:\n module = getattr(self, f\"_{mtype}s\")[mod_id]\n except KeyError:\n if getattr(self, f\"{mtype}_available\")(mod_id):\n status = mcs.NOT_YET_LOADED\n else:\n status = mcs.NO_SUCH_MOD\n else:\n for attr in (\"name\", \"description\", \"author\", \"version\", \"license\"):\n info[attr] = getattr(module, attr)\n results.append(ModuleCmdResult(mod_id, status, mtype, info))\n await ctx.core_command_module(parsed, results)","def exec_module(cls, *args, **kwargs): # real signature unknown\n pass","def exec_module(cls, *args, **kwargs): # real signature unknown\n pass","def update_modules(self) -> None:\n\n matches = apache_util.parse_modules(self.configurator.options.get_modules_cmd)\n for mod in matches:\n self.add_mod(mod.strip())","def module_file(module):\n ...","def module(self, module):\n if isinstance(module, six.string_types):\n module = importlib.import_module(module)\n for func in get_module_functions(module):\n self.register_command(func)","def on_modules_command(sender, command, label, args):\n plugin_header(sender, \"Modules\")\n msg(sender, \", \".join([((\"&a\" if mod in shared[\"modules\"] else \"&c\") + mod) for mod in shared[\"load_modules\"]]))","def handle_request_command(self, msg):\n\n\t\t# only one command?\n\t\tcommand = None\n\t\tif msg.arguments:\n\t\t\tcommand = msg.arguments[0]\n\n\t\tmodule_name = moduleManager.module_providing(self.__command_list, command)\n\n\t\ttry:\n\t\t\t# check if the module exists in the module manager\n\t\t\tmoduleManager[module_name]\n\t\texcept KeyError:\n\t\t\t# the module has been removed from moduleManager (probably through a reload)\n\t\t\tCORE.warn('Module %r (command=%r, id=%r) does not exists anymore' % (module_name, command, msg.id))\n\t\t\tmoduleManager.load()\n\t\t\tself._reload_acls_and_permitted_commands()\n\t\t\tmodule_name = None\n\n\t\tif not module_name:\n\t\t\traise Forbidden()\n\n\t\tif msg.arguments:\n\t\t\tif msg.mimetype == MIMETYPE_JSON:\n\t\t\t\tis_allowed = moduleManager.is_command_allowed(self.acls, msg.arguments[0], options=msg.options, flavor=msg.flavor)\n\t\t\telse:\n\t\t\t\tis_allowed = moduleManager.is_command_allowed(self.acls, msg.arguments[0])\n\t\t\tif not is_allowed:\n\t\t\t\traise Forbidden()\n\t\t\tif module_name not in self.__processes:\n\t\t\t\tCORE.info('Starting new module process and passing new request to module %s: %s' % (module_name, str(msg._id)))\n\t\t\t\ttry:\n\t\t\t\t\tmod_proc = ModuleProcess(module_name, debug=MODULE_DEBUG_LEVEL, locale=self.i18n.locale)\n\t\t\t\texcept EnvironmentError as exc:\n\t\t\t\t\tmessage = self._('Could not open the module. %s Please try again later.') % {\n\t\t\t\t\t\terrno.ENOMEM: self._('There is not enough memory available on the server.'),\n\t\t\t\t\t\terrno.EMFILE: self._('There are too many opened files on the server.'),\n\t\t\t\t\t\terrno.ENFILE: self._('There are too many opened files on the server.'),\n\t\t\t\t\t\terrno.ENOSPC: self._('There is not enough free space on the server.')\n\t\t\t\t\t}.get(exc.errno, self._('An unknown operating system error occurred (%s).' % (exc,)))\n\t\t\t\t\traise ServiceUnavailable(message)\n\t\t\t\tmod_proc.signal_connect('result', self.result)\n\n\t\t\t\tcb = notifier.Callback(self._mod_error, module_name)\n\t\t\t\tmod_proc.signal_connect('error', cb)\n\n\t\t\t\tcb = notifier.Callback(self._socket_died, module_name)\n\t\t\t\tmod_proc.signal_connect('closed', cb)\n\n\t\t\t\tcb = notifier.Callback(self._mod_died, module_name)\n\t\t\t\tmod_proc.signal_connect('finished', cb)\n\n\t\t\t\tself.__processes[module_name] = mod_proc\n\n\t\t\t\tcb = notifier.Callback(self._mod_connect, mod_proc, msg)\n\t\t\t\tnotifier.timer_add(50, cb)\n\t\t\telse:\n\t\t\t\tproc = self.__processes[module_name]\n\t\t\t\tif proc.running:\n\t\t\t\t\tCORE.info('Passing new request to running module %s' % module_name)\n\t\t\t\t\tproc.request(msg)\n\t\t\t\t\tself.reset_inactivity_timer(proc)\n\t\t\t\telse:\n\t\t\t\t\tCORE.info('Queuing incoming request for module %s that is not yet ready to receive' % module_name)\n\t\t\t\t\tproc._queued_requests.append(msg)","def assemble_module(module):\n\n print(f\"Assembling module: {module.name}\")","def _process_modulename(self,modulename):\n\t\tif modulename:\n\t\t\tif modulename in modules.keys():\n\t\t\t\traise NameError(\"Module name has already been used in this instance of Python.\")\n\t\t\tself._modulename = modulename\n\t\telse:\n\t\t\twhile self._modulename in modules.keys():\n\t\t\t\tself._modulename = count_up(self._modulename)\n\t\t\n\t\tmodulefile = self._tmpfile(self._modulename + \".so\")\n\t\tif path.isfile(modulefile):\n\t\t\traise OSError(\"Module file already exists.\")","def parse_modules(self) -> None:\n mods: Dict[str, str] = {}\n matches = self.find_dir(\"LoadModule\")\n iterator = iter(matches)\n # Make sure prev_size != cur_size for do: while: iteration\n prev_size = -1\n\n while len(mods) != prev_size:\n prev_size = len(mods)\n\n for match_name, match_filename in zip(\n iterator, iterator):\n mod_name = self.get_arg(match_name)\n mod_filename = self.get_arg(match_filename)\n if mod_name and mod_filename:\n mods[mod_name] = mod_filename\n mods[os.path.basename(mod_filename)[:-2] + \"c\"] = mod_filename\n else:\n logger.debug(\"Could not read LoadModule directive from Augeas path: %s\",\n match_name[6:])\n self.modules.update(mods)","def test_module(self):\n pass","def setModule(name, module):","def handleModuleMessage(self, data, datapathSendFcn):\n print (\"handler not implemented in silverline.\")","def _setModule(self, module):\n self._module = module","def visit_Module(self, node):\n self.generic_visit(node)\n return self.classes","def __extract_module(log):\n module = \"UNKNOWN\"\n if \"module\" in log:\n module = log[\"module\"]\n elif \"executorName\" in log:\n module = log[\"executorName\"]\n elif \"http_uri\" in log:\n module = Transformer.__extract_module_from_url(log[\"http_uri\"])\n if module == \"UNKNOWN\" and \"header_referer\" in log:\n module = Transformer.__extract_module_from_url(log[\"header_referer\"])\n return module","def __setup_modules(self, config, db, rcontext):\n DEPTH_ROOT = 0\n DEPTH_TYPE = 1\n DEPTH_SUBTYPE = 2\n\n for root, sub_folders, files in os.walk(\"modules\"):\n nicepath = os.path.relpath(root, \"modules\")\n fullpath = root\n\n if nicepath == '.':\n depth = DEPTH_ROOT\n else:\n depth = nicepath.count(os.path.sep) + 1\n\n if depth > DEPTH_SUBTYPE:\n warnings.warn(\"sub-subdirectory in module (%s) \\\n ignored.\" % nicepath)\n\n modulenamebase = nicepath.replace(os.path.sep, '.')\n mimetype = nicepath.replace(os.path.sep, '/')\n\n if depth != DEPTH_ROOT:\n # Each folder should except root have an __init__.py,\n # otherwise the directory name be assigned as a module.\n if not \"__init__.py\" in files:\n warnings.warn(\"__init__.py not found in \\\n module folder '%s'.\" % nicepath)\n continue\n\n modulepath = fullpath + os.path.sep + \"__init__.py\"\n module = Module(modulepath, modulenamebase, mimetype)\n self.modules.append(module)\n\n # Now load each handler .py file\n for file in files:\n modulenameend, extension = os.path.splitext(file)\n if extension.lower() == \".py\":\n is_init = file == \"__init__.py\"\n modulepath = fullpath + os.path.sep + file\n modulename = None\n if is_init:\n modulename = modulenamebase\n elif depth == DEPTH_ROOT:\n modulename = modulenameend\n else:\n modulename = modulenamebase + '.' + modulenameend\n\n module = Module(modulepath, modulename, mimetype,\n is_global=(depth == DEPTH_ROOT),\n as_mime_handler=not is_init)\n if module.is_mime_handler and not rcontext.is_recursive:\n db.setup_module_table(module.md5_tablename,\n module.columndefinition)\n\n self.modules.append(module)","def module(self, module):\n self._module = module","def module(self, module):\n self._module = module","def module(self, module):\n self._module = module","def hookInfo() :\n return ModuleInfo(\n name=\"My Module\",\n version=\"1.2\",\n author=\"Some Author\",\n description=\"A module that does something.\"\n )","def setup_module():\n common_setup_module()","def form_module_handlers(page, request, context, *args, **kwargs):\n form_modules = {}\n streamfields = util.get_streamfields(page)\n\n for fieldname, blocks in streamfields.items():\n for index, child in enumerate(blocks):\n if hasattr(child.block, 'get_result'):\n if fieldname not in form_modules:\n form_modules[fieldname] = {}\n\n if not request.method == 'POST':\n is_submitted = child.block.is_submitted(\n request,\n fieldname,\n index\n )\n module_context = child.block.get_result(\n page,\n request,\n child.value,\n is_submitted\n )\n form_modules[fieldname].update({index: module_context})\n if form_modules:\n context['form_modules'] = form_modules","def _ui_module(self, name, module):\n raise NotImplementedError()","def exec_module(self, module):\n\n if not self.filename.endswith(config.FILE_EXT) and not self.filename.endswith(\n \"__init__.py\"\n ):\n print(\"Fatal error: ExtensionLoader is asked to load a normal file.\")\n print(\"filename:\", self.filename)\n print(\"Expected extension:\", config.FILE_EXT)\n raise SystemExit\n\n name = module.__name__\n if module.__name__ == config.MAIN_MODULE_NAME:\n module.__name__ = \"__main__\"\n config.MAIN_MODULE_NAME = None\n\n with open(self.filename) as f:\n source = f.read()\n\n transforms.identify_requested_transformers(source)\n\n if config.TRANSFORMERS:\n original = source\n source = transforms.add_all_imports(source)\n source = transforms.apply_source_transformations(source)\n\n if config.DIFF and original != source:\n self.write_html_diff(name, original, source)\n\n if config.CONVERT and self.filename.endswith(config.FILE_EXT):\n print(\"############### Original source: ############\\n\")\n print(original)\n print(\"\\n############### Converted source: ############\\n\")\n print(source)\n print(\"=\" * 50, \"\\n\")\n\n source = transforms.apply_ast_transformations(source)\n exec(source, vars(module))","def perform_module_operation(self):\n\n nfs_export_name = self.module.params['nfs_export_name']\n nfs_export_id = self.module.params['nfs_export_id']\n filesystem = self.module.params['filesystem']\n snapshot = self.module.params['snapshot']\n nas_server = self.module.params['nas_server']\n path = self.module.params['path']\n description = self.module.params['description']\n default_access = self.module.params['default_access']\n no_access_hosts = self.module.params['no_access_hosts']\n read_only_hosts = self.module.params['read_only_hosts']\n read_only_root_hosts = self.module.params['read_only_root_hosts']\n read_write_hosts = self.module.params['read_write_hosts']\n read_write_root_hosts = self.module.params['read_write_root_hosts']\n min_security = self.module.params['min_security']\n anonymous_uid = self.module.params['anonymous_uid']\n anonymous_gid = self.module.params['anonymous_gid']\n is_no_suid = self.module.params['is_no_suid']\n host_state = self.module.params['host_state']\n state = self.module.params['state']\n\n result = dict(\n changed=False,\n nfs_export_details=''\n )\n\n export_parent = filesystem if filesystem else snapshot\n changed = False\n nfs_modify_dict = dict()\n\n # Validate the input parameters\n self.validate_input(export_parent)\n\n # Get the ID of the filesystem/snapshot if name is provided\n export_parent_id = None\n if export_parent is not None:\n export_parent_id = self.get_fs_id_from_filesystem(\n export_parent, nas_server)\n\n # Get the details of NFS export\n nfs_export_details = self.get_nfs_export(\n nfs_export_name, nfs_export_id, export_parent, nas_server, path)\n\n # Check if modification to the NFS export is required\n if state == 'present' and nfs_export_details:\n nfs_modify_dict = self.check_nfs_export_modified(\n nfs_export_details, description, default_access, min_security,\n anonymous_uid, anonymous_gid, is_no_suid)\n\n # Create NFS export\n if state == 'present' and not nfs_export_details:\n if nfs_export_id:\n error_msg = \"NFS export with nfs_export_id {0} not found.\".\\\n format(nfs_export_id)\n self.module.fail_json(msg=error_msg)\n\n if nfs_export_name and not export_parent:\n self.module.fail_json(msg=\"filesystem/snapshot is required to\"\n \" create NFS export.\")\n\n changed = self.create_nfs_export(export_parent, nfs_export_name,\n export_parent_id, path)\n\n # Modify NFS export\n if state == 'present' and nfs_export_details and nfs_modify_dict:\n changed = self.modify_nfs_export(nfs_export_details,\n nfs_modify_dict)\n\n # Delete NFS export\n elif state == 'absent' and nfs_export_details:\n changed = self.delete_nfs_export(nfs_export_details)\n\n # Finally update the module result!\n result['changed'] = changed\n if state == 'present':\n result['nfs_export_details'] = self.get_nfs_export(\n nfs_export_name, nfs_export_id, export_parent, nas_server,\n path)\n\n self.module.exit_json(**result)","def module_runner(module):\n task_queue.put(1)\n result = sys.modules[module].run()\n task_queue.get()\n store_module_result(result) # Store the result in our repo","def post(self):\n return self.rpc.call(MsfRpcMethod.ModulePost)['modules']","async def execute_module_command(request):\n hw = hw_from_req(request)\n requested_serial = request.match_info['serial']\n data = await request.json()\n command_type = data.get('command_type')\n args = data.get('args')\n\n hw_mods = hw.attached_modules\n\n if len(hw_mods) == 0:\n return web.json_response({\"message\": \"No connected modules\"},\n status=404)\n\n matching_mod = next((mod for mod in hw_mods if\n mod.device_info.get('serial') == requested_serial),\n None)\n\n if not matching_mod:\n return web.json_response({\"message\": \"Specified module not found\"},\n status=404)\n\n if hasattr(matching_mod, command_type):\n clean_args = args or []\n method = getattr(matching_mod, command_type)\n if asyncio.iscoroutinefunction(method):\n val = await method(*clean_args)\n else:\n val = method(*clean_args)\n\n return web.json_response(\n {'message': 'Success', 'returnValue': val},\n status=200)\n else:\n return web.json_response(\n {'message': f'Module does not have command: {command_type}'},\n status=400)","def RunModule(self):\n module = self.statModules.GetActive()\n \n self.ShutdownStatModule()\n \n if module is not None:\n wx.LogMessage(\"Running stat module...\")\n self.statPage = module.Load(self.nb, self)\n self.SetView(self.statModules.caption, self.statPage)","def process_module(module):\n options_dict = {}\n flags_dict = {}\n \n for klass in [getattr(module, cname) for cname in dir(module) if hasattr(getattr(module, cname), 'option_names')]:\n if klass.option_names[0] is not None:\n flags_dict[klass.option_names[0]] = klass()\n options_dict[klass.option_names[1]] = klass()\n \n module.options_dict = options_dict\n module.flags_dict = flags_dict","def _createModuleObj(self):\n raise NotImplementedError(\"Implement in derived class.\")","def set_values(self,module):\n if type(module) == dict:\n self.set_value(\"name\",module[\"name\"])\n self.set_value(\"hrname\",module[\"hrname\"])\n self.set_value(\"version_major\",module[\"version_major\"])\n self.set_value(\"version_minor\",module[\"version_minor\"])\n self.set_value(\"revision\",module[\"revision\"])\n if module.has_key(\"signature\"):\n self.set_value(\"signature\",module[\"signature\"])\n elif module.__class__.__name__ == \"Module\":\n pass #TODO IMPLEMENT / DISCUSS AFTER IMPLEMENTING MODULE-SUBSYSTEM","def moduleInfo(*args, definition: bool=True, listModules: bool=True, moduleName: AnyStr=\"\",\n path: bool=True, version: bool=True, **kwargs)->List[AnyStr]:\n pass","def add_module(self, *args, **kwargs):\n# if 'path' in kwargs:\n# path = kwargs['path']\n# else:\n# path = os.getcwd()\n#\n# if len(args) > 0:\n# module = args[0]\n# elif 'module' in kwargs:\n# module = kwargs['module']\n#\n# if 'path' not in kwargs:\n# path = os.getcwd()\n# kwargs['path'] = path\n\n if 'module' not in kwargs:\n if len(args) > 0:\n module = args[0]\n kwargs['module'] = module\n\n# if 'module' in kwargs:\n if len(kwargs) > 0:\n self._data.add_detector(self._name, **kwargs)","def set_module(self, module):\n setattr(self, \"module\", module)","def _handle_load_module(self, name: str, module_type: Type[Module]) -> ModuleType:\n if module_type not in [FeatureModule, ProtocolModule]:\n raise TypeError(f\"Invalid type '{module_type}'\")\n type_str = \"feature\" if module_type is FeatureModule else \"protocol\"\n try:\n module = module_type(f\"ZeroBot.{type_str}.{name}\")\n except ModuleNotFoundError as ex:\n raise NoSuchModule(f\"Could not find {type_str} module '{name}': {ex}\", mod_id=name, exc=ex) from None\n except Exception as ex:\n raise ModuleLoadError(f\"Failed to load {type_str} module '{name}'\", mod_id=name) from ex\n self.logger.debug(f\"Imported {type_str} module {module!r}\")\n return module","def _try_set_module(self, module: str):\n loaded_module = next((x for x in self.modules if x.__name__ == module), None)\n if loaded_module is not None:\n self.current_module = module\n self._real_module = loaded_module\n print(\n asciistuff.Cowsay(\n \"Master of puppets is pulling the strings: using \"\n + self.current_module\n )\n )\n else:\n print(\"No module named {} available\".format(module))","def _add_module_to_map(self, model_key, module_dict):\n\n # Get the module name from the dict.\n if 'module' in module_dict:\n module_name = module_dict['module']\n elif 'omftype' in module_dict:\n module_name = module_dict['argument']\n else:\n # Bad dict.\n raise ValueError('Malformed module_dict: {}'.format(module_dict))\n\n # Ensure we aren't over-writing existing module.\n if module_name in self.model_map['module']:\n s = 'Module {} is already present!'.format(module_name)\n raise ItemExistsError(s)\n\n # Map it by name.\n self.model_map['module'][module_name] = [model_key, module_dict]","def make_modules(self, config):\n pass","def visit(self, file_object):\n\n module = ast.parse(file_object.read())\n # TODO remove prefixes such as C:\\Users\\...\n module_name = file_object.name.rstrip(\".py\").replace(\"/\", \".\")\n\n exec(\"import %s\"%module_name)\n self._module = eval(module_name)\n\n self.found = {\"vars\":[], \"classes\":[], \"funcs\":[]}\n self.found_classes = set()\n\n self._explorer(self, [module_name]).visit(module)","def mod_load(self):\n raise NotImplementedError(\"Mod load isn't overriden\")","def do_workload(self):\n module_manager = self._core.get_module_manager()\n module = module_manager.get_module_by_name(self._values[\"name\"])\n module_manager.update_module(module)","def process(self, doc):\n if not type(doc) is xmldoc.XMLDoc:\n raise ValueError(\"doc must be a XMLDoc\")\n\n pyIdlak_txp.PyIdlakModule_process(self._mod, doc.idlak_doc)","def load_module(self, module_name): # pragma: no cover\r\n try:\r\n module = import_module('SoftLayer.CLI.modules.%s' % module_name)\r\n for _, obj in inspect.getmembers(module):\r\n if inspect.isclass(obj) and issubclass(obj, CLIRunnable):\r\n self.add_plugin(obj)\r\n return module\r\n except ImportError:\r\n raise InvalidModule(module_name)","def do_use(self, module: str):\n if module != \"\":\n self._try_set_module(module)\n else:\n self.current_module = None\n self._real_module = None","def test_03_module_logger(self):\n module_logger = get_module_logger(self.__module__)\n module_logger.info('Info in Module {}'.format(self.__module__))","def _createModuleObj(self):\n ModuleInitialCondition.__init__(self)","def __init__(self):\n self.modules = {}","def __update_module(item):\n\n conn = sqlite3.connect(DTF_DB)\n cur = conn.cursor()\n\n # Remove the line first.\n sql = ('DELETE FROM modules '\n \"WHERE name='%s'\" % item.name)\n\n cur.execute(sql)\n\n entry = [(item.name, item.about, item.version,\n item.author, item.install_name)]\n\n # Update a Module Entry\n sql = ('INSERT INTO modules (name, about, version, '\n 'author, install_name)'\n 'VALUES (?, ?, ?, ?, ?)')\n\n cur.executemany(sql, entry)\n conn.commit()\n\n return cur.rowcount","def execute_module(self, module, *args, **opts):\n module_file = module.__file__\n if module_file.endswith('.pyc'):\n module_file = module_file[:-1]\n cmd = [self._path]\n if 'python_options' in opts:\n cmd.extend(opts['python_options'])\n del opts['python_options']\n cmd.append(module_file)\n cmd.extend(args)\n return get_cmd_output(*cmd, **opts)","def setup_module(self, conf: DictConfig) -> BaseMLModule:\n pass","def present_module_info():\n writer()\n print_heading(\"Module Info\")\n writer(f\"GWT Version: {GWT_VERSION}\")\n writer(f\"Content-Type: {CONTENT_TYPE}\")\n writer(f\"X-GWT-Module-Base: {BASE_URL}\")\n writer(f\"X-GWT-Permutation: {GWT_PERMUTATION}\")\n if RPC_MODE:\n writer(f\"RPC Version: {RPC_VERSION}\")\n writer(f\"RPC Flags: {RPC_FLAGS}\")\n writer()","def run_module(self):\n try:\n if self.in_distributed_mode:\n self.output_dict['insurance_usd'] = 0\n self.output_dict['construction_permitting_usd'] = 0\n self.output_dict['project_management_usd'] = 0\n self.output_dict['bonding_usd'] = 0\n self.output_dict['markup_contingency_usd'] = 0\n self.output_dict['engineering_usd'] = 0\n self.output_dict['site_facility_usd'] = 0\n self.output_dict['total_management_cost'] = self.input_dict['override_total_management_cost']\n\n else:\n self.output_dict['insurance_usd'] = self.insurance()\n self.output_dict['construction_permitting_usd'] = self.construction_permitting()\n self.output_dict['project_management_usd'] = self.project_management()\n self.output_dict['bonding_usd'] = self.bonding()\n self.output_dict['markup_contingency_usd'] = self.markup_contingency()\n self.output_dict['engineering_usd'] = self.engineering_foundations_collection_sys()\n self.output_dict['site_facility_usd'] = self.site_facility()\n self.output_dict['total_management_cost'] = self.total_management_cost()\n self.output_dict['management_cost_csv'] = self.outputs_for_detailed_tab()\n self.output_dict['mangement_module_type_operation'] = self.outputs_for_module_type_operation()\n return 0, 0 # module ran successfully\n except Exception as error:\n traceback.print_exc()\n print(f\"Fail {self.project_name} ManagementCost\")\n return 1, error # module did not run successfully","def on_module_choice(self, event):\n\n self.log.trace(\"Handle module selection by user.\")\n result = {'successful': False}\n\n try:\n # determine module selected\n module_name = event.GetString()\n\n self.feature_choices = []\n for selection in DEFAULT_SEL:\n self.feature_choices.append(selection)\n if module_name.lower() == CUSTOM_SEL.lower():\n # set custom flag\n self.custom_module = True\n # show custom input\n self.input_custom_module.Show()\n else:\n # clear custom flag\n self.custom_module = False\n # make sure custom field is hidden\n self.input_custom_module.Hide()\n if module_name.lower() != BLANK_SEL.lower():\n # return all features for module\n self.log.trace(\"Rebuilding feature list for %s module ...\" % module_name)\n features = self.database.return_features_for_module(module_name)['features']\n\n # build feature list\n for feature in features:\n self.feature_choices.append(feature['name'])\n\n # set feature choices to selection\n self.input_feature.SetItems(self.feature_choices)\n self._update_feature_input_according_to_custom_module_flag()\n self.log.trace(\"Feature list for %s module rebuilt.\" % module_name)\n\n # reset user story selections\n self.log.trace(\"Reseting user story list ...\")\n self.story_choices = []\n for selection in DEFAULT_SEL:\n self.story_choices.append(selection)\n self.input_story.SetItems(self.story_choices)\n self._update_story_input_according_to_custom_feature_flag()\n self.log.trace(\"User story list reset.\")\n\n # reset test selections\n self.log.trace(\"Reseting test list ...\")\n self.test_choices = []\n for selection in DEFAULT_SEL:\n self.test_choices.append(selection)\n self.input_test.SetItems(self.test_choices)\n self._update_test_input_according_to_custom_story_flag()\n self.log.trace(\"Test list reset.\")\n\n # reset testcase selections\n self.log.trace(\"Reseting test case list ...\")\n self.testcase_choices = []\n for selection in DEFAULT_SEL:\n self.testcase_choices.append(selection)\n self.input_testcase.SetItems(self.testcase_choices)\n self._update_testcase_input_according_to_custom_test_flag()\n self.log.trace(\"Test case list reset.\")\n\n result['successful'] = True\n except BaseException, e:\n self.handle_exception(e, \"handle module selection by user\")\n\n # return\n return result","def main():\n obj = UnityFilesystem()\n obj.perform_module_operation()","def __do_single_module_install(item):\n\n name = item.name\n local_name = item.local_name\n install_name = item.install_name\n\n # First copy the new file.\n if copy_file(local_name, install_name, DTF_MODULES_DIR) != 0:\n log.e(TAG, \"Error copying module '%s'\" % (local_name))\n return -1\n\n # Update database\n if __update_module(item) == 0:\n log.e(TAG, \"Failed to update module '%s' details in database.\"\n % (name))\n return -2\n\n log.i(TAG, \"Module '%s' installed successfully!\" % name)\n return 0","def _reset_module(m):\n raise NotImplementedError","def applyModuleChanges(self, moduleInst):\n\n pass","def loadModule(self, module = \"\", modType=\"python\"):\n\t\tif modType == \"python\":\t\t\t\n\t\t\tmod = None\t\t\t#try:\n\t\t\tsys.path.insert(0, os.path.dirname(module))\n\t\t\tfile = os.path.basename(module)\n\t\t\tfile = file[:file.rfind('.')]\n\t\t\t#print \"Try: \", file, \"over\", sys.path\n\t\t\ttry:\n\t\t\t\tmod = __import__(file)\n\t\t\texcept:\n\t\t\t\tprint \"Invalid CSL API Module '%s' ignored.\" % (file)\n\t\t\t\tsys.path.pop(0)\n\t\t\t\treturn None\n\t\t\tsys.path.pop(0)\n\t\t\t#print \"Loaded Module Info:\", dir(mod)\n\t\t\tif \"CSLAPI_NAME\" in dir(mod):\t\t\t\t\n\t\t\t\tmod.CSLValue = CSLValue\n\t\t\t\tmod.debug = self.debug\n\t\t\t\tvtbl = mod.getFuncTable()\n\t\t\t\t#print \"CSL Module loader:\", module\n\t\t\t\tvtbl_names = vtbl.keys()\n\t\t\t\tfor i in vtbl_names:\n\t\t\t\t\t#print \"\\tAdded Function '%s' from module: %s (%s)\" % (i, mod.__file__, vtbl[i].__class__)\n\t\t\t\t\tself.cslAPIS[i] = vtbl[i]\n\t\t\t\tself.cslAPIMods.append(mod)","def compileModule(self, code):\n r = ast.Module(None, self.compileSuite(code))\n #print r\n return r","def start_modules():\n global logf\n # BUG.\n # this log-string will never be in the log file, because loglevel is low than DEBUG ;(\n _log(logf,log.DEBUG,\"В функции %s\" % str(inspect.getframeinfo(inspect.currentframe())[1]));\n # \n dates=date.get_cur_date(logf)\n runmode=None\n module=None\n auto=1\n wait=1\n upload=1\n do_archive=1\n src_shops=None\n dst_shops=None\n try:\n options,args=getopt.getopt(sys.argv[1:],'a:t:f:m:d:l:u:s:g:p:wn',['action=','to=','from=','module=','date=','loglevel=','shop=','get=','put=','wait','noauto'])\n if (len(options)==0):\n display_usage()\n return 0\n except getopt.GetoptError:\n _log(logf,log.ERROR,\"Неизвестная опция или опция без параметра\");\n _log(logf,log.DEBUG,\"Выход из функции %s\" % str(inspect.getframeinfo(inspect.currentframe())[1]));\n display_usage()\n return -1;\n except:\n _log(logf,log.ERROR,\"Ошибка разбора командной строки\");\n _log(logf,log.ERROR,\"Сообщение системы: [%s.%s]\" % str(sys.exc_info()[0],str(sys.exc_info()[1])));\n _log(logf,log.DEBUG,\"Выход из функции %s\" % str(inspect.getframeinfo(inspect.currentframe())[1]));\n display_usage()\n return -1;\n for option,value in options:\n value=string.lower(value)\n if (option in ('-a','--action')):\n runmodes=[]\n for mode in cfg.runmodes:\n runmodes.append(cfg.runmodes[mode])\n if (value not in runmodes):\n _log(logf,log.ERROR,\"Неизвестный режим запуска [%s]\" % str(value));\n _log(logf,log.ERROR,\"Доступны только \"+str(runmodes));\n _log(logf,log.DEBUG,\"Выход из функции %s\" % str(inspect.getframeinfo(inspect.currentframe())[1])); \n return -1\n else:\n for mode_ in cfg.runmodes.items():\n if (value==mode_[1]):\n runmode=mode_[0]\n break\n\n elif (option in ('-t','--to') or (option in ('-s','--shop'))):\n wo_shops=''\n if (string.count(value,'-')>0):\n value_=string.split(value,'-')\n value=value_[0]\n wo_shops=string.split(value_[1],',')\n if (value=='*'):\n dst_shops=[]\n for counter in cfg.shops:\n dst_shops.append(counter)\n else:\n dst_shops=string.split(value,',')\n for shop_ in dst_shops:\n try:\n shop=cfg.shops[shop_]\n except:\n _log(logf,log.ERROR,\"Неизвестный магазин (назначения) [\"+str(shop_)+\"]\");\n _log(logf,log.ERROR,\"Сообщение системы: \"+str(\"[\"+str(sys.exc_info()[0])+\".\"+str(sys.exc_info()[1])+\"]\"));\n _log(logf,log.DEBUG,\"Выход из функции %s\" % str(inspect.getframeinfo(inspect.currentframe())[1])); \n return -1\n if (wo_shops!=''):\n for wo_shop_ in wo_shops:\n try:\n dst_shops.remove(wo_shop_)\n except:\n _log(logf,log.ERROR,\"Неизвестный магазин (назначения), который необходимо пропустить [\"+str(wo_shop_)+\"]\");\n _log(logf,log.ERROR,\"Сообщение системы: \"+str(\"[\"+str(sys.exc_info()[0])+\".\"+str(sys.exc_info()[1])+\"]\"));\n _log(logf,log.DEBUG,\"Выход из функции %s\" % str(inspect.getframeinfo(inspect.currentframe())[1])); \n return -1\n\n elif (option in ('-f','--from')):\n wo_shops=''\n if (string.count(value,'-')>0):\n value_=string.split(value,'-')\n value=value_[0]\n wo_shops=string.split(value_[1],',')\n\n if (value=='*'):\n src_shops=[]\n for counter in cfg.shops:\n src_shops.append(counter)\n else:\n src_shops=string.split(value,',')\n for shop_ in src_shops:\n try:\n shop=cfg.shops[shop_]\n except:\n _log(logf,log.ERROR,\"Неизвестный магазин (источника) [\"+str(shop_)+\"]\");\n _log(logf,log.ERROR,\"Сообщение системы: \"+str(\"[\"+str(sys.exc_info()[0])+\".\"+str(sys.exc_info()[1])+\"]\"));\n _log(logf,log.DEBUG,\"Выход из функции %s\" % str(inspect.getframeinfo(inspect.currentframe())[1])); \n return -1\n if (wo_shops!=''):\n for wo_shop_ in wo_shops:\n try:\n src_shops.remove(wo_shop_)\n except:\n _log(logf,log.ERROR,\"Неизвестный магазин (источника), который необходимо пропустить [\"+str(wo_shop_)+\"]\");\n _log(logf,log.ERROR,\"Сообщение системы: \"+str(\"[\"+str(sys.exc_info()[0])+\".\"+str(sys.exc_info()[1])+\"]\"));\n _log(logf,log.DEBUG,\"Выход из функции %s\" % str(inspect.getframeinfo(inspect.currentframe())[1])); \n return -1\n\n elif (option in ('-m','--module')):\n try:\n (modfile,modname,moddesc)=imp.find_module(value)\n except:\n _log(logf,log.ERROR,\"Hе могу найти модуль [\"+str(value)+\"]\");\n _log(logf,log.ERROR,\"Сообщение системы: \"+str(\"[\"+str(sys.exc_info()[0])+\".\"+str(sys.exc_info()[1])+\"]\"));\n _log(logf,log.DEBUG,\"Выход из функции %s\" % str(inspect.getframeinfo(inspect.currentframe())[1])); \n return -1\n try:\n module=imp.load_module(value,modfile,modname,moddesc)\n except:\n _log(logf,log.ERROR,\"Hе могу загрузить модуль [\"+str(value)+\"]\");\n _log(logf,log.ERROR,\"Сообщение системы: \"+str(\"[\"+str(sys.exc_info()[0])+\".\"+str(sys.exc_info()[1])+\"]\"));\n _log(logf,log.DEBUG,\"Выход из функции %s\" % str(inspect.getframeinfo(inspect.currentframe())[1])); \n return -1\n elif (option in ('-d','--dates')):\n # move dates parse to module\n #dates=date.get_dates(value);\n dates=value;\n elif (option in ('-l','--loglevel')):\n logf.setlevel(int(value));\n elif (option in ('-n','--noauto')):\n # if (value=='yes'):\n # auto=1\n #elif (value=='no'):\n # auto=0\n auto=0\n elif ((option in ('-g','--get')) or (option in ('-p','--put')) ):\n if (value=='yes'):\n upload=1\n elif (value=='no'):\n upload=0\n elif (option in ('-w','--wait')):\n if (value=='yes'):\n wait=1\n elif (value=='no'):\n wait=0\n\n if (runmode==None):\n _log(logf,log.ERROR,\"Hе задан режим запуска [\"+cfg.runmodes[cfg.IMPORT]+\" или \"+cfg.runmodes[cfg.EXPORT]+\" или \"+cfg.runmodes[cfg.GUI_IMPORT]+\" или \"+cfg.runmodes[cfg.GUI_EXPORT]+\"]\");\n _log(logf,log.DEBUG,\"Выход из функции %s\" % str(inspect.getframeinfo(inspect.currentframe())[1])); \n return -1\n if (module==None):\n _log(logf,log.ERROR,\"Hе задан модуль для запуска\");\n _log(logf,log.DEBUG,\"Выход из функции %s\" % str(inspect.getframeinfo(inspect.currentframe())[1])); \n return -1\n if (runmode!=cfg.GUI_IMPORT) and (runmode!=cfg.GUI_EXPORT) and (runmode!=cfg.GUI):\n if (dst_shops==None):\n _log(logf,log.ERROR,\"Hе задан ни один магазин назначения\");\n _log(logf,log.DEBUG,\"Выход из функции %s\" % str(inspect.getframeinfo(inspect.currentframe())[1]));\n return -1\n if (src_shops==None):\n _log(logf,log.ERROR,\"Hе задан ни один магазин-источник\");\n _log(logf,log.DEBUG,\"Выход из функции %s\" % str(inspect.getframeinfo(inspect.currentframe())[1]));\n return -1\n\n\n if (module.__runmodes__.count(cfg.runmodes[runmode])==0):\n _log(logf,log.ERROR,\"Модуль [\"+(module.__name__)+\"] не поддерживает режим запуска [\"+cfg.runmodes[runmode]+\"]\");\n return -1\n _log(logf,log.INFO,\"Запуск модуля %s\" % str(module.__name__))\n try:\n module_=eval('module.'+module.__name__+'()')\n except:\n _log(logf,log.ERROR,\"Ошибка инициализации модуля [%s]\"% str(module.__name__));\n _log(logf,log.ERROR,\"Сообщение системы: \"+str(\"[\"+str(sys.exc_info()[0])+\".\"+str(sys.exc_info()[1])+\"]\"));\n return -1\n\n try:\n result=module_.start_module(auto,runmode,upload,src_shops,dst_shops,dates,logf.loglevel,args);\n _log(logf,log.INFO,\"Завершение работы модуля [%s] с кодом выхода [%s]\" % (str(module.__name__),str(cfg.errors[result])));\n _log(logf,log.DEBUG,\"Выход из функции %s\" % str(inspect.getframeinfo(inspect.currentframe())[1]));\n except:\n _log(logf,log.ERROR,\"Ошибка запуска модуля [%s]\" % str(module.__name__));\n _log(logf,log.ERROR,\"Сообщение системы: \"+str(\"[\"+str(sys.exc_info()[0])+\".\"+str(sys.exc_info()[1])+\"]\")); \n return -1\n\n return result","def onReload(self,moduleName=\"NeedleFinder\"):\n if profiling : profbox()\n #framework\n globals()[moduleName] = slicer.util.reloadScriptedModule(moduleName)","def test_hook_called_with_module(self):\n def test_hook(module):\n self.assertTrue(hasattr(module, 'A'))\n register_post_import_hook('tests.utils.test_module', test_hook)\n import tests.utils.test_module # noqa","def use(self, mtype, mname):\n if mtype == 'exploit':\n return ExploitModule(self.rpc, mname)\n elif mtype == 'post':\n return PostModule(self.rpc, mname)\n elif mtype == 'encoder':\n return EncoderModule(self.rpc, mname)\n elif mtype == 'auxiliary':\n return AuxiliaryModule(self.rpc, mname)\n elif mtype == 'nop':\n return NopModule(self.rpc, mname)\n elif mtype == 'payload':\n return PayloadModule(self.rpc, mname)\n raise MsfRpcError('Unknown module type %s not: exploit, post, encoder, auxiliary, nop, or payload' % mname)","def import_module(self, location, name):","def modExec(module):\n modName = module.split('_')[-1]\n if \"live\" in module:\n dn = '{0} (live)'.format(modName.upper())\n else:\n dn = '{0}'.format(modName.upper())\n\n try:\n modStart = datetime.utcnow()\n log.info(\"Running {0}\".format(dn))\n modImport = 'modules.' + module\n\n import_module(modImport)\n\n modOutput = [i for i in glob.glob(outputdir + '/*') if all(p in i for p in [modName, runID])]\n try:\n arch = [archive.add_file(os.path.basename(outfile)) for outfile in modOutput]\n except IndexError:\n pass\n\n modEnd = datetime.utcnow()\n modRuntime = modEnd - modStart\n log.debug(\"{0} finished in {1}.\".format(dn, modRuntime))\n\n except KeyboardInterrupt:\n sys.stdout.write('\\r')\n sys.stdout.flush()\n log.error(\"{0} was killed. \".format(module))\n\n except Exception:\n log.error(\"{0} failed: {1}\".format(module, [traceback.format_exc()]))","def AddModule (self, module):\n getattr (module, 'load_bench') (self)","def ismodule(object):\r\n return isinstance(object, types.ModuleType)","def create_modules(self):\n self.bitcell = self.replica_bitcell = self.mod_replica_bitcell()\n self.add_mod(self.bitcell)\n\n # This is the replica bitline load column that is the height of our array\n self.rbl = bitcell_array(name=\"bitline_load\", cols=1, rows=self.bitcell_loads)\n self.add_mod(self.rbl)\n\n # FIXME: The FO and depth of this should be tuned\n self.delay_chain = self.mod_delay_chain([self.delay_fanout]*self.delay_stages)\n self.add_mod(self.delay_chain)\n\n self.inv = pinv()\n self.add_mod(self.inv)\n\n self.access_tx = ptx(tx_type=\"pmos\")\n self.add_mod(self.access_tx)","def visit(self, module):\n construct_fn = getattr(module, self.construct_fn, None)\n if construct_fn is not None:\n ret = construct_fn(self.arch_desc, **copy.deepcopy(self.fn_args))\n return module if ret is None else ret\n for n, m in module.named_children():\n m = self.visit(m)\n if m is not None and self.substitute:\n module.add_module(n, m)\n return module","def add_mod(self, mod_name: str) -> None:\n if mod_name + \"_module\" not in self.modules:\n self.modules[mod_name + \"_module\"] = None\n if \"mod_\" + mod_name + \".c\" not in self.modules:\n self.modules[\"mod_\" + mod_name + \".c\"] = None","def _load_module(self):\n self.log(logging.INFO, \"Checking file\", (self.filename, os.getpid()))\n\n try:\n return self.load_module(self.filename)\n except KeyboardInterrupt:\n raise\n except BaseException as e:\n # don't re-raise the error, just proceed without a module object\n # this can happen with scripts that aren't intended to be imported\n if not self.has_file_level_ignore():\n traceback.print_exc()\n if self.tree.body:\n node = self.tree.body[0]\n else:\n node = None\n self.show_error(\n node,\n \"Failed to import {} due to {!r}\".format(self.filename, e),\n error_code=ErrorCode.import_failed,\n )\n return None, False","def __init__(self):\n ScriptedLoadableModuleLogic.__init__(self)","def module(self):\n return self._module","def module(self):\n return self._module","def module(self):\n return self._module","def module(self):\n return self._module","def module(self):\n return self._module","def add_module(self, module):\n if module.name not in self.pool:\n self.pool[module.name] = module"],"string":"[\n \"def process_module_list(self, modules):\",\n \"def visit_Module(self, node):\\n for item in node.body:\\n self.visit(item)\",\n \"def visit_Module(self, node):\\n for item in node.body:\\n self.visit(item)\",\n \"def exec_module(self, module):\\n pass\",\n \"def on_module_event(self, event: str, *args, **kwargs):\",\n \"def process_modules(self) -> typing.NoReturn:\\n\\t\\tfor moduleName in self.moduleNameSet:\\n\\t\\t\\tdetected_encoding = detect_encoding(moduleName)\\n\\n\\t\\t\\tprint(f\\\"Processing {moduleName} ({detected_encoding})\\\")\\n\\n\\t\\t\\twith open(moduleName, 'r+', encoding=detected_encoding) as fileStream:\\n\\t\\t\\t\\t# Store the content of the file\\n\\t\\t\\t\\tfileContent: str = fileStream.read()\\n\\t\\t\\t\\t# Sets the file's current position at the offset, the position of the read/write pointer within the file\\n\\t\\t\\t\\tfileStream.seek(0, 0)\\n\\t\\t\\t\\t# Truncates the file's size\\n\\t\\t\\t\\tfileStream.truncate()\\n\\n\\t\\t\\t\\t# Process regex patterns\\n\\t\\t\\t\\tfor regexDict in regexDictList:\\n\\t\\t\\t\\t\\tfileContent = self.process_function(regexDict, fileContent)\\n\\n\\t\\t\\t\\t# Rewrite the processed content of the file\\n\\t\\t\\t\\tfileStream.write(fileContent)\",\n \"def modules():\",\n \"def handleModuleMessage(self, data):\\n # print (\\\"got a message in silverline module.\\\")\\n (messageType, content) = self.ofxAgent.unpackModuleMessage(data)\\n # print \\\"\\\\tmessage type: %s\\\"%messageType\\n if messageType == ENABLEDECLASSIFIER:\\n self.enableDeclassifier()\\n elif messageType == ADDFLOWPERMISSION:\\n self.addFlowPermission(content)\",\n \"def processModule(newDocNode, modulename):\\n filename = os.path.join(SRC, \\\"%s_swig.xml\\\" % modulename)\\n print filename\\n\\n doc = libxml2.parseFile(filename)\\n topNode = doc.getRootElement()\\n\\n # make a module element\\n name = getAttr(topNode, \\\"module\\\")\\n ##assert name == modulename # sanity check \\n\\n moduleNode = libxml2.newNode(\\\"module\\\")\\n moduleNode.setProp(\\\"name\\\", name) \\n newDocNode.addChild(moduleNode)\\n\\n node = topNode.children\\n while node is not None:\\n if node.name == \\\"include\\\":\\n processInclude(moduleNode, node)\\n node = node.next\\n\\n doc.freeDoc()\",\n \"def execute_module(self):\\n raise NotImplementedError\",\n \"def do_modules(self, args):\\n logger.debug(\\\"do_modules() was called\\\")\\n \\n parser = CrispyArgumentParser(description=self.do_modules.__doc__, prog=\\\"modules\\\")\\n \\n try:\\n pargs = parser.parse_args(shlex.split(args))\\n if pargs:\\n print \\\"\\\\nAvailable modules:\\\\n===================\\\"\\n for mod in self.srv.get_module_list():\\n print \\\"{:<12} -- {}\\\".format(mod.__module__, mod.__doc__)\\n fprint.success(\\\"Done.\\\")\\n except MyParserException as e:\\n print e\",\n \"def module_info():\\n pass\",\n \"def setup_module(module):\\n print(\\\"Start rishabhSetupModule of Program\\\")\",\n \"def process_module(self, node):\\n with node.stream() as stream:\\n self.append_stream(self.linter.current_name, stream, node.file_encoding)\",\n \"def MODULES(self):\\n pass\",\n \"def do_modules(self, module: Optional[str] = None):\\n if module is None or module == \\\"\\\":\\n self._display_available_modules()\\n else:\\n self._display_module(module)\",\n \"def do_list_modules(self, arg):\\n for module in self.reader.module_list.modules:\\n if arg:\\n name = GetModuleName(self.reader, module).lower()\\n if name.find(arg.lower()) >= 0:\\n PrintModuleDetails(self.reader, module)\\n else:\\n PrintModuleDetails(self.reader, module)\\n print()\",\n \"def visit_Module(self, node):\\n self.generic_visit(node)\\n return self.functions\",\n \"def process_module(self, node):\\n code = node.file_stream.read()\\n\\n try:\\n tree = compile(code, node.file, \\\"exec\\\", ast.PyCF_ONLY_AST)\\n except SyntaxError:\\n # Pylint would have already failed\\n return\\n\\n McCabeChecker.max_complexity = self.max_complexity\\n results = McCabeChecker(tree, node.file).run()\\n for lineno, _, text, _ in results:\\n text = text[5:]\\n self.add_message('C0901', line=lineno, args=text)\",\n \"async def module_command_module(self, ctx, parsed):\\n mcs = ModuleCmdStatus\\n results = []\\n subcmd = parsed.subcmd\\n if subcmd.endswith(\\\"load\\\"): # load, reload\\n mtype = parsed.args[\\\"mtype\\\"]\\n if parsed.args[\\\"mtype\\\"] == \\\"protocol\\\" and subcmd == \\\"reload\\\":\\n await ctx.reply_command_result(parsed, \\\"Reloading protocol modules is not yet implemented.\\\")\\n return\\n for mod_id in parsed.args[\\\"module\\\"]:\\n try:\\n module = await getattr(self, f\\\"{subcmd}_{mtype}\\\")(mod_id)\\n except NoSuchModule:\\n status = mcs.NO_SUCH_MOD\\n except (ModuleLoadError, ModuleRegisterError) as ex:\\n status = getattr(mcs, f\\\"{subcmd.upper()}_FAIL\\\")\\n self.logger.exception(ex)\\n except ModuleAlreadyLoaded:\\n status = mcs.ALREADY_LOADED\\n except ModuleNotLoaded:\\n status = mcs.NOT_YET_LOADED\\n else:\\n status = getattr(mcs, f\\\"{subcmd.upper()}_OK\\\")\\n results.append(ModuleCmdResult(mod_id, status, mtype))\\n elif subcmd == \\\"list\\\":\\n status = mcs.QUERY\\n for category in parsed.args[\\\"category\\\"]:\\n if parsed.args[\\\"loaded\\\"]:\\n pool = (mod.identifier for mod in getattr(self, f\\\"get_loaded_{category}s\\\")())\\n else:\\n pool = getattr(self, f\\\"get_available_{category}s\\\")()\\n results.extend(ModuleCmdResult(mod, status, category) for mod in pool)\\n elif subcmd == \\\"info\\\":\\n status = mcs.QUERY\\n mtype = parsed.args[\\\"mtype\\\"]\\n for mod_id in parsed.args[\\\"module\\\"]:\\n info = {}\\n try:\\n module = getattr(self, f\\\"_{mtype}s\\\")[mod_id]\\n except KeyError:\\n if getattr(self, f\\\"{mtype}_available\\\")(mod_id):\\n status = mcs.NOT_YET_LOADED\\n else:\\n status = mcs.NO_SUCH_MOD\\n else:\\n for attr in (\\\"name\\\", \\\"description\\\", \\\"author\\\", \\\"version\\\", \\\"license\\\"):\\n info[attr] = getattr(module, attr)\\n results.append(ModuleCmdResult(mod_id, status, mtype, info))\\n await ctx.core_command_module(parsed, results)\",\n \"def exec_module(cls, *args, **kwargs): # real signature unknown\\n pass\",\n \"def exec_module(cls, *args, **kwargs): # real signature unknown\\n pass\",\n \"def update_modules(self) -> None:\\n\\n matches = apache_util.parse_modules(self.configurator.options.get_modules_cmd)\\n for mod in matches:\\n self.add_mod(mod.strip())\",\n \"def module_file(module):\\n ...\",\n \"def module(self, module):\\n if isinstance(module, six.string_types):\\n module = importlib.import_module(module)\\n for func in get_module_functions(module):\\n self.register_command(func)\",\n \"def on_modules_command(sender, command, label, args):\\n plugin_header(sender, \\\"Modules\\\")\\n msg(sender, \\\", \\\".join([((\\\"&a\\\" if mod in shared[\\\"modules\\\"] else \\\"&c\\\") + mod) for mod in shared[\\\"load_modules\\\"]]))\",\n \"def handle_request_command(self, msg):\\n\\n\\t\\t# only one command?\\n\\t\\tcommand = None\\n\\t\\tif msg.arguments:\\n\\t\\t\\tcommand = msg.arguments[0]\\n\\n\\t\\tmodule_name = moduleManager.module_providing(self.__command_list, command)\\n\\n\\t\\ttry:\\n\\t\\t\\t# check if the module exists in the module manager\\n\\t\\t\\tmoduleManager[module_name]\\n\\t\\texcept KeyError:\\n\\t\\t\\t# the module has been removed from moduleManager (probably through a reload)\\n\\t\\t\\tCORE.warn('Module %r (command=%r, id=%r) does not exists anymore' % (module_name, command, msg.id))\\n\\t\\t\\tmoduleManager.load()\\n\\t\\t\\tself._reload_acls_and_permitted_commands()\\n\\t\\t\\tmodule_name = None\\n\\n\\t\\tif not module_name:\\n\\t\\t\\traise Forbidden()\\n\\n\\t\\tif msg.arguments:\\n\\t\\t\\tif msg.mimetype == MIMETYPE_JSON:\\n\\t\\t\\t\\tis_allowed = moduleManager.is_command_allowed(self.acls, msg.arguments[0], options=msg.options, flavor=msg.flavor)\\n\\t\\t\\telse:\\n\\t\\t\\t\\tis_allowed = moduleManager.is_command_allowed(self.acls, msg.arguments[0])\\n\\t\\t\\tif not is_allowed:\\n\\t\\t\\t\\traise Forbidden()\\n\\t\\t\\tif module_name not in self.__processes:\\n\\t\\t\\t\\tCORE.info('Starting new module process and passing new request to module %s: %s' % (module_name, str(msg._id)))\\n\\t\\t\\t\\ttry:\\n\\t\\t\\t\\t\\tmod_proc = ModuleProcess(module_name, debug=MODULE_DEBUG_LEVEL, locale=self.i18n.locale)\\n\\t\\t\\t\\texcept EnvironmentError as exc:\\n\\t\\t\\t\\t\\tmessage = self._('Could not open the module. %s Please try again later.') % {\\n\\t\\t\\t\\t\\t\\terrno.ENOMEM: self._('There is not enough memory available on the server.'),\\n\\t\\t\\t\\t\\t\\terrno.EMFILE: self._('There are too many opened files on the server.'),\\n\\t\\t\\t\\t\\t\\terrno.ENFILE: self._('There are too many opened files on the server.'),\\n\\t\\t\\t\\t\\t\\terrno.ENOSPC: self._('There is not enough free space on the server.')\\n\\t\\t\\t\\t\\t}.get(exc.errno, self._('An unknown operating system error occurred (%s).' % (exc,)))\\n\\t\\t\\t\\t\\traise ServiceUnavailable(message)\\n\\t\\t\\t\\tmod_proc.signal_connect('result', self.result)\\n\\n\\t\\t\\t\\tcb = notifier.Callback(self._mod_error, module_name)\\n\\t\\t\\t\\tmod_proc.signal_connect('error', cb)\\n\\n\\t\\t\\t\\tcb = notifier.Callback(self._socket_died, module_name)\\n\\t\\t\\t\\tmod_proc.signal_connect('closed', cb)\\n\\n\\t\\t\\t\\tcb = notifier.Callback(self._mod_died, module_name)\\n\\t\\t\\t\\tmod_proc.signal_connect('finished', cb)\\n\\n\\t\\t\\t\\tself.__processes[module_name] = mod_proc\\n\\n\\t\\t\\t\\tcb = notifier.Callback(self._mod_connect, mod_proc, msg)\\n\\t\\t\\t\\tnotifier.timer_add(50, cb)\\n\\t\\t\\telse:\\n\\t\\t\\t\\tproc = self.__processes[module_name]\\n\\t\\t\\t\\tif proc.running:\\n\\t\\t\\t\\t\\tCORE.info('Passing new request to running module %s' % module_name)\\n\\t\\t\\t\\t\\tproc.request(msg)\\n\\t\\t\\t\\t\\tself.reset_inactivity_timer(proc)\\n\\t\\t\\t\\telse:\\n\\t\\t\\t\\t\\tCORE.info('Queuing incoming request for module %s that is not yet ready to receive' % module_name)\\n\\t\\t\\t\\t\\tproc._queued_requests.append(msg)\",\n \"def assemble_module(module):\\n\\n print(f\\\"Assembling module: {module.name}\\\")\",\n \"def _process_modulename(self,modulename):\\n\\t\\tif modulename:\\n\\t\\t\\tif modulename in modules.keys():\\n\\t\\t\\t\\traise NameError(\\\"Module name has already been used in this instance of Python.\\\")\\n\\t\\t\\tself._modulename = modulename\\n\\t\\telse:\\n\\t\\t\\twhile self._modulename in modules.keys():\\n\\t\\t\\t\\tself._modulename = count_up(self._modulename)\\n\\t\\t\\n\\t\\tmodulefile = self._tmpfile(self._modulename + \\\".so\\\")\\n\\t\\tif path.isfile(modulefile):\\n\\t\\t\\traise OSError(\\\"Module file already exists.\\\")\",\n \"def parse_modules(self) -> None:\\n mods: Dict[str, str] = {}\\n matches = self.find_dir(\\\"LoadModule\\\")\\n iterator = iter(matches)\\n # Make sure prev_size != cur_size for do: while: iteration\\n prev_size = -1\\n\\n while len(mods) != prev_size:\\n prev_size = len(mods)\\n\\n for match_name, match_filename in zip(\\n iterator, iterator):\\n mod_name = self.get_arg(match_name)\\n mod_filename = self.get_arg(match_filename)\\n if mod_name and mod_filename:\\n mods[mod_name] = mod_filename\\n mods[os.path.basename(mod_filename)[:-2] + \\\"c\\\"] = mod_filename\\n else:\\n logger.debug(\\\"Could not read LoadModule directive from Augeas path: %s\\\",\\n match_name[6:])\\n self.modules.update(mods)\",\n \"def test_module(self):\\n pass\",\n \"def setModule(name, module):\",\n \"def handleModuleMessage(self, data, datapathSendFcn):\\n print (\\\"handler not implemented in silverline.\\\")\",\n \"def _setModule(self, module):\\n self._module = module\",\n \"def visit_Module(self, node):\\n self.generic_visit(node)\\n return self.classes\",\n \"def __extract_module(log):\\n module = \\\"UNKNOWN\\\"\\n if \\\"module\\\" in log:\\n module = log[\\\"module\\\"]\\n elif \\\"executorName\\\" in log:\\n module = log[\\\"executorName\\\"]\\n elif \\\"http_uri\\\" in log:\\n module = Transformer.__extract_module_from_url(log[\\\"http_uri\\\"])\\n if module == \\\"UNKNOWN\\\" and \\\"header_referer\\\" in log:\\n module = Transformer.__extract_module_from_url(log[\\\"header_referer\\\"])\\n return module\",\n \"def __setup_modules(self, config, db, rcontext):\\n DEPTH_ROOT = 0\\n DEPTH_TYPE = 1\\n DEPTH_SUBTYPE = 2\\n\\n for root, sub_folders, files in os.walk(\\\"modules\\\"):\\n nicepath = os.path.relpath(root, \\\"modules\\\")\\n fullpath = root\\n\\n if nicepath == '.':\\n depth = DEPTH_ROOT\\n else:\\n depth = nicepath.count(os.path.sep) + 1\\n\\n if depth > DEPTH_SUBTYPE:\\n warnings.warn(\\\"sub-subdirectory in module (%s) \\\\\\n ignored.\\\" % nicepath)\\n\\n modulenamebase = nicepath.replace(os.path.sep, '.')\\n mimetype = nicepath.replace(os.path.sep, '/')\\n\\n if depth != DEPTH_ROOT:\\n # Each folder should except root have an __init__.py,\\n # otherwise the directory name be assigned as a module.\\n if not \\\"__init__.py\\\" in files:\\n warnings.warn(\\\"__init__.py not found in \\\\\\n module folder '%s'.\\\" % nicepath)\\n continue\\n\\n modulepath = fullpath + os.path.sep + \\\"__init__.py\\\"\\n module = Module(modulepath, modulenamebase, mimetype)\\n self.modules.append(module)\\n\\n # Now load each handler .py file\\n for file in files:\\n modulenameend, extension = os.path.splitext(file)\\n if extension.lower() == \\\".py\\\":\\n is_init = file == \\\"__init__.py\\\"\\n modulepath = fullpath + os.path.sep + file\\n modulename = None\\n if is_init:\\n modulename = modulenamebase\\n elif depth == DEPTH_ROOT:\\n modulename = modulenameend\\n else:\\n modulename = modulenamebase + '.' + modulenameend\\n\\n module = Module(modulepath, modulename, mimetype,\\n is_global=(depth == DEPTH_ROOT),\\n as_mime_handler=not is_init)\\n if module.is_mime_handler and not rcontext.is_recursive:\\n db.setup_module_table(module.md5_tablename,\\n module.columndefinition)\\n\\n self.modules.append(module)\",\n \"def module(self, module):\\n self._module = module\",\n \"def module(self, module):\\n self._module = module\",\n \"def module(self, module):\\n self._module = module\",\n \"def hookInfo() :\\n return ModuleInfo(\\n name=\\\"My Module\\\",\\n version=\\\"1.2\\\",\\n author=\\\"Some Author\\\",\\n description=\\\"A module that does something.\\\"\\n )\",\n \"def setup_module():\\n common_setup_module()\",\n \"def form_module_handlers(page, request, context, *args, **kwargs):\\n form_modules = {}\\n streamfields = util.get_streamfields(page)\\n\\n for fieldname, blocks in streamfields.items():\\n for index, child in enumerate(blocks):\\n if hasattr(child.block, 'get_result'):\\n if fieldname not in form_modules:\\n form_modules[fieldname] = {}\\n\\n if not request.method == 'POST':\\n is_submitted = child.block.is_submitted(\\n request,\\n fieldname,\\n index\\n )\\n module_context = child.block.get_result(\\n page,\\n request,\\n child.value,\\n is_submitted\\n )\\n form_modules[fieldname].update({index: module_context})\\n if form_modules:\\n context['form_modules'] = form_modules\",\n \"def _ui_module(self, name, module):\\n raise NotImplementedError()\",\n \"def exec_module(self, module):\\n\\n if not self.filename.endswith(config.FILE_EXT) and not self.filename.endswith(\\n \\\"__init__.py\\\"\\n ):\\n print(\\\"Fatal error: ExtensionLoader is asked to load a normal file.\\\")\\n print(\\\"filename:\\\", self.filename)\\n print(\\\"Expected extension:\\\", config.FILE_EXT)\\n raise SystemExit\\n\\n name = module.__name__\\n if module.__name__ == config.MAIN_MODULE_NAME:\\n module.__name__ = \\\"__main__\\\"\\n config.MAIN_MODULE_NAME = None\\n\\n with open(self.filename) as f:\\n source = f.read()\\n\\n transforms.identify_requested_transformers(source)\\n\\n if config.TRANSFORMERS:\\n original = source\\n source = transforms.add_all_imports(source)\\n source = transforms.apply_source_transformations(source)\\n\\n if config.DIFF and original != source:\\n self.write_html_diff(name, original, source)\\n\\n if config.CONVERT and self.filename.endswith(config.FILE_EXT):\\n print(\\\"############### Original source: ############\\\\n\\\")\\n print(original)\\n print(\\\"\\\\n############### Converted source: ############\\\\n\\\")\\n print(source)\\n print(\\\"=\\\" * 50, \\\"\\\\n\\\")\\n\\n source = transforms.apply_ast_transformations(source)\\n exec(source, vars(module))\",\n \"def perform_module_operation(self):\\n\\n nfs_export_name = self.module.params['nfs_export_name']\\n nfs_export_id = self.module.params['nfs_export_id']\\n filesystem = self.module.params['filesystem']\\n snapshot = self.module.params['snapshot']\\n nas_server = self.module.params['nas_server']\\n path = self.module.params['path']\\n description = self.module.params['description']\\n default_access = self.module.params['default_access']\\n no_access_hosts = self.module.params['no_access_hosts']\\n read_only_hosts = self.module.params['read_only_hosts']\\n read_only_root_hosts = self.module.params['read_only_root_hosts']\\n read_write_hosts = self.module.params['read_write_hosts']\\n read_write_root_hosts = self.module.params['read_write_root_hosts']\\n min_security = self.module.params['min_security']\\n anonymous_uid = self.module.params['anonymous_uid']\\n anonymous_gid = self.module.params['anonymous_gid']\\n is_no_suid = self.module.params['is_no_suid']\\n host_state = self.module.params['host_state']\\n state = self.module.params['state']\\n\\n result = dict(\\n changed=False,\\n nfs_export_details=''\\n )\\n\\n export_parent = filesystem if filesystem else snapshot\\n changed = False\\n nfs_modify_dict = dict()\\n\\n # Validate the input parameters\\n self.validate_input(export_parent)\\n\\n # Get the ID of the filesystem/snapshot if name is provided\\n export_parent_id = None\\n if export_parent is not None:\\n export_parent_id = self.get_fs_id_from_filesystem(\\n export_parent, nas_server)\\n\\n # Get the details of NFS export\\n nfs_export_details = self.get_nfs_export(\\n nfs_export_name, nfs_export_id, export_parent, nas_server, path)\\n\\n # Check if modification to the NFS export is required\\n if state == 'present' and nfs_export_details:\\n nfs_modify_dict = self.check_nfs_export_modified(\\n nfs_export_details, description, default_access, min_security,\\n anonymous_uid, anonymous_gid, is_no_suid)\\n\\n # Create NFS export\\n if state == 'present' and not nfs_export_details:\\n if nfs_export_id:\\n error_msg = \\\"NFS export with nfs_export_id {0} not found.\\\".\\\\\\n format(nfs_export_id)\\n self.module.fail_json(msg=error_msg)\\n\\n if nfs_export_name and not export_parent:\\n self.module.fail_json(msg=\\\"filesystem/snapshot is required to\\\"\\n \\\" create NFS export.\\\")\\n\\n changed = self.create_nfs_export(export_parent, nfs_export_name,\\n export_parent_id, path)\\n\\n # Modify NFS export\\n if state == 'present' and nfs_export_details and nfs_modify_dict:\\n changed = self.modify_nfs_export(nfs_export_details,\\n nfs_modify_dict)\\n\\n # Delete NFS export\\n elif state == 'absent' and nfs_export_details:\\n changed = self.delete_nfs_export(nfs_export_details)\\n\\n # Finally update the module result!\\n result['changed'] = changed\\n if state == 'present':\\n result['nfs_export_details'] = self.get_nfs_export(\\n nfs_export_name, nfs_export_id, export_parent, nas_server,\\n path)\\n\\n self.module.exit_json(**result)\",\n \"def module_runner(module):\\n task_queue.put(1)\\n result = sys.modules[module].run()\\n task_queue.get()\\n store_module_result(result) # Store the result in our repo\",\n \"def post(self):\\n return self.rpc.call(MsfRpcMethod.ModulePost)['modules']\",\n \"async def execute_module_command(request):\\n hw = hw_from_req(request)\\n requested_serial = request.match_info['serial']\\n data = await request.json()\\n command_type = data.get('command_type')\\n args = data.get('args')\\n\\n hw_mods = hw.attached_modules\\n\\n if len(hw_mods) == 0:\\n return web.json_response({\\\"message\\\": \\\"No connected modules\\\"},\\n status=404)\\n\\n matching_mod = next((mod for mod in hw_mods if\\n mod.device_info.get('serial') == requested_serial),\\n None)\\n\\n if not matching_mod:\\n return web.json_response({\\\"message\\\": \\\"Specified module not found\\\"},\\n status=404)\\n\\n if hasattr(matching_mod, command_type):\\n clean_args = args or []\\n method = getattr(matching_mod, command_type)\\n if asyncio.iscoroutinefunction(method):\\n val = await method(*clean_args)\\n else:\\n val = method(*clean_args)\\n\\n return web.json_response(\\n {'message': 'Success', 'returnValue': val},\\n status=200)\\n else:\\n return web.json_response(\\n {'message': f'Module does not have command: {command_type}'},\\n status=400)\",\n \"def RunModule(self):\\n module = self.statModules.GetActive()\\n \\n self.ShutdownStatModule()\\n \\n if module is not None:\\n wx.LogMessage(\\\"Running stat module...\\\")\\n self.statPage = module.Load(self.nb, self)\\n self.SetView(self.statModules.caption, self.statPage)\",\n \"def process_module(module):\\n options_dict = {}\\n flags_dict = {}\\n \\n for klass in [getattr(module, cname) for cname in dir(module) if hasattr(getattr(module, cname), 'option_names')]:\\n if klass.option_names[0] is not None:\\n flags_dict[klass.option_names[0]] = klass()\\n options_dict[klass.option_names[1]] = klass()\\n \\n module.options_dict = options_dict\\n module.flags_dict = flags_dict\",\n \"def _createModuleObj(self):\\n raise NotImplementedError(\\\"Implement in derived class.\\\")\",\n \"def set_values(self,module):\\n if type(module) == dict:\\n self.set_value(\\\"name\\\",module[\\\"name\\\"])\\n self.set_value(\\\"hrname\\\",module[\\\"hrname\\\"])\\n self.set_value(\\\"version_major\\\",module[\\\"version_major\\\"])\\n self.set_value(\\\"version_minor\\\",module[\\\"version_minor\\\"])\\n self.set_value(\\\"revision\\\",module[\\\"revision\\\"])\\n if module.has_key(\\\"signature\\\"):\\n self.set_value(\\\"signature\\\",module[\\\"signature\\\"])\\n elif module.__class__.__name__ == \\\"Module\\\":\\n pass #TODO IMPLEMENT / DISCUSS AFTER IMPLEMENTING MODULE-SUBSYSTEM\",\n \"def moduleInfo(*args, definition: bool=True, listModules: bool=True, moduleName: AnyStr=\\\"\\\",\\n path: bool=True, version: bool=True, **kwargs)->List[AnyStr]:\\n pass\",\n \"def add_module(self, *args, **kwargs):\\n# if 'path' in kwargs:\\n# path = kwargs['path']\\n# else:\\n# path = os.getcwd()\\n#\\n# if len(args) > 0:\\n# module = args[0]\\n# elif 'module' in kwargs:\\n# module = kwargs['module']\\n#\\n# if 'path' not in kwargs:\\n# path = os.getcwd()\\n# kwargs['path'] = path\\n\\n if 'module' not in kwargs:\\n if len(args) > 0:\\n module = args[0]\\n kwargs['module'] = module\\n\\n# if 'module' in kwargs:\\n if len(kwargs) > 0:\\n self._data.add_detector(self._name, **kwargs)\",\n \"def set_module(self, module):\\n setattr(self, \\\"module\\\", module)\",\n \"def _handle_load_module(self, name: str, module_type: Type[Module]) -> ModuleType:\\n if module_type not in [FeatureModule, ProtocolModule]:\\n raise TypeError(f\\\"Invalid type '{module_type}'\\\")\\n type_str = \\\"feature\\\" if module_type is FeatureModule else \\\"protocol\\\"\\n try:\\n module = module_type(f\\\"ZeroBot.{type_str}.{name}\\\")\\n except ModuleNotFoundError as ex:\\n raise NoSuchModule(f\\\"Could not find {type_str} module '{name}': {ex}\\\", mod_id=name, exc=ex) from None\\n except Exception as ex:\\n raise ModuleLoadError(f\\\"Failed to load {type_str} module '{name}'\\\", mod_id=name) from ex\\n self.logger.debug(f\\\"Imported {type_str} module {module!r}\\\")\\n return module\",\n \"def _try_set_module(self, module: str):\\n loaded_module = next((x for x in self.modules if x.__name__ == module), None)\\n if loaded_module is not None:\\n self.current_module = module\\n self._real_module = loaded_module\\n print(\\n asciistuff.Cowsay(\\n \\\"Master of puppets is pulling the strings: using \\\"\\n + self.current_module\\n )\\n )\\n else:\\n print(\\\"No module named {} available\\\".format(module))\",\n \"def _add_module_to_map(self, model_key, module_dict):\\n\\n # Get the module name from the dict.\\n if 'module' in module_dict:\\n module_name = module_dict['module']\\n elif 'omftype' in module_dict:\\n module_name = module_dict['argument']\\n else:\\n # Bad dict.\\n raise ValueError('Malformed module_dict: {}'.format(module_dict))\\n\\n # Ensure we aren't over-writing existing module.\\n if module_name in self.model_map['module']:\\n s = 'Module {} is already present!'.format(module_name)\\n raise ItemExistsError(s)\\n\\n # Map it by name.\\n self.model_map['module'][module_name] = [model_key, module_dict]\",\n \"def make_modules(self, config):\\n pass\",\n \"def visit(self, file_object):\\n\\n module = ast.parse(file_object.read())\\n # TODO remove prefixes such as C:\\\\Users\\\\...\\n module_name = file_object.name.rstrip(\\\".py\\\").replace(\\\"/\\\", \\\".\\\")\\n\\n exec(\\\"import %s\\\"%module_name)\\n self._module = eval(module_name)\\n\\n self.found = {\\\"vars\\\":[], \\\"classes\\\":[], \\\"funcs\\\":[]}\\n self.found_classes = set()\\n\\n self._explorer(self, [module_name]).visit(module)\",\n \"def mod_load(self):\\n raise NotImplementedError(\\\"Mod load isn't overriden\\\")\",\n \"def do_workload(self):\\n module_manager = self._core.get_module_manager()\\n module = module_manager.get_module_by_name(self._values[\\\"name\\\"])\\n module_manager.update_module(module)\",\n \"def process(self, doc):\\n if not type(doc) is xmldoc.XMLDoc:\\n raise ValueError(\\\"doc must be a XMLDoc\\\")\\n\\n pyIdlak_txp.PyIdlakModule_process(self._mod, doc.idlak_doc)\",\n \"def load_module(self, module_name): # pragma: no cover\\r\\n try:\\r\\n module = import_module('SoftLayer.CLI.modules.%s' % module_name)\\r\\n for _, obj in inspect.getmembers(module):\\r\\n if inspect.isclass(obj) and issubclass(obj, CLIRunnable):\\r\\n self.add_plugin(obj)\\r\\n return module\\r\\n except ImportError:\\r\\n raise InvalidModule(module_name)\",\n \"def do_use(self, module: str):\\n if module != \\\"\\\":\\n self._try_set_module(module)\\n else:\\n self.current_module = None\\n self._real_module = None\",\n \"def test_03_module_logger(self):\\n module_logger = get_module_logger(self.__module__)\\n module_logger.info('Info in Module {}'.format(self.__module__))\",\n \"def _createModuleObj(self):\\n ModuleInitialCondition.__init__(self)\",\n \"def __init__(self):\\n self.modules = {}\",\n \"def __update_module(item):\\n\\n conn = sqlite3.connect(DTF_DB)\\n cur = conn.cursor()\\n\\n # Remove the line first.\\n sql = ('DELETE FROM modules '\\n \\\"WHERE name='%s'\\\" % item.name)\\n\\n cur.execute(sql)\\n\\n entry = [(item.name, item.about, item.version,\\n item.author, item.install_name)]\\n\\n # Update a Module Entry\\n sql = ('INSERT INTO modules (name, about, version, '\\n 'author, install_name)'\\n 'VALUES (?, ?, ?, ?, ?)')\\n\\n cur.executemany(sql, entry)\\n conn.commit()\\n\\n return cur.rowcount\",\n \"def execute_module(self, module, *args, **opts):\\n module_file = module.__file__\\n if module_file.endswith('.pyc'):\\n module_file = module_file[:-1]\\n cmd = [self._path]\\n if 'python_options' in opts:\\n cmd.extend(opts['python_options'])\\n del opts['python_options']\\n cmd.append(module_file)\\n cmd.extend(args)\\n return get_cmd_output(*cmd, **opts)\",\n \"def setup_module(self, conf: DictConfig) -> BaseMLModule:\\n pass\",\n \"def present_module_info():\\n writer()\\n print_heading(\\\"Module Info\\\")\\n writer(f\\\"GWT Version: {GWT_VERSION}\\\")\\n writer(f\\\"Content-Type: {CONTENT_TYPE}\\\")\\n writer(f\\\"X-GWT-Module-Base: {BASE_URL}\\\")\\n writer(f\\\"X-GWT-Permutation: {GWT_PERMUTATION}\\\")\\n if RPC_MODE:\\n writer(f\\\"RPC Version: {RPC_VERSION}\\\")\\n writer(f\\\"RPC Flags: {RPC_FLAGS}\\\")\\n writer()\",\n \"def run_module(self):\\n try:\\n if self.in_distributed_mode:\\n self.output_dict['insurance_usd'] = 0\\n self.output_dict['construction_permitting_usd'] = 0\\n self.output_dict['project_management_usd'] = 0\\n self.output_dict['bonding_usd'] = 0\\n self.output_dict['markup_contingency_usd'] = 0\\n self.output_dict['engineering_usd'] = 0\\n self.output_dict['site_facility_usd'] = 0\\n self.output_dict['total_management_cost'] = self.input_dict['override_total_management_cost']\\n\\n else:\\n self.output_dict['insurance_usd'] = self.insurance()\\n self.output_dict['construction_permitting_usd'] = self.construction_permitting()\\n self.output_dict['project_management_usd'] = self.project_management()\\n self.output_dict['bonding_usd'] = self.bonding()\\n self.output_dict['markup_contingency_usd'] = self.markup_contingency()\\n self.output_dict['engineering_usd'] = self.engineering_foundations_collection_sys()\\n self.output_dict['site_facility_usd'] = self.site_facility()\\n self.output_dict['total_management_cost'] = self.total_management_cost()\\n self.output_dict['management_cost_csv'] = self.outputs_for_detailed_tab()\\n self.output_dict['mangement_module_type_operation'] = self.outputs_for_module_type_operation()\\n return 0, 0 # module ran successfully\\n except Exception as error:\\n traceback.print_exc()\\n print(f\\\"Fail {self.project_name} ManagementCost\\\")\\n return 1, error # module did not run successfully\",\n \"def on_module_choice(self, event):\\n\\n self.log.trace(\\\"Handle module selection by user.\\\")\\n result = {'successful': False}\\n\\n try:\\n # determine module selected\\n module_name = event.GetString()\\n\\n self.feature_choices = []\\n for selection in DEFAULT_SEL:\\n self.feature_choices.append(selection)\\n if module_name.lower() == CUSTOM_SEL.lower():\\n # set custom flag\\n self.custom_module = True\\n # show custom input\\n self.input_custom_module.Show()\\n else:\\n # clear custom flag\\n self.custom_module = False\\n # make sure custom field is hidden\\n self.input_custom_module.Hide()\\n if module_name.lower() != BLANK_SEL.lower():\\n # return all features for module\\n self.log.trace(\\\"Rebuilding feature list for %s module ...\\\" % module_name)\\n features = self.database.return_features_for_module(module_name)['features']\\n\\n # build feature list\\n for feature in features:\\n self.feature_choices.append(feature['name'])\\n\\n # set feature choices to selection\\n self.input_feature.SetItems(self.feature_choices)\\n self._update_feature_input_according_to_custom_module_flag()\\n self.log.trace(\\\"Feature list for %s module rebuilt.\\\" % module_name)\\n\\n # reset user story selections\\n self.log.trace(\\\"Reseting user story list ...\\\")\\n self.story_choices = []\\n for selection in DEFAULT_SEL:\\n self.story_choices.append(selection)\\n self.input_story.SetItems(self.story_choices)\\n self._update_story_input_according_to_custom_feature_flag()\\n self.log.trace(\\\"User story list reset.\\\")\\n\\n # reset test selections\\n self.log.trace(\\\"Reseting test list ...\\\")\\n self.test_choices = []\\n for selection in DEFAULT_SEL:\\n self.test_choices.append(selection)\\n self.input_test.SetItems(self.test_choices)\\n self._update_test_input_according_to_custom_story_flag()\\n self.log.trace(\\\"Test list reset.\\\")\\n\\n # reset testcase selections\\n self.log.trace(\\\"Reseting test case list ...\\\")\\n self.testcase_choices = []\\n for selection in DEFAULT_SEL:\\n self.testcase_choices.append(selection)\\n self.input_testcase.SetItems(self.testcase_choices)\\n self._update_testcase_input_according_to_custom_test_flag()\\n self.log.trace(\\\"Test case list reset.\\\")\\n\\n result['successful'] = True\\n except BaseException, e:\\n self.handle_exception(e, \\\"handle module selection by user\\\")\\n\\n # return\\n return result\",\n \"def main():\\n obj = UnityFilesystem()\\n obj.perform_module_operation()\",\n \"def __do_single_module_install(item):\\n\\n name = item.name\\n local_name = item.local_name\\n install_name = item.install_name\\n\\n # First copy the new file.\\n if copy_file(local_name, install_name, DTF_MODULES_DIR) != 0:\\n log.e(TAG, \\\"Error copying module '%s'\\\" % (local_name))\\n return -1\\n\\n # Update database\\n if __update_module(item) == 0:\\n log.e(TAG, \\\"Failed to update module '%s' details in database.\\\"\\n % (name))\\n return -2\\n\\n log.i(TAG, \\\"Module '%s' installed successfully!\\\" % name)\\n return 0\",\n \"def _reset_module(m):\\n raise NotImplementedError\",\n \"def applyModuleChanges(self, moduleInst):\\n\\n pass\",\n \"def loadModule(self, module = \\\"\\\", modType=\\\"python\\\"):\\n\\t\\tif modType == \\\"python\\\":\\t\\t\\t\\n\\t\\t\\tmod = None\\t\\t\\t#try:\\n\\t\\t\\tsys.path.insert(0, os.path.dirname(module))\\n\\t\\t\\tfile = os.path.basename(module)\\n\\t\\t\\tfile = file[:file.rfind('.')]\\n\\t\\t\\t#print \\\"Try: \\\", file, \\\"over\\\", sys.path\\n\\t\\t\\ttry:\\n\\t\\t\\t\\tmod = __import__(file)\\n\\t\\t\\texcept:\\n\\t\\t\\t\\tprint \\\"Invalid CSL API Module '%s' ignored.\\\" % (file)\\n\\t\\t\\t\\tsys.path.pop(0)\\n\\t\\t\\t\\treturn None\\n\\t\\t\\tsys.path.pop(0)\\n\\t\\t\\t#print \\\"Loaded Module Info:\\\", dir(mod)\\n\\t\\t\\tif \\\"CSLAPI_NAME\\\" in dir(mod):\\t\\t\\t\\t\\n\\t\\t\\t\\tmod.CSLValue = CSLValue\\n\\t\\t\\t\\tmod.debug = self.debug\\n\\t\\t\\t\\tvtbl = mod.getFuncTable()\\n\\t\\t\\t\\t#print \\\"CSL Module loader:\\\", module\\n\\t\\t\\t\\tvtbl_names = vtbl.keys()\\n\\t\\t\\t\\tfor i in vtbl_names:\\n\\t\\t\\t\\t\\t#print \\\"\\\\tAdded Function '%s' from module: %s (%s)\\\" % (i, mod.__file__, vtbl[i].__class__)\\n\\t\\t\\t\\t\\tself.cslAPIS[i] = vtbl[i]\\n\\t\\t\\t\\tself.cslAPIMods.append(mod)\",\n \"def compileModule(self, code):\\n r = ast.Module(None, self.compileSuite(code))\\n #print r\\n return r\",\n \"def start_modules():\\n global logf\\n # BUG.\\n # this log-string will never be in the log file, because loglevel is low than DEBUG ;(\\n _log(logf,log.DEBUG,\\\"В функции %s\\\" % str(inspect.getframeinfo(inspect.currentframe())[1]));\\n # \\n dates=date.get_cur_date(logf)\\n runmode=None\\n module=None\\n auto=1\\n wait=1\\n upload=1\\n do_archive=1\\n src_shops=None\\n dst_shops=None\\n try:\\n options,args=getopt.getopt(sys.argv[1:],'a:t:f:m:d:l:u:s:g:p:wn',['action=','to=','from=','module=','date=','loglevel=','shop=','get=','put=','wait','noauto'])\\n if (len(options)==0):\\n display_usage()\\n return 0\\n except getopt.GetoptError:\\n _log(logf,log.ERROR,\\\"Неизвестная опция или опция без параметра\\\");\\n _log(logf,log.DEBUG,\\\"Выход из функции %s\\\" % str(inspect.getframeinfo(inspect.currentframe())[1]));\\n display_usage()\\n return -1;\\n except:\\n _log(logf,log.ERROR,\\\"Ошибка разбора командной строки\\\");\\n _log(logf,log.ERROR,\\\"Сообщение системы: [%s.%s]\\\" % str(sys.exc_info()[0],str(sys.exc_info()[1])));\\n _log(logf,log.DEBUG,\\\"Выход из функции %s\\\" % str(inspect.getframeinfo(inspect.currentframe())[1]));\\n display_usage()\\n return -1;\\n for option,value in options:\\n value=string.lower(value)\\n if (option in ('-a','--action')):\\n runmodes=[]\\n for mode in cfg.runmodes:\\n runmodes.append(cfg.runmodes[mode])\\n if (value not in runmodes):\\n _log(logf,log.ERROR,\\\"Неизвестный режим запуска [%s]\\\" % str(value));\\n _log(logf,log.ERROR,\\\"Доступны только \\\"+str(runmodes));\\n _log(logf,log.DEBUG,\\\"Выход из функции %s\\\" % str(inspect.getframeinfo(inspect.currentframe())[1])); \\n return -1\\n else:\\n for mode_ in cfg.runmodes.items():\\n if (value==mode_[1]):\\n runmode=mode_[0]\\n break\\n\\n elif (option in ('-t','--to') or (option in ('-s','--shop'))):\\n wo_shops=''\\n if (string.count(value,'-')>0):\\n value_=string.split(value,'-')\\n value=value_[0]\\n wo_shops=string.split(value_[1],',')\\n if (value=='*'):\\n dst_shops=[]\\n for counter in cfg.shops:\\n dst_shops.append(counter)\\n else:\\n dst_shops=string.split(value,',')\\n for shop_ in dst_shops:\\n try:\\n shop=cfg.shops[shop_]\\n except:\\n _log(logf,log.ERROR,\\\"Неизвестный магазин (назначения) [\\\"+str(shop_)+\\\"]\\\");\\n _log(logf,log.ERROR,\\\"Сообщение системы: \\\"+str(\\\"[\\\"+str(sys.exc_info()[0])+\\\".\\\"+str(sys.exc_info()[1])+\\\"]\\\"));\\n _log(logf,log.DEBUG,\\\"Выход из функции %s\\\" % str(inspect.getframeinfo(inspect.currentframe())[1])); \\n return -1\\n if (wo_shops!=''):\\n for wo_shop_ in wo_shops:\\n try:\\n dst_shops.remove(wo_shop_)\\n except:\\n _log(logf,log.ERROR,\\\"Неизвестный магазин (назначения), который необходимо пропустить [\\\"+str(wo_shop_)+\\\"]\\\");\\n _log(logf,log.ERROR,\\\"Сообщение системы: \\\"+str(\\\"[\\\"+str(sys.exc_info()[0])+\\\".\\\"+str(sys.exc_info()[1])+\\\"]\\\"));\\n _log(logf,log.DEBUG,\\\"Выход из функции %s\\\" % str(inspect.getframeinfo(inspect.currentframe())[1])); \\n return -1\\n\\n elif (option in ('-f','--from')):\\n wo_shops=''\\n if (string.count(value,'-')>0):\\n value_=string.split(value,'-')\\n value=value_[0]\\n wo_shops=string.split(value_[1],',')\\n\\n if (value=='*'):\\n src_shops=[]\\n for counter in cfg.shops:\\n src_shops.append(counter)\\n else:\\n src_shops=string.split(value,',')\\n for shop_ in src_shops:\\n try:\\n shop=cfg.shops[shop_]\\n except:\\n _log(logf,log.ERROR,\\\"Неизвестный магазин (источника) [\\\"+str(shop_)+\\\"]\\\");\\n _log(logf,log.ERROR,\\\"Сообщение системы: \\\"+str(\\\"[\\\"+str(sys.exc_info()[0])+\\\".\\\"+str(sys.exc_info()[1])+\\\"]\\\"));\\n _log(logf,log.DEBUG,\\\"Выход из функции %s\\\" % str(inspect.getframeinfo(inspect.currentframe())[1])); \\n return -1\\n if (wo_shops!=''):\\n for wo_shop_ in wo_shops:\\n try:\\n src_shops.remove(wo_shop_)\\n except:\\n _log(logf,log.ERROR,\\\"Неизвестный магазин (источника), который необходимо пропустить [\\\"+str(wo_shop_)+\\\"]\\\");\\n _log(logf,log.ERROR,\\\"Сообщение системы: \\\"+str(\\\"[\\\"+str(sys.exc_info()[0])+\\\".\\\"+str(sys.exc_info()[1])+\\\"]\\\"));\\n _log(logf,log.DEBUG,\\\"Выход из функции %s\\\" % str(inspect.getframeinfo(inspect.currentframe())[1])); \\n return -1\\n\\n elif (option in ('-m','--module')):\\n try:\\n (modfile,modname,moddesc)=imp.find_module(value)\\n except:\\n _log(logf,log.ERROR,\\\"Hе могу найти модуль [\\\"+str(value)+\\\"]\\\");\\n _log(logf,log.ERROR,\\\"Сообщение системы: \\\"+str(\\\"[\\\"+str(sys.exc_info()[0])+\\\".\\\"+str(sys.exc_info()[1])+\\\"]\\\"));\\n _log(logf,log.DEBUG,\\\"Выход из функции %s\\\" % str(inspect.getframeinfo(inspect.currentframe())[1])); \\n return -1\\n try:\\n module=imp.load_module(value,modfile,modname,moddesc)\\n except:\\n _log(logf,log.ERROR,\\\"Hе могу загрузить модуль [\\\"+str(value)+\\\"]\\\");\\n _log(logf,log.ERROR,\\\"Сообщение системы: \\\"+str(\\\"[\\\"+str(sys.exc_info()[0])+\\\".\\\"+str(sys.exc_info()[1])+\\\"]\\\"));\\n _log(logf,log.DEBUG,\\\"Выход из функции %s\\\" % str(inspect.getframeinfo(inspect.currentframe())[1])); \\n return -1\\n elif (option in ('-d','--dates')):\\n # move dates parse to module\\n #dates=date.get_dates(value);\\n dates=value;\\n elif (option in ('-l','--loglevel')):\\n logf.setlevel(int(value));\\n elif (option in ('-n','--noauto')):\\n # if (value=='yes'):\\n # auto=1\\n #elif (value=='no'):\\n # auto=0\\n auto=0\\n elif ((option in ('-g','--get')) or (option in ('-p','--put')) ):\\n if (value=='yes'):\\n upload=1\\n elif (value=='no'):\\n upload=0\\n elif (option in ('-w','--wait')):\\n if (value=='yes'):\\n wait=1\\n elif (value=='no'):\\n wait=0\\n\\n if (runmode==None):\\n _log(logf,log.ERROR,\\\"Hе задан режим запуска [\\\"+cfg.runmodes[cfg.IMPORT]+\\\" или \\\"+cfg.runmodes[cfg.EXPORT]+\\\" или \\\"+cfg.runmodes[cfg.GUI_IMPORT]+\\\" или \\\"+cfg.runmodes[cfg.GUI_EXPORT]+\\\"]\\\");\\n _log(logf,log.DEBUG,\\\"Выход из функции %s\\\" % str(inspect.getframeinfo(inspect.currentframe())[1])); \\n return -1\\n if (module==None):\\n _log(logf,log.ERROR,\\\"Hе задан модуль для запуска\\\");\\n _log(logf,log.DEBUG,\\\"Выход из функции %s\\\" % str(inspect.getframeinfo(inspect.currentframe())[1])); \\n return -1\\n if (runmode!=cfg.GUI_IMPORT) and (runmode!=cfg.GUI_EXPORT) and (runmode!=cfg.GUI):\\n if (dst_shops==None):\\n _log(logf,log.ERROR,\\\"Hе задан ни один магазин назначения\\\");\\n _log(logf,log.DEBUG,\\\"Выход из функции %s\\\" % str(inspect.getframeinfo(inspect.currentframe())[1]));\\n return -1\\n if (src_shops==None):\\n _log(logf,log.ERROR,\\\"Hе задан ни один магазин-источник\\\");\\n _log(logf,log.DEBUG,\\\"Выход из функции %s\\\" % str(inspect.getframeinfo(inspect.currentframe())[1]));\\n return -1\\n\\n\\n if (module.__runmodes__.count(cfg.runmodes[runmode])==0):\\n _log(logf,log.ERROR,\\\"Модуль [\\\"+(module.__name__)+\\\"] не поддерживает режим запуска [\\\"+cfg.runmodes[runmode]+\\\"]\\\");\\n return -1\\n _log(logf,log.INFO,\\\"Запуск модуля %s\\\" % str(module.__name__))\\n try:\\n module_=eval('module.'+module.__name__+'()')\\n except:\\n _log(logf,log.ERROR,\\\"Ошибка инициализации модуля [%s]\\\"% str(module.__name__));\\n _log(logf,log.ERROR,\\\"Сообщение системы: \\\"+str(\\\"[\\\"+str(sys.exc_info()[0])+\\\".\\\"+str(sys.exc_info()[1])+\\\"]\\\"));\\n return -1\\n\\n try:\\n result=module_.start_module(auto,runmode,upload,src_shops,dst_shops,dates,logf.loglevel,args);\\n _log(logf,log.INFO,\\\"Завершение работы модуля [%s] с кодом выхода [%s]\\\" % (str(module.__name__),str(cfg.errors[result])));\\n _log(logf,log.DEBUG,\\\"Выход из функции %s\\\" % str(inspect.getframeinfo(inspect.currentframe())[1]));\\n except:\\n _log(logf,log.ERROR,\\\"Ошибка запуска модуля [%s]\\\" % str(module.__name__));\\n _log(logf,log.ERROR,\\\"Сообщение системы: \\\"+str(\\\"[\\\"+str(sys.exc_info()[0])+\\\".\\\"+str(sys.exc_info()[1])+\\\"]\\\")); \\n return -1\\n\\n return result\",\n \"def onReload(self,moduleName=\\\"NeedleFinder\\\"):\\n if profiling : profbox()\\n #framework\\n globals()[moduleName] = slicer.util.reloadScriptedModule(moduleName)\",\n \"def test_hook_called_with_module(self):\\n def test_hook(module):\\n self.assertTrue(hasattr(module, 'A'))\\n register_post_import_hook('tests.utils.test_module', test_hook)\\n import tests.utils.test_module # noqa\",\n \"def use(self, mtype, mname):\\n if mtype == 'exploit':\\n return ExploitModule(self.rpc, mname)\\n elif mtype == 'post':\\n return PostModule(self.rpc, mname)\\n elif mtype == 'encoder':\\n return EncoderModule(self.rpc, mname)\\n elif mtype == 'auxiliary':\\n return AuxiliaryModule(self.rpc, mname)\\n elif mtype == 'nop':\\n return NopModule(self.rpc, mname)\\n elif mtype == 'payload':\\n return PayloadModule(self.rpc, mname)\\n raise MsfRpcError('Unknown module type %s not: exploit, post, encoder, auxiliary, nop, or payload' % mname)\",\n \"def import_module(self, location, name):\",\n \"def modExec(module):\\n modName = module.split('_')[-1]\\n if \\\"live\\\" in module:\\n dn = '{0} (live)'.format(modName.upper())\\n else:\\n dn = '{0}'.format(modName.upper())\\n\\n try:\\n modStart = datetime.utcnow()\\n log.info(\\\"Running {0}\\\".format(dn))\\n modImport = 'modules.' + module\\n\\n import_module(modImport)\\n\\n modOutput = [i for i in glob.glob(outputdir + '/*') if all(p in i for p in [modName, runID])]\\n try:\\n arch = [archive.add_file(os.path.basename(outfile)) for outfile in modOutput]\\n except IndexError:\\n pass\\n\\n modEnd = datetime.utcnow()\\n modRuntime = modEnd - modStart\\n log.debug(\\\"{0} finished in {1}.\\\".format(dn, modRuntime))\\n\\n except KeyboardInterrupt:\\n sys.stdout.write('\\\\r')\\n sys.stdout.flush()\\n log.error(\\\"{0} was killed. \\\".format(module))\\n\\n except Exception:\\n log.error(\\\"{0} failed: {1}\\\".format(module, [traceback.format_exc()]))\",\n \"def AddModule (self, module):\\n getattr (module, 'load_bench') (self)\",\n \"def ismodule(object):\\r\\n return isinstance(object, types.ModuleType)\",\n \"def create_modules(self):\\n self.bitcell = self.replica_bitcell = self.mod_replica_bitcell()\\n self.add_mod(self.bitcell)\\n\\n # This is the replica bitline load column that is the height of our array\\n self.rbl = bitcell_array(name=\\\"bitline_load\\\", cols=1, rows=self.bitcell_loads)\\n self.add_mod(self.rbl)\\n\\n # FIXME: The FO and depth of this should be tuned\\n self.delay_chain = self.mod_delay_chain([self.delay_fanout]*self.delay_stages)\\n self.add_mod(self.delay_chain)\\n\\n self.inv = pinv()\\n self.add_mod(self.inv)\\n\\n self.access_tx = ptx(tx_type=\\\"pmos\\\")\\n self.add_mod(self.access_tx)\",\n \"def visit(self, module):\\n construct_fn = getattr(module, self.construct_fn, None)\\n if construct_fn is not None:\\n ret = construct_fn(self.arch_desc, **copy.deepcopy(self.fn_args))\\n return module if ret is None else ret\\n for n, m in module.named_children():\\n m = self.visit(m)\\n if m is not None and self.substitute:\\n module.add_module(n, m)\\n return module\",\n \"def add_mod(self, mod_name: str) -> None:\\n if mod_name + \\\"_module\\\" not in self.modules:\\n self.modules[mod_name + \\\"_module\\\"] = None\\n if \\\"mod_\\\" + mod_name + \\\".c\\\" not in self.modules:\\n self.modules[\\\"mod_\\\" + mod_name + \\\".c\\\"] = None\",\n \"def _load_module(self):\\n self.log(logging.INFO, \\\"Checking file\\\", (self.filename, os.getpid()))\\n\\n try:\\n return self.load_module(self.filename)\\n except KeyboardInterrupt:\\n raise\\n except BaseException as e:\\n # don't re-raise the error, just proceed without a module object\\n # this can happen with scripts that aren't intended to be imported\\n if not self.has_file_level_ignore():\\n traceback.print_exc()\\n if self.tree.body:\\n node = self.tree.body[0]\\n else:\\n node = None\\n self.show_error(\\n node,\\n \\\"Failed to import {} due to {!r}\\\".format(self.filename, e),\\n error_code=ErrorCode.import_failed,\\n )\\n return None, False\",\n \"def __init__(self):\\n ScriptedLoadableModuleLogic.__init__(self)\",\n \"def module(self):\\n return self._module\",\n \"def module(self):\\n return self._module\",\n \"def module(self):\\n return self._module\",\n \"def module(self):\\n return self._module\",\n \"def module(self):\\n return self._module\",\n \"def add_module(self, module):\\n if module.name not in self.pool:\\n self.pool[module.name] = module\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.73333037","0.6903211","0.6903211","0.6841748","0.6787638","0.6626777","0.6554846","0.64963454","0.6429045","0.6391386","0.63664407","0.63107514","0.6293941","0.6276409","0.6265793","0.6207045","0.61946833","0.61454856","0.61390555","0.6034528","0.60310644","0.60310644","0.6018316","0.5976949","0.5976227","0.59668565","0.59504586","0.5944654","0.59398866","0.5921813","0.5917266","0.5914685","0.5899526","0.5880972","0.5809535","0.580783","0.5790046","0.57778066","0.57778066","0.57778066","0.5756075","0.574554","0.57314265","0.5728601","0.569954","0.56819576","0.56736237","0.5650754","0.5631707","0.5627215","0.5618883","0.56044966","0.5601472","0.5597783","0.558184","0.55785966","0.5571201","0.55702096","0.5563471","0.55564255","0.5546018","0.5537794","0.55345875","0.5533474","0.5531188","0.5497358","0.54853994","0.54841995","0.54836524","0.5477618","0.54703194","0.5468989","0.54663855","0.54656947","0.54631233","0.54597265","0.54499555","0.54205453","0.54150015","0.5411519","0.540168","0.5398034","0.5396556","0.5383018","0.53743315","0.5365115","0.5351878","0.5351286","0.53509","0.53465134","0.5345827","0.53428185","0.5339545","0.5337736","0.5318942","0.5318942","0.5318942","0.5318942","0.5318942","0.53140134"],"string":"[\n \"0.73333037\",\n \"0.6903211\",\n \"0.6903211\",\n \"0.6841748\",\n \"0.6787638\",\n \"0.6626777\",\n \"0.6554846\",\n \"0.64963454\",\n \"0.6429045\",\n \"0.6391386\",\n \"0.63664407\",\n \"0.63107514\",\n \"0.6293941\",\n \"0.6276409\",\n \"0.6265793\",\n \"0.6207045\",\n \"0.61946833\",\n \"0.61454856\",\n \"0.61390555\",\n \"0.6034528\",\n \"0.60310644\",\n \"0.60310644\",\n \"0.6018316\",\n \"0.5976949\",\n \"0.5976227\",\n \"0.59668565\",\n \"0.59504586\",\n \"0.5944654\",\n \"0.59398866\",\n \"0.5921813\",\n \"0.5917266\",\n \"0.5914685\",\n \"0.5899526\",\n \"0.5880972\",\n \"0.5809535\",\n \"0.580783\",\n \"0.5790046\",\n \"0.57778066\",\n \"0.57778066\",\n \"0.57778066\",\n \"0.5756075\",\n \"0.574554\",\n \"0.57314265\",\n \"0.5728601\",\n \"0.569954\",\n \"0.56819576\",\n \"0.56736237\",\n \"0.5650754\",\n \"0.5631707\",\n \"0.5627215\",\n \"0.5618883\",\n \"0.56044966\",\n \"0.5601472\",\n \"0.5597783\",\n \"0.558184\",\n \"0.55785966\",\n \"0.5571201\",\n \"0.55702096\",\n \"0.5563471\",\n \"0.55564255\",\n \"0.5546018\",\n \"0.5537794\",\n \"0.55345875\",\n \"0.5533474\",\n \"0.5531188\",\n \"0.5497358\",\n \"0.54853994\",\n \"0.54841995\",\n \"0.54836524\",\n \"0.5477618\",\n \"0.54703194\",\n \"0.5468989\",\n \"0.54663855\",\n \"0.54656947\",\n \"0.54631233\",\n \"0.54597265\",\n \"0.54499555\",\n \"0.54205453\",\n \"0.54150015\",\n \"0.5411519\",\n \"0.540168\",\n \"0.5398034\",\n \"0.5396556\",\n \"0.5383018\",\n \"0.53743315\",\n \"0.5365115\",\n \"0.5351878\",\n \"0.5351286\",\n \"0.53509\",\n \"0.53465134\",\n \"0.5345827\",\n \"0.53428185\",\n \"0.5339545\",\n \"0.5337736\",\n \"0.5318942\",\n \"0.5318942\",\n \"0.5318942\",\n \"0.5318942\",\n \"0.5318942\",\n \"0.53140134\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.6489552"},"document_rank":{"kind":"string","value":"8"}}},{"rowIdx":24993,"cells":{"query":{"kind":"string","value":"Add the \"ClassName\" filed."},"document":{"kind":"string","value":"def add_class_name_field(data):\n\n for case in data:\n case_id = case['No.']\n filed_list = case_id.split('_')\n filed_list = list(map(lambda x: x.title(), filed_list))\n case['ClassName'] = ''.join(filed_list)"},"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 setClassName(self,whichDir):\n self.className = whichDir\n self.setClassMap({whichDir : 1})","def addClassRef(clazz):\n\n global h_classes\n header = \"class %s;\" % clazz\n if not header in h_classes:\n h_classes.append(header)","def add_class(self, name):\n if name is not None and not self.has_class(name):\n self._cached_class.append(name)\n self._update_class()","def add_class(self, period_num, class_name):\n self._classes[period_num] = class_name","def save_class(self, a, class_name):\n logging.debug(\"in save class \" + class_name)\n self.produce(\"class_name\", class_name)\n self.classes.append(class_name)\n self.begin('')","def add_class(self, new_class):\n index = self._counter\n self._counter += 1\n for element in new_class:\n self._class_names[element] = index\n node = self.part[index].append(element)\n self._place[element] = node","def add_class(self, cls):\n self.commands.append(cls)","def add_class(self, klass):\n if not issubclass(klass, DataClayObject):\n raise DataClayException(\"Can only use DataClayObject classes\")\n\n logger.debug(\"Adding class %s to the MetaClassFactory\", klass)\n class_container = klass._prepare_metaclass(self._namespace, self._responsible_account)\n\n # Save to the list, and bookmark the MetaClass\n # (for valid recursive behaviour, e.g. cycles)\n complete_name = class_container.name\n logger.debug(\"[add_class] Using `%s` as `name` field of Type\", complete_name)\n if complete_name not in self.types:\n self.types[complete_name] = UserType(\n signature=\"L{};\".format(complete_name).replace(\".\", \"/\"),\n includes=[],\n namespace=self._namespace,\n typeName=complete_name,\n )\n self.classes.append(class_container)\n\n parent = klass.__bases__[0]\n if parent is not DataClayObject:\n self.add_class(parent)\n\n logger.debug(\"Class %s finished\", class_container.name)","def update_css_class(kwargs, class_name):\n if \"className\" in kwargs:\n kwargs[\"className\"] += f\" {class_name}\"\n else:\n kwargs[\"className\"] = class_name","def add_class_to_ont(self, ID):\n self.ont.addClass(ID)\n self.ont.label(ID, self.label)\n self.ont.annotation(ID, 'IAO_0000115', self.definition)\n if 'equivalentTo' in self.pattern:\n self.ont.equivalentClasses(ID, self.equivalentTo)\n if 'subClassOf' in self.pattern:\n self.ont.subClassOf(ID, self.subClassOf)\n # Don't currently have means to generate GCIs!","def new_class(self, grp, name, class_type=\"NXcollection\"):\n sub = grp.require_group(name)\n sub.attrs[\"NX_class\"] = numpy.string_(class_type)\n return sub","def set_name(self, name):\n self.class_name = name","def write_class_name(annotation_file_path, class_name):\n root = etree.parse(annotation_file_path)\n objects = root.findall('object')\n \n for item in objects:\n name = item.find('name')\n name.text = class_name\n\n root.write(annotation_file_path, pretty_print=True)","def add_sclass(self, w: Wrapper, prop: Any) -> None:\n if not prop:\n return\n props = self.sclasses(w)\n if isinstance(prop, str):\n props.append(prop)\n else:\n props.extend(prop)\n self.set_sclasses(w, props)","def __set_name__(self, cls, name):\n pass","def register_class(self, cls, *, name=None):\n cls_name = self.host.cache_class(cls, name)\n self.register_constant(cls, cls_name)","def _add_class_to_map(self, model_key, class_dict):\n # Extract the class name.\n class_name = class_dict['class']\n\n try:\n # Attempt to access this class by name in the map.\n self.model_map['class'][class_name]\n except KeyError:\n # Class object does not exist. Map it.\n self.model_map['class'][class_name] = [model_key, class_dict]\n else:\n # This class name already exists, which will lead to\n # duplicates and failure.\n raise ItemExistsError('Class {} already exists in the map.'\n .format(class_name))","def CSSClasses(self):","def process_class(self, parent, cls):\n if cls.typemap.flat_name in self.class_map:\n raise RuntimeError(\"process_class: class {} already exists in class_map\"\n .format(cls.typemap.flat_name))\n self.class_map[cls.typemap.flat_name] = cls\n for var in cls.variables:\n self.add_var_getter_setter(parent, cls, var)\n cls.functions = self.define_function_suffix(cls.functions)","def visit_class(self, flags, scope, token, parent):\r\n\r\n # define the class name in the current scope\r\n # see visit_block\r\n #scope.define(SC_FUNCTION, token.children[0])\r\n scope.defer(token)","def contribute_to_class(self, cls, name):\n\n super(StdImageField, self).contribute_to_class(cls, name)\n signals.post_save.connect(self._rename_resize_image, sender=cls)\n signals.post_init.connect(self.set_variations, sender=cls)","def class_name(name: str) -> str:\n return text.pascal_case(utils.safe_snake(name, \"type\"))","def add_to_class(cls, name, value):\n if hasattr(value, 'contribute_to_class'):\n value.contribute_to_class(cls, name)\n if not name.startswith('_'):\n cls._fields[name] = value\n else:\n setattr(cls, name, value)","def __create_classname(self, fullname):\n return PACKAGE_NAME + \".\" + fullname","def set_class_list(self, L):\n\t\tself.class_list = L","def declare_class_property(self, name):\n\n self.objc_class.forced_properties.add(name)","def add_class_to_widget(widget, *css_classes):\n css_string = \" \".join(css_classes)\n if 'class' in widget.attrs:\n widget.attrs['class'] += ' {} '.format(css_string)\n else:\n widget.attrs['class'] = css_string","def bind_class(self, className, sequence=None, func=None, add=None):\n return super().bind_class(className, sequence, func, add)","def register(cls, class_):\n cls._registered[class_.tag()] = class_","def setup_class(klass):","def setup_class(klass):","def register_node_type_from_module(self, modname, classname):\n nodelist.register_node_type_from_module(modname, classname)","def prepare_classnames(self, start=None, add=None, exclude=None):\n classnames = start or []\n classnames.extend(add or [])\n return self.finalise_classname(classnames, exclude or [])","def process_class_list(self, module, classes):","def _create_class(self, name, superclass):\n template = self._fill_template(name, superclass)\n directory = (\"controllers\" if self.type == \"controller\" else\n self.type.capitalize())\n\n path = self.module.path + os.sep + directory + os.sep\n # Check if the class name contains underscores. If it does, interpret\n # them as directory separators.\n if not name.find(\"_\") == -1:\n substrings = name.split(\"_\")\n path += os.path.join(*substrings[:-1]) + os.sep\n try:\n os.makedirs(path)\n except OSError:\n pass # The directories already exist\n name = substrings[-1]\n dest = path + name + \".php\"\n if not os.path.isfile(dest):\n dest = open(dest, \"w\")\n dest.write(template)\n dest.close()\n else:\n raise OSError(\"File exists: \" + dest)","def _class(self, _class):\n\n self.__class = _class","def _class(self, _class):\n\n self.__class = _class","def add_parameter(self, param_type, param_name, this_class_name=''):\n self._set_instance_data('parameters',\n ' '.join([self.add_dependency(param_type, this_class_name),\n param_name]))","def create_class(self):\n temp_class = self.temp('separated.class')\n return temp_class.format(**self.__dict__)","def create(self, class_name, default_version, description):\n\n body = {'class_name': class_name, 'default_version': default_version}\n if description is not None:\n body['description'] = description\n response = self.client.post(Classes.PATH_CLASSES, body=body)\n return response","def update_class(self, class_info):\n SchemaValidator(self.schema_extension_only, self.schema_nx).validate_class_schema(class_info)\n self.schema[\"@graph\"].append(class_info)\n self.load_schema(self.schema)\n print(\"Updated the class {} successfully!\".format(class_info[\"rdfs:label\"]))","def insert_class(self, user_label: str) -> None:\n logger.debug(\"Adds \\\"{}\\\" to the user label class\", user_label)\n\n if self.cluster_k == -1:\n logger.debug(\"Clustering is disabled. Hence, just added to the list in set-semantic (current length: {})\",\n len(self.classes))\n final_label_tokens = self.convert_label(user_label=user_label)\n if final_label_tokens not in self.classes:\n self.classes.append(final_label_tokens)\n else:\n logger.debug(\"\\\"{}\\\" was already in the list!\", \" \".join(final_label_tokens))","def setup_class(self):\n pass","def register(self, klass):\n if klass not in self.extensions:\n self.extensions.append(klass)","def add_obj_class(self, new_obj_class: ObjClass) -> ProjectMeta:\n return self.add_obj_classes([new_obj_class])","def registerFileType(self, extensions, classname):\r\n\r\n # keep track of all reader classes\r\n self._all_readers.append(classname)\r\n\r\n # iterate over all extensions\r\n for e in extensions:\r\n e_lower = e.lower()\r\n if e_lower not in self._extension_map:\r\n self._extension_map[e_lower] = []\r\n\r\n self._extension_map[e_lower].append(\r\n (extensions[e] + ' file', classname))","def add_to(class_reference, **attr_dict): \n _entry=class_reference()\n for _key in attr_dict:\n _entry.__dict__['_'+_key] = attr_dict[_key]\n _entry.put()\n return str(_entry.key())","def __init__(self):\n self.classes = {}","def register(cls, instance_class: Type, name: str = None):\n if name is None:\n name = instance_class.__name__\n if logger.isEnabledFor(logging.DEBUG):\n logger.debug(f'registering: {instance_class} for {cls} -> {name}')\n cls.INSTANCE_CLASSES[name] = instance_class","def visit_ClassDef(self, node):\n if node in self.manager.found_classes:\n return\n\n self.manager.found_classes.add(node)\n self.manager.found[\"classes\"].append({\"name\":node.name,\n \"lineno\":node.lineno,\n \"namespace\":\".\".join(self.parent)})\n\n # Keep checking all nodes in this class.\n for my_node in node.body:\n self.manager._explorer(self.manager, self.parent + [node.name]).visit(my_node)","def addType(self, name):\n setattr(self, name, name)\n self._type_names[name] = name\n if name in self._pending_type_names:\n del self._pending_type_names[name]","def register_class(self, instance, name=None):\n prefix_name = name or instance.__class__.__name__\n\n for e in dir(instance):\n if e[0][0] != \"_\":\n self.register_function(\n getattr(instance, e),\n name=\"%s.%s\" % (prefix_name, e)\n )","def after_class_creation(cls):\n pass","def classname(cls):\n return cls.__name__.lower()","def _get_classname(cls):\n return cls.__name__","def __init__(self, name: str = 'ret_val') -> None:\n self.name = name\n self.class_name = \"\"","def insert_class_markers(soup):\r\n\r\n # look for class name in a div like <div class=\"title\">Namespace::MyClass Class Reference</div>\r\n title_div = soup.find(\"div\", \"title\")\r\n if not title_div:\r\n raise ValueError(\"The following div was not found : <div class='title'>...<div>\")\r\n\r\n # titlediv.get_text() --> \"Namespace::MyClass Class Reference\"\r\n fullclassname = title_div.get_text().split()[0]\r\n classname = fullclassname.split(\"::\")[-1]\r\n\r\n # look for the contents div\r\n contents_div = soup.find( \"div\", \"contents\" )\r\n if not contents_div:\r\n raise ValueError(\"The following div was not found : <div class='contents'>...<div>\")\r\n \r\n # insert Qt Creator markers around the brief paragraph\r\n brief_p = contents_div.p\r\n brief_p.insert_before(class_brief_start(classname))\r\n brief_p.insert_after(class_brief_end(classname))","def deploy_class( self, target, type_name, fti ):\n write = self.stream.write\n tptypes = getToolByName( target, 'portal_types', None )\n\n if tptypes is None:\n write( 'No portal_skins' )\n elif not tptypes.getTypeInfo( type_name ):\n tptypes.addType( type_name, fti[0] )\n write( 'Added type object for %s \\n' % type_name )\n else:\n write( 'Skipping type object for %s (already exists) \\n' % type_name )","def find_class(self, class_name: str) -> Type:\n pass","def changeClass(self, newClass):\n\t\turl = \"https://habitica.com/api/v3/user/change-class?class=\" + newClass\n\t\treturn(postUrl(url, self.credentials))","def apiresponse(classname):\n APIRESPONSE[classname.name] = classname\n return classname","def register_classname(self, classname, package, pxd_base, cpppxd_base,\n cpp_classname=None, make_dtypes=True):\n # target classname\n baseclassname = classname\n if isinstance(classname, basestring):\n template_args = None\n templateclassname = baseclassname\n templatefuncname = baseclassname.lower()\n else:\n template_args = ['T{0}'.format(i) for i in range(len(classname)-2)]\n template_args = tuple(template_args)\n while not isinstance(baseclassname, basestring):\n baseclassname = baseclassname[0] # hack version of ts.basename()\n templateclassname = baseclassname\n templateclassname = templateclassname + \\\n ''.join([\"{\"+targ+\"}\" for targ in template_args])\n templatefuncname = baseclassname.lower() + '_' + \\\n '_'.join([\"{\"+targ+\"}\" for targ in template_args])\n\n # source classname\n if cpp_classname is None:\n cpp_classname = classname\n cpp_baseclassname = cpp_classname\n if not isinstance(cpp_classname, basestring):\n while not isinstance(cpp_baseclassname, basestring):\n cpp_baseclassname = cpp_baseclassname[0]\n if template_args is None:\n template_args = ['T{0}'.format(i) for i in range(len(cpp_classname)-2)]\n template_args = tuple(template_args)\n\n # register regular class\n class_c2py = ( # '{t.cython_pytype}({var})',\n ('{proxy_name} = {t.cython_pytype}()\\n'\n '(<{t.cython_ctype_nopred} *> {proxy_name}._inst)[0] = {var}'),\n ('{proxy_name} = {t.cython_pytype}()\\n'\n '(<{t.cython_ctype_nopred} *> {proxy_name}._inst)[0] = {var}'),\n ('if {cache_name} is None:\\n'\n ' {proxy_name} = {t.cython_pytype}()\\n'\n ' {proxy_name}._free_inst = False\\n'\n ' {proxy_name}._inst = &{var}\\n'\n ' {cache_name} = {proxy_name}\\n')\n )\n class_py2c = ('{proxy_name} = <{t.cython_cytype_nopred}> {var}',\n '(<{t.cython_ctype_nopred} *> {proxy_name}._inst)[0]')\n class_cimport = ((package, cpppxd_base),)\n kwclass = dict(\n name=baseclassname, # FCComp\n template_args=template_args,\n cython_c_type=cpppxd_base + '.' + cpp_baseclassname, # cpp_fccomp.FCComp\n cython_cimport=class_cimport,\n cython_cy_type=pxd_base + '.' + baseclassname, # fccomp.FCComp\n cython_py_type=pxd_base + '.' + baseclassname, # fccomp.FCComp\n from_pytype=[pxd_base + '.' + baseclassname], # fccomp.FCComp\n cpp_type=cpp_baseclassname,\n human_name=templateclassname,\n cython_template_class_name=templateclassname,\n cython_template_function_name=templatefuncname,\n cython_cyimport=((pxd_base,),), # fccomp\n cython_pyimport=((pxd_base,),), # fccomp\n cython_c2py=class_c2py,\n cython_py2c=class_py2c,\n )\n self.register_class(**kwclass)\n canonname = classname if isinstance(classname, basestring) \\\n else self.canon(classname)\n if template_args is not None:\n specname = classname if isinstance(classname, basestring) \\\n else self.cython_classname(classname)[1]\n kwclassspec = dict(\n name=classname,\n cython_c_type=cpppxd_base + '.' + specname,\n cython_cy_type=pxd_base + '.' + specname,\n cython_py_type=pxd_base + '.' + specname,\n cpp_type=self.cpp_type(cpp_classname),\n )\n self.register_class(**kwclassspec)\n kwclassspec['name'] = canonname\n self.register_class(**kwclassspec)\n kwclassspec['name'] = self.canon(cpp_classname)\n self.register_class(**kwclassspec)\n # register numpy type\n if make_dtypes:\n self.register_numpy_dtype(classname,\n cython_cimport=class_cimport,\n cython_cyimport=pxd_base,\n cython_pyimport=pxd_base,\n )\n # register vector\n class_vector_py2c = ((\n '# {var} is a {t.type}\\n'\n 'cdef int i{var}\\n'\n 'cdef int {var}_size\\n'\n 'cdef {t.cython_npctypes[0]} * {var}_data\\n'\n '{var}_size = len({var})\\n'\n 'if isinstance({var}, np.ndarray) and (<np.ndarray> {var}).descr.type_num == {t.cython_nptype}:\\n'\n ' {var}_data = <{t.cython_npctypes[0]} *> np.PyArray_DATA(<np.ndarray> {var})\\n'\n ' {proxy_name} = {t.cython_ctype_nopred}(<size_t> {var}_size)\\n'\n ' for i{var} in range({var}_size):\\n'\n ' {proxy_name}[i{var}] = {var}_data[i{var}]\\n'\n 'else:\\n'\n ' {proxy_name} = {t.cython_ctype_nopred}(<size_t> {var}_size)\\n'\n ' for i{var} in range({var}_size):\\n'\n ' {proxy_name}[i{var}] = (<{t.cython_npctypes_nopred[0]} *> (<{t.cython_npcytypes_nopred[0]}> {var}[i{var}])._inst)[0]\\n'),\n '{proxy_name}')\n self.register_class(('vector', canonname, 0), cython_py2c=class_vector_py2c)\n self.register_class(('vector', classname, 0), cython_py2c=class_vector_py2c)\n self.register_class((('vector', canonname, 0), '&'), cython_py2c=class_vector_py2c)\n self.register_class((('vector', classname, 0), '&'), cython_py2c=class_vector_py2c)\n self.register_class(((('vector', canonname, 0), 'const'), '&'), cython_py2c=class_vector_py2c)\n self.register_class(((('vector', classname, 0), 'const'), '&'), cython_py2c=class_vector_py2c)\n # register pointer to class\n class_ptr_c2py = ('{t.cython_pytype}({var})',\n ('cdef {t.cython_pytype} {proxy_name} = {t.cython_pytype}()\\n'\n 'if {proxy_name}._free_inst:\\n'\n ' free({proxy_name}._inst)\\n'\n '(<{t.cython_ctype}> {proxy_name}._inst) = {var}'),\n ('if {cache_name} is None:\\n'\n ' {proxy_name} = {t.cython_pytype}()\\n'\n ' {proxy_name}._free_inst = False\\n'\n ' {proxy_name}._inst = {var}\\n'\n ' {cache_name} = {proxy_name}\\n')\n )\n class_ptr_py2c = ('{proxy_name} = <{t.cython_cytype_nopred}> {var}',\n '(<{t.cython_ctype_nopred} *> {proxy_name}._inst)')\n kwclassptr = dict(\n name=(classname, '*'),\n template_args=template_args,\n cython_py_type=pxd_base + '.' + baseclassname,\n cython_cy_type=pxd_base + '.' + baseclassname,\n cpp_type=cpp_baseclassname,\n cython_c2py=class_ptr_c2py,\n cython_py2c=class_ptr_py2c,\n cython_cimport=kwclass['cython_cimport'] ,\n cython_cyimport=kwclass['cython_cyimport'] + (('libc.stdlib','free'),),\n cython_pyimport=kwclass['cython_pyimport'],\n )\n self.register_class(**kwclassptr)\n kwclassref = dict(kwclassptr)\n # Register reference to class\n kwclassref['name'] = (classname, '&')\n kwclassref['cython_c2py'] = class_c2py\n kwclassref['cython_py2c'] = class_py2c\n #ts.register_class(**kwclassref)\n # register doublepointer to class\n class_dblptr_c2py = ('{t.cython_pytype}({var})',\n ('{proxy_name} = {proxy_name}_obj._inst\\n'\n '(<{t.cython_ctype} *> {proxy_name}._inst) = {var}'),\n ('if {cache_name} is None:\\n'\n ' {proxy_name} = {t.cython_pytype}()\\n'\n ' {proxy_name}._free_inst = False\\n'\n ' {proxy_name}._inst = {var}\\n'\n ' {proxy_name}_list = [{proxy_name}]\\n'\n ' {cache_name} = {proxy_name}_list\\n')\n )\n class_dblptr_py2c = ('{proxy_name} = <{t.cython_cytype_nopred}> {var}[0]',\n '(<{t.cython_ctype_nopred} **> {proxy_name}._inst)')\n kwclassdblptr = dict(\n name=((classname, '*'), '*'),\n template_args=template_args,\n cython_c2py=class_dblptr_c2py,\n cython_py2c=class_dblptr_py2c,\n cython_cimport=kwclass['cython_cimport'],\n cython_cyimport=kwclass['cython_cyimport'],\n cython_pyimport=kwclass['cython_pyimport'],\n )\n self.register_class(**kwclassdblptr)","def do_create(self, line):\n if line:\n if line in HBNBCommand.classes:\n class_to_ins = HBNBCommand.classes.get(line)\n new_instance = class_to_ins()\n new_instance.save()\n print(new_instance.id)\n else:\n print(\"** class name missing **\")\n else:\n print(\"** class doesn't exist **\")","def add_etl_class(self, etl_class):\n\n if etl_class.identifier in self.etl_classes:\n raise DuplicateConfigException(\n \"Builder already has etl_class with identifier : {}\".format(\n etl_class.identifier\n )\n )\n\n self.etl_classes[etl_class.identifier] = etl_class","def add_attribute(a_class, name, value):\n types = ['str', [], {}, (1, 1), 1.1, 1, None]\n for item in types:\n if type(a_class) == type(item):\n raise TypeError(\"can't add new attribute\")\n a_class.name = value","def register_class(obj):\r\n try:\r\n KnownClass.objects.get(module_name=obj.__module__, class_name=obj.__class__.__name__)\r\n except DoesNotExist:\r\n # Create it\r\n KnownClass(module_name = obj.__module__, class_name = obj.__class__.__name__).save()","def do_create(self, arg):\n args = arg.split()\n if len(args) == 0:\n print(\"** class name missing **\")\n return\n if args[0] in self.class_dict:\n new = self.class_dict.get(args[0])()\n storage.save()\n print(new.id)\n else:\n print(\"** class doesn't exist **\")","def set_route_class_to_add_destination(self, route_class):\n self.multiple_items_selection_from_kendo_dropdown(self.route_class_multiple_kendo_dropdown_locator, route_class)\n self.click_element(self.new_destination_header_locator)","def set_bucket_class(self, bucket_class):\r\n self.bucket_class = bucket_class","def classnamefilter(self, name):\n return False","def classnamefilter(self, name):\n return False","def classes(self):\n if self.classname:\n return [self.classname]\n return []","def set_sclasses(self, w: Wrapper, classes: Any) -> None:\n w.setProperty(self.style_sclass_property, f\" {' '.join(set(classes))} \")","def class_name(self) -> str:\n return pulumi.get(self, \"class_name\")","def addRegexClass(self, label, regex, userdist=3):\n self._call_java('addRegexClass', label, regex, userdist)\n return self","def html_class(self):\n try:\n html_class = [\n 'plugin-{0} {1}'.format(\n self.uid, ' '.join(self.html_classes)\n )\n ]\n return ' '.join(html_class)\n except Exception as err:\n logger.debug(\n \"Error in class %s. Details: %s\",\n self.__class__.__name__,\n str(err)\n )","def do_create(self, class_name):\n\n if not class_name:\n print(\"** class name missing **\")\n elif class_name not in HBNBCommand.class_list:\n print(\"** class doesn't exist **\")\n else:\n new_object = eval(class_name + \"()\")\n new_object.save()\n print(new_object.id)","def setup_class(cls):","def setup_class(cls):","def get_class(self, name):\n raise NotImplementedError","def get_classname(self):\n return 'ImageFilm'","def compile_class(self):\n\t\t\n\t\txml = '<class>\\n' + self.tokenizer.keyword() + self.tokenizer.identifier() + self.tokenizer.symbol()\n\n\t\tself.outfile.write(xml)","def create_class_from_strings( self, module_name, class_name):\r\n if not( self.logger is None ):\r\n self.logger.debug( \"create class {module_name} {class_name}\" )\r\n\r\n# print( \"create class \" + module_name + \" \" + class_name )\r\n\r\n a_class = getattr( importlib.import_module(module_name), class_name )\r\n instance = a_class( )\r\n return instance","def add_train_file(self, classname: str, filename: str, handler: int = 0) -> int:\n return self.get_func(\"DC_AddTrainFile\", [c_char_p, c_char_p, POINTER(c_int)], c_int)(\n classname, filename, handler)","def register_class(self, entity_class):\n key = entity_class.__collection_name__\n\n if key not in self._registered_types:\n self._registered_types[key] = entity_class","def parameterize_class_name(cls: Type, idx: int, input_dicts: Mapping[Any, Any]):\n suffix = \"_\".join(f\"{k}_{v}\" for k, v in input_dicts.items())\n return f\"{cls.__name__}_{suffix}\"","def register_class(cls):\n if cls is RegisteredType:\n raise \"Please do _not_ register RegisteredType!\"\n \n cid = RegisteredType._reg[autoid]\n RegisteredType._reg['classes'][cls] = cid\n RegisteredType._reg['classids'][cid] = cls\n RegisteredType._reg['autoid'] += 1","def make_class(attributes, base_classes=()):\r\n \"*** YOUR CODE HERE ***\"","def on_Add_new_class_button_clicked(self):\n Add_new_class = Shangke_message()\n Add_new_class.exec_()\n result = Shangke_message.result\n # print(result)\n self.lineEdit.setText(result['Cname'])\n self.lineEdit_2.setText(result['Sclass'])\n self.lineEdit_3.setText(result['ClassTime'])\n self.lineEdit_4.setText(result['Tno'])\n self.lineEdit_6.setText(result['Date'])","def setup_java_class(content_to_add):\n template = \"\"\"\npublic class Lambda {\n\n public static void main(String args[]) {\n %s\n }\n}\n \"\"\"\n return template % content_to_add","def set_key_class(self, key_class):\r\n self.key_class = key_class","def full_classname(cls: type) -> str:\n return ClassImporter.full_classname(cls)","def create_class(name, attr_defs):\r\n meta = {'metaclass': Class }\r\n def update(clsdic):\r\n for att, val in attr_defs.items():\r\n clsdic[att] = val\r\n return types.new_class(name, kwds=meta, exec_body=update)","def test_add_nested_class(self):\n test_node = class_dependency.JavaClass(self.TEST_PKG, self.TEST_CLS)\n test_node.add_nested_class(self.UNIQUE_KEY_1)\n self.assertEqual(test_node.nested_classes, {self.UNIQUE_KEY_1})","def setup_class(cls):\n super().setup_class()\n cls.add_item(\"skill\", str(cls.GENERIC_SELLER.public_id), local=False)","def new(class_name:str, label:int,\n is_fixed_shape:bool=False, data_shape:tuple=()):\n\n if DG_ClassWrapper.does_class_exist(class_name, label):\n return None\n\n new_class = DG_ClassWrapper.DG_Class(class_name, label, data_size, is_fixed_size)\n\n DG_ClassWrapper.class_list.append(new_class)\n return new_class","def networkClassCreator(className,*args):\n\n print 'In networkClassCreator: ',args\n return WorldManipulationEvent(['create',className,args])","def class_names(self):\n raise NotImplementedError","def do_create(self, arg):\n\n args = shlex.split(arg)\n if len(args) == 0:\n print(\"** class name missing **\")\n\n elif args[0] in models.classes:\n new_instance = models.classes[args[0]]()\n print(new_instance.id)\n \"\"\"saves it (to the JSON file) \"\"\"\n models.storage.save()\n\n else:\n print(\"** class doesn't exist **\")","def __init__(self):\n self.label = \"Change Field Name\"\n self.alias = \"Field name\"\n\n # List of tool classes associated with this toolbox\n self.tools = [FieldName]"],"string":"[\n \"def setClassName(self,whichDir):\\n self.className = whichDir\\n self.setClassMap({whichDir : 1})\",\n \"def addClassRef(clazz):\\n\\n global h_classes\\n header = \\\"class %s;\\\" % clazz\\n if not header in h_classes:\\n h_classes.append(header)\",\n \"def add_class(self, name):\\n if name is not None and not self.has_class(name):\\n self._cached_class.append(name)\\n self._update_class()\",\n \"def add_class(self, period_num, class_name):\\n self._classes[period_num] = class_name\",\n \"def save_class(self, a, class_name):\\n logging.debug(\\\"in save class \\\" + class_name)\\n self.produce(\\\"class_name\\\", class_name)\\n self.classes.append(class_name)\\n self.begin('')\",\n \"def add_class(self, new_class):\\n index = self._counter\\n self._counter += 1\\n for element in new_class:\\n self._class_names[element] = index\\n node = self.part[index].append(element)\\n self._place[element] = node\",\n \"def add_class(self, cls):\\n self.commands.append(cls)\",\n \"def add_class(self, klass):\\n if not issubclass(klass, DataClayObject):\\n raise DataClayException(\\\"Can only use DataClayObject classes\\\")\\n\\n logger.debug(\\\"Adding class %s to the MetaClassFactory\\\", klass)\\n class_container = klass._prepare_metaclass(self._namespace, self._responsible_account)\\n\\n # Save to the list, and bookmark the MetaClass\\n # (for valid recursive behaviour, e.g. cycles)\\n complete_name = class_container.name\\n logger.debug(\\\"[add_class] Using `%s` as `name` field of Type\\\", complete_name)\\n if complete_name not in self.types:\\n self.types[complete_name] = UserType(\\n signature=\\\"L{};\\\".format(complete_name).replace(\\\".\\\", \\\"/\\\"),\\n includes=[],\\n namespace=self._namespace,\\n typeName=complete_name,\\n )\\n self.classes.append(class_container)\\n\\n parent = klass.__bases__[0]\\n if parent is not DataClayObject:\\n self.add_class(parent)\\n\\n logger.debug(\\\"Class %s finished\\\", class_container.name)\",\n \"def update_css_class(kwargs, class_name):\\n if \\\"className\\\" in kwargs:\\n kwargs[\\\"className\\\"] += f\\\" {class_name}\\\"\\n else:\\n kwargs[\\\"className\\\"] = class_name\",\n \"def add_class_to_ont(self, ID):\\n self.ont.addClass(ID)\\n self.ont.label(ID, self.label)\\n self.ont.annotation(ID, 'IAO_0000115', self.definition)\\n if 'equivalentTo' in self.pattern:\\n self.ont.equivalentClasses(ID, self.equivalentTo)\\n if 'subClassOf' in self.pattern:\\n self.ont.subClassOf(ID, self.subClassOf)\\n # Don't currently have means to generate GCIs!\",\n \"def new_class(self, grp, name, class_type=\\\"NXcollection\\\"):\\n sub = grp.require_group(name)\\n sub.attrs[\\\"NX_class\\\"] = numpy.string_(class_type)\\n return sub\",\n \"def set_name(self, name):\\n self.class_name = name\",\n \"def write_class_name(annotation_file_path, class_name):\\n root = etree.parse(annotation_file_path)\\n objects = root.findall('object')\\n \\n for item in objects:\\n name = item.find('name')\\n name.text = class_name\\n\\n root.write(annotation_file_path, pretty_print=True)\",\n \"def add_sclass(self, w: Wrapper, prop: Any) -> None:\\n if not prop:\\n return\\n props = self.sclasses(w)\\n if isinstance(prop, str):\\n props.append(prop)\\n else:\\n props.extend(prop)\\n self.set_sclasses(w, props)\",\n \"def __set_name__(self, cls, name):\\n pass\",\n \"def register_class(self, cls, *, name=None):\\n cls_name = self.host.cache_class(cls, name)\\n self.register_constant(cls, cls_name)\",\n \"def _add_class_to_map(self, model_key, class_dict):\\n # Extract the class name.\\n class_name = class_dict['class']\\n\\n try:\\n # Attempt to access this class by name in the map.\\n self.model_map['class'][class_name]\\n except KeyError:\\n # Class object does not exist. Map it.\\n self.model_map['class'][class_name] = [model_key, class_dict]\\n else:\\n # This class name already exists, which will lead to\\n # duplicates and failure.\\n raise ItemExistsError('Class {} already exists in the map.'\\n .format(class_name))\",\n \"def CSSClasses(self):\",\n \"def process_class(self, parent, cls):\\n if cls.typemap.flat_name in self.class_map:\\n raise RuntimeError(\\\"process_class: class {} already exists in class_map\\\"\\n .format(cls.typemap.flat_name))\\n self.class_map[cls.typemap.flat_name] = cls\\n for var in cls.variables:\\n self.add_var_getter_setter(parent, cls, var)\\n cls.functions = self.define_function_suffix(cls.functions)\",\n \"def visit_class(self, flags, scope, token, parent):\\r\\n\\r\\n # define the class name in the current scope\\r\\n # see visit_block\\r\\n #scope.define(SC_FUNCTION, token.children[0])\\r\\n scope.defer(token)\",\n \"def contribute_to_class(self, cls, name):\\n\\n super(StdImageField, self).contribute_to_class(cls, name)\\n signals.post_save.connect(self._rename_resize_image, sender=cls)\\n signals.post_init.connect(self.set_variations, sender=cls)\",\n \"def class_name(name: str) -> str:\\n return text.pascal_case(utils.safe_snake(name, \\\"type\\\"))\",\n \"def add_to_class(cls, name, value):\\n if hasattr(value, 'contribute_to_class'):\\n value.contribute_to_class(cls, name)\\n if not name.startswith('_'):\\n cls._fields[name] = value\\n else:\\n setattr(cls, name, value)\",\n \"def __create_classname(self, fullname):\\n return PACKAGE_NAME + \\\".\\\" + fullname\",\n \"def set_class_list(self, L):\\n\\t\\tself.class_list = L\",\n \"def declare_class_property(self, name):\\n\\n self.objc_class.forced_properties.add(name)\",\n \"def add_class_to_widget(widget, *css_classes):\\n css_string = \\\" \\\".join(css_classes)\\n if 'class' in widget.attrs:\\n widget.attrs['class'] += ' {} '.format(css_string)\\n else:\\n widget.attrs['class'] = css_string\",\n \"def bind_class(self, className, sequence=None, func=None, add=None):\\n return super().bind_class(className, sequence, func, add)\",\n \"def register(cls, class_):\\n cls._registered[class_.tag()] = class_\",\n \"def setup_class(klass):\",\n \"def setup_class(klass):\",\n \"def register_node_type_from_module(self, modname, classname):\\n nodelist.register_node_type_from_module(modname, classname)\",\n \"def prepare_classnames(self, start=None, add=None, exclude=None):\\n classnames = start or []\\n classnames.extend(add or [])\\n return self.finalise_classname(classnames, exclude or [])\",\n \"def process_class_list(self, module, classes):\",\n \"def _create_class(self, name, superclass):\\n template = self._fill_template(name, superclass)\\n directory = (\\\"controllers\\\" if self.type == \\\"controller\\\" else\\n self.type.capitalize())\\n\\n path = self.module.path + os.sep + directory + os.sep\\n # Check if the class name contains underscores. If it does, interpret\\n # them as directory separators.\\n if not name.find(\\\"_\\\") == -1:\\n substrings = name.split(\\\"_\\\")\\n path += os.path.join(*substrings[:-1]) + os.sep\\n try:\\n os.makedirs(path)\\n except OSError:\\n pass # The directories already exist\\n name = substrings[-1]\\n dest = path + name + \\\".php\\\"\\n if not os.path.isfile(dest):\\n dest = open(dest, \\\"w\\\")\\n dest.write(template)\\n dest.close()\\n else:\\n raise OSError(\\\"File exists: \\\" + dest)\",\n \"def _class(self, _class):\\n\\n self.__class = _class\",\n \"def _class(self, _class):\\n\\n self.__class = _class\",\n \"def add_parameter(self, param_type, param_name, this_class_name=''):\\n self._set_instance_data('parameters',\\n ' '.join([self.add_dependency(param_type, this_class_name),\\n param_name]))\",\n \"def create_class(self):\\n temp_class = self.temp('separated.class')\\n return temp_class.format(**self.__dict__)\",\n \"def create(self, class_name, default_version, description):\\n\\n body = {'class_name': class_name, 'default_version': default_version}\\n if description is not None:\\n body['description'] = description\\n response = self.client.post(Classes.PATH_CLASSES, body=body)\\n return response\",\n \"def update_class(self, class_info):\\n SchemaValidator(self.schema_extension_only, self.schema_nx).validate_class_schema(class_info)\\n self.schema[\\\"@graph\\\"].append(class_info)\\n self.load_schema(self.schema)\\n print(\\\"Updated the class {} successfully!\\\".format(class_info[\\\"rdfs:label\\\"]))\",\n \"def insert_class(self, user_label: str) -> None:\\n logger.debug(\\\"Adds \\\\\\\"{}\\\\\\\" to the user label class\\\", user_label)\\n\\n if self.cluster_k == -1:\\n logger.debug(\\\"Clustering is disabled. Hence, just added to the list in set-semantic (current length: {})\\\",\\n len(self.classes))\\n final_label_tokens = self.convert_label(user_label=user_label)\\n if final_label_tokens not in self.classes:\\n self.classes.append(final_label_tokens)\\n else:\\n logger.debug(\\\"\\\\\\\"{}\\\\\\\" was already in the list!\\\", \\\" \\\".join(final_label_tokens))\",\n \"def setup_class(self):\\n pass\",\n \"def register(self, klass):\\n if klass not in self.extensions:\\n self.extensions.append(klass)\",\n \"def add_obj_class(self, new_obj_class: ObjClass) -> ProjectMeta:\\n return self.add_obj_classes([new_obj_class])\",\n \"def registerFileType(self, extensions, classname):\\r\\n\\r\\n # keep track of all reader classes\\r\\n self._all_readers.append(classname)\\r\\n\\r\\n # iterate over all extensions\\r\\n for e in extensions:\\r\\n e_lower = e.lower()\\r\\n if e_lower not in self._extension_map:\\r\\n self._extension_map[e_lower] = []\\r\\n\\r\\n self._extension_map[e_lower].append(\\r\\n (extensions[e] + ' file', classname))\",\n \"def add_to(class_reference, **attr_dict): \\n _entry=class_reference()\\n for _key in attr_dict:\\n _entry.__dict__['_'+_key] = attr_dict[_key]\\n _entry.put()\\n return str(_entry.key())\",\n \"def __init__(self):\\n self.classes = {}\",\n \"def register(cls, instance_class: Type, name: str = None):\\n if name is None:\\n name = instance_class.__name__\\n if logger.isEnabledFor(logging.DEBUG):\\n logger.debug(f'registering: {instance_class} for {cls} -> {name}')\\n cls.INSTANCE_CLASSES[name] = instance_class\",\n \"def visit_ClassDef(self, node):\\n if node in self.manager.found_classes:\\n return\\n\\n self.manager.found_classes.add(node)\\n self.manager.found[\\\"classes\\\"].append({\\\"name\\\":node.name,\\n \\\"lineno\\\":node.lineno,\\n \\\"namespace\\\":\\\".\\\".join(self.parent)})\\n\\n # Keep checking all nodes in this class.\\n for my_node in node.body:\\n self.manager._explorer(self.manager, self.parent + [node.name]).visit(my_node)\",\n \"def addType(self, name):\\n setattr(self, name, name)\\n self._type_names[name] = name\\n if name in self._pending_type_names:\\n del self._pending_type_names[name]\",\n \"def register_class(self, instance, name=None):\\n prefix_name = name or instance.__class__.__name__\\n\\n for e in dir(instance):\\n if e[0][0] != \\\"_\\\":\\n self.register_function(\\n getattr(instance, e),\\n name=\\\"%s.%s\\\" % (prefix_name, e)\\n )\",\n \"def after_class_creation(cls):\\n pass\",\n \"def classname(cls):\\n return cls.__name__.lower()\",\n \"def _get_classname(cls):\\n return cls.__name__\",\n \"def __init__(self, name: str = 'ret_val') -> None:\\n self.name = name\\n self.class_name = \\\"\\\"\",\n \"def insert_class_markers(soup):\\r\\n\\r\\n # look for class name in a div like <div class=\\\"title\\\">Namespace::MyClass Class Reference</div>\\r\\n title_div = soup.find(\\\"div\\\", \\\"title\\\")\\r\\n if not title_div:\\r\\n raise ValueError(\\\"The following div was not found : <div class='title'>...<div>\\\")\\r\\n\\r\\n # titlediv.get_text() --> \\\"Namespace::MyClass Class Reference\\\"\\r\\n fullclassname = title_div.get_text().split()[0]\\r\\n classname = fullclassname.split(\\\"::\\\")[-1]\\r\\n\\r\\n # look for the contents div\\r\\n contents_div = soup.find( \\\"div\\\", \\\"contents\\\" )\\r\\n if not contents_div:\\r\\n raise ValueError(\\\"The following div was not found : <div class='contents'>...<div>\\\")\\r\\n \\r\\n # insert Qt Creator markers around the brief paragraph\\r\\n brief_p = contents_div.p\\r\\n brief_p.insert_before(class_brief_start(classname))\\r\\n brief_p.insert_after(class_brief_end(classname))\",\n \"def deploy_class( self, target, type_name, fti ):\\n write = self.stream.write\\n tptypes = getToolByName( target, 'portal_types', None )\\n\\n if tptypes is None:\\n write( 'No portal_skins' )\\n elif not tptypes.getTypeInfo( type_name ):\\n tptypes.addType( type_name, fti[0] )\\n write( 'Added type object for %s \\\\n' % type_name )\\n else:\\n write( 'Skipping type object for %s (already exists) \\\\n' % type_name )\",\n \"def find_class(self, class_name: str) -> Type:\\n pass\",\n \"def changeClass(self, newClass):\\n\\t\\turl = \\\"https://habitica.com/api/v3/user/change-class?class=\\\" + newClass\\n\\t\\treturn(postUrl(url, self.credentials))\",\n \"def apiresponse(classname):\\n APIRESPONSE[classname.name] = classname\\n return classname\",\n \"def register_classname(self, classname, package, pxd_base, cpppxd_base,\\n cpp_classname=None, make_dtypes=True):\\n # target classname\\n baseclassname = classname\\n if isinstance(classname, basestring):\\n template_args = None\\n templateclassname = baseclassname\\n templatefuncname = baseclassname.lower()\\n else:\\n template_args = ['T{0}'.format(i) for i in range(len(classname)-2)]\\n template_args = tuple(template_args)\\n while not isinstance(baseclassname, basestring):\\n baseclassname = baseclassname[0] # hack version of ts.basename()\\n templateclassname = baseclassname\\n templateclassname = templateclassname + \\\\\\n ''.join([\\\"{\\\"+targ+\\\"}\\\" for targ in template_args])\\n templatefuncname = baseclassname.lower() + '_' + \\\\\\n '_'.join([\\\"{\\\"+targ+\\\"}\\\" for targ in template_args])\\n\\n # source classname\\n if cpp_classname is None:\\n cpp_classname = classname\\n cpp_baseclassname = cpp_classname\\n if not isinstance(cpp_classname, basestring):\\n while not isinstance(cpp_baseclassname, basestring):\\n cpp_baseclassname = cpp_baseclassname[0]\\n if template_args is None:\\n template_args = ['T{0}'.format(i) for i in range(len(cpp_classname)-2)]\\n template_args = tuple(template_args)\\n\\n # register regular class\\n class_c2py = ( # '{t.cython_pytype}({var})',\\n ('{proxy_name} = {t.cython_pytype}()\\\\n'\\n '(<{t.cython_ctype_nopred} *> {proxy_name}._inst)[0] = {var}'),\\n ('{proxy_name} = {t.cython_pytype}()\\\\n'\\n '(<{t.cython_ctype_nopred} *> {proxy_name}._inst)[0] = {var}'),\\n ('if {cache_name} is None:\\\\n'\\n ' {proxy_name} = {t.cython_pytype}()\\\\n'\\n ' {proxy_name}._free_inst = False\\\\n'\\n ' {proxy_name}._inst = &{var}\\\\n'\\n ' {cache_name} = {proxy_name}\\\\n')\\n )\\n class_py2c = ('{proxy_name} = <{t.cython_cytype_nopred}> {var}',\\n '(<{t.cython_ctype_nopred} *> {proxy_name}._inst)[0]')\\n class_cimport = ((package, cpppxd_base),)\\n kwclass = dict(\\n name=baseclassname, # FCComp\\n template_args=template_args,\\n cython_c_type=cpppxd_base + '.' + cpp_baseclassname, # cpp_fccomp.FCComp\\n cython_cimport=class_cimport,\\n cython_cy_type=pxd_base + '.' + baseclassname, # fccomp.FCComp\\n cython_py_type=pxd_base + '.' + baseclassname, # fccomp.FCComp\\n from_pytype=[pxd_base + '.' + baseclassname], # fccomp.FCComp\\n cpp_type=cpp_baseclassname,\\n human_name=templateclassname,\\n cython_template_class_name=templateclassname,\\n cython_template_function_name=templatefuncname,\\n cython_cyimport=((pxd_base,),), # fccomp\\n cython_pyimport=((pxd_base,),), # fccomp\\n cython_c2py=class_c2py,\\n cython_py2c=class_py2c,\\n )\\n self.register_class(**kwclass)\\n canonname = classname if isinstance(classname, basestring) \\\\\\n else self.canon(classname)\\n if template_args is not None:\\n specname = classname if isinstance(classname, basestring) \\\\\\n else self.cython_classname(classname)[1]\\n kwclassspec = dict(\\n name=classname,\\n cython_c_type=cpppxd_base + '.' + specname,\\n cython_cy_type=pxd_base + '.' + specname,\\n cython_py_type=pxd_base + '.' + specname,\\n cpp_type=self.cpp_type(cpp_classname),\\n )\\n self.register_class(**kwclassspec)\\n kwclassspec['name'] = canonname\\n self.register_class(**kwclassspec)\\n kwclassspec['name'] = self.canon(cpp_classname)\\n self.register_class(**kwclassspec)\\n # register numpy type\\n if make_dtypes:\\n self.register_numpy_dtype(classname,\\n cython_cimport=class_cimport,\\n cython_cyimport=pxd_base,\\n cython_pyimport=pxd_base,\\n )\\n # register vector\\n class_vector_py2c = ((\\n '# {var} is a {t.type}\\\\n'\\n 'cdef int i{var}\\\\n'\\n 'cdef int {var}_size\\\\n'\\n 'cdef {t.cython_npctypes[0]} * {var}_data\\\\n'\\n '{var}_size = len({var})\\\\n'\\n 'if isinstance({var}, np.ndarray) and (<np.ndarray> {var}).descr.type_num == {t.cython_nptype}:\\\\n'\\n ' {var}_data = <{t.cython_npctypes[0]} *> np.PyArray_DATA(<np.ndarray> {var})\\\\n'\\n ' {proxy_name} = {t.cython_ctype_nopred}(<size_t> {var}_size)\\\\n'\\n ' for i{var} in range({var}_size):\\\\n'\\n ' {proxy_name}[i{var}] = {var}_data[i{var}]\\\\n'\\n 'else:\\\\n'\\n ' {proxy_name} = {t.cython_ctype_nopred}(<size_t> {var}_size)\\\\n'\\n ' for i{var} in range({var}_size):\\\\n'\\n ' {proxy_name}[i{var}] = (<{t.cython_npctypes_nopred[0]} *> (<{t.cython_npcytypes_nopred[0]}> {var}[i{var}])._inst)[0]\\\\n'),\\n '{proxy_name}')\\n self.register_class(('vector', canonname, 0), cython_py2c=class_vector_py2c)\\n self.register_class(('vector', classname, 0), cython_py2c=class_vector_py2c)\\n self.register_class((('vector', canonname, 0), '&'), cython_py2c=class_vector_py2c)\\n self.register_class((('vector', classname, 0), '&'), cython_py2c=class_vector_py2c)\\n self.register_class(((('vector', canonname, 0), 'const'), '&'), cython_py2c=class_vector_py2c)\\n self.register_class(((('vector', classname, 0), 'const'), '&'), cython_py2c=class_vector_py2c)\\n # register pointer to class\\n class_ptr_c2py = ('{t.cython_pytype}({var})',\\n ('cdef {t.cython_pytype} {proxy_name} = {t.cython_pytype}()\\\\n'\\n 'if {proxy_name}._free_inst:\\\\n'\\n ' free({proxy_name}._inst)\\\\n'\\n '(<{t.cython_ctype}> {proxy_name}._inst) = {var}'),\\n ('if {cache_name} is None:\\\\n'\\n ' {proxy_name} = {t.cython_pytype}()\\\\n'\\n ' {proxy_name}._free_inst = False\\\\n'\\n ' {proxy_name}._inst = {var}\\\\n'\\n ' {cache_name} = {proxy_name}\\\\n')\\n )\\n class_ptr_py2c = ('{proxy_name} = <{t.cython_cytype_nopred}> {var}',\\n '(<{t.cython_ctype_nopred} *> {proxy_name}._inst)')\\n kwclassptr = dict(\\n name=(classname, '*'),\\n template_args=template_args,\\n cython_py_type=pxd_base + '.' + baseclassname,\\n cython_cy_type=pxd_base + '.' + baseclassname,\\n cpp_type=cpp_baseclassname,\\n cython_c2py=class_ptr_c2py,\\n cython_py2c=class_ptr_py2c,\\n cython_cimport=kwclass['cython_cimport'] ,\\n cython_cyimport=kwclass['cython_cyimport'] + (('libc.stdlib','free'),),\\n cython_pyimport=kwclass['cython_pyimport'],\\n )\\n self.register_class(**kwclassptr)\\n kwclassref = dict(kwclassptr)\\n # Register reference to class\\n kwclassref['name'] = (classname, '&')\\n kwclassref['cython_c2py'] = class_c2py\\n kwclassref['cython_py2c'] = class_py2c\\n #ts.register_class(**kwclassref)\\n # register doublepointer to class\\n class_dblptr_c2py = ('{t.cython_pytype}({var})',\\n ('{proxy_name} = {proxy_name}_obj._inst\\\\n'\\n '(<{t.cython_ctype} *> {proxy_name}._inst) = {var}'),\\n ('if {cache_name} is None:\\\\n'\\n ' {proxy_name} = {t.cython_pytype}()\\\\n'\\n ' {proxy_name}._free_inst = False\\\\n'\\n ' {proxy_name}._inst = {var}\\\\n'\\n ' {proxy_name}_list = [{proxy_name}]\\\\n'\\n ' {cache_name} = {proxy_name}_list\\\\n')\\n )\\n class_dblptr_py2c = ('{proxy_name} = <{t.cython_cytype_nopred}> {var}[0]',\\n '(<{t.cython_ctype_nopred} **> {proxy_name}._inst)')\\n kwclassdblptr = dict(\\n name=((classname, '*'), '*'),\\n template_args=template_args,\\n cython_c2py=class_dblptr_c2py,\\n cython_py2c=class_dblptr_py2c,\\n cython_cimport=kwclass['cython_cimport'],\\n cython_cyimport=kwclass['cython_cyimport'],\\n cython_pyimport=kwclass['cython_pyimport'],\\n )\\n self.register_class(**kwclassdblptr)\",\n \"def do_create(self, line):\\n if line:\\n if line in HBNBCommand.classes:\\n class_to_ins = HBNBCommand.classes.get(line)\\n new_instance = class_to_ins()\\n new_instance.save()\\n print(new_instance.id)\\n else:\\n print(\\\"** class name missing **\\\")\\n else:\\n print(\\\"** class doesn't exist **\\\")\",\n \"def add_etl_class(self, etl_class):\\n\\n if etl_class.identifier in self.etl_classes:\\n raise DuplicateConfigException(\\n \\\"Builder already has etl_class with identifier : {}\\\".format(\\n etl_class.identifier\\n )\\n )\\n\\n self.etl_classes[etl_class.identifier] = etl_class\",\n \"def add_attribute(a_class, name, value):\\n types = ['str', [], {}, (1, 1), 1.1, 1, None]\\n for item in types:\\n if type(a_class) == type(item):\\n raise TypeError(\\\"can't add new attribute\\\")\\n a_class.name = value\",\n \"def register_class(obj):\\r\\n try:\\r\\n KnownClass.objects.get(module_name=obj.__module__, class_name=obj.__class__.__name__)\\r\\n except DoesNotExist:\\r\\n # Create it\\r\\n KnownClass(module_name = obj.__module__, class_name = obj.__class__.__name__).save()\",\n \"def do_create(self, arg):\\n args = arg.split()\\n if len(args) == 0:\\n print(\\\"** class name missing **\\\")\\n return\\n if args[0] in self.class_dict:\\n new = self.class_dict.get(args[0])()\\n storage.save()\\n print(new.id)\\n else:\\n print(\\\"** class doesn't exist **\\\")\",\n \"def set_route_class_to_add_destination(self, route_class):\\n self.multiple_items_selection_from_kendo_dropdown(self.route_class_multiple_kendo_dropdown_locator, route_class)\\n self.click_element(self.new_destination_header_locator)\",\n \"def set_bucket_class(self, bucket_class):\\r\\n self.bucket_class = bucket_class\",\n \"def classnamefilter(self, name):\\n return False\",\n \"def classnamefilter(self, name):\\n return False\",\n \"def classes(self):\\n if self.classname:\\n return [self.classname]\\n return []\",\n \"def set_sclasses(self, w: Wrapper, classes: Any) -> None:\\n w.setProperty(self.style_sclass_property, f\\\" {' '.join(set(classes))} \\\")\",\n \"def class_name(self) -> str:\\n return pulumi.get(self, \\\"class_name\\\")\",\n \"def addRegexClass(self, label, regex, userdist=3):\\n self._call_java('addRegexClass', label, regex, userdist)\\n return self\",\n \"def html_class(self):\\n try:\\n html_class = [\\n 'plugin-{0} {1}'.format(\\n self.uid, ' '.join(self.html_classes)\\n )\\n ]\\n return ' '.join(html_class)\\n except Exception as err:\\n logger.debug(\\n \\\"Error in class %s. Details: %s\\\",\\n self.__class__.__name__,\\n str(err)\\n )\",\n \"def do_create(self, class_name):\\n\\n if not class_name:\\n print(\\\"** class name missing **\\\")\\n elif class_name not in HBNBCommand.class_list:\\n print(\\\"** class doesn't exist **\\\")\\n else:\\n new_object = eval(class_name + \\\"()\\\")\\n new_object.save()\\n print(new_object.id)\",\n \"def setup_class(cls):\",\n \"def setup_class(cls):\",\n \"def get_class(self, name):\\n raise NotImplementedError\",\n \"def get_classname(self):\\n return 'ImageFilm'\",\n \"def compile_class(self):\\n\\t\\t\\n\\t\\txml = '<class>\\\\n' + self.tokenizer.keyword() + self.tokenizer.identifier() + self.tokenizer.symbol()\\n\\n\\t\\tself.outfile.write(xml)\",\n \"def create_class_from_strings( self, module_name, class_name):\\r\\n if not( self.logger is None ):\\r\\n self.logger.debug( \\\"create class {module_name} {class_name}\\\" )\\r\\n\\r\\n# print( \\\"create class \\\" + module_name + \\\" \\\" + class_name )\\r\\n\\r\\n a_class = getattr( importlib.import_module(module_name), class_name )\\r\\n instance = a_class( )\\r\\n return instance\",\n \"def add_train_file(self, classname: str, filename: str, handler: int = 0) -> int:\\n return self.get_func(\\\"DC_AddTrainFile\\\", [c_char_p, c_char_p, POINTER(c_int)], c_int)(\\n classname, filename, handler)\",\n \"def register_class(self, entity_class):\\n key = entity_class.__collection_name__\\n\\n if key not in self._registered_types:\\n self._registered_types[key] = entity_class\",\n \"def parameterize_class_name(cls: Type, idx: int, input_dicts: Mapping[Any, Any]):\\n suffix = \\\"_\\\".join(f\\\"{k}_{v}\\\" for k, v in input_dicts.items())\\n return f\\\"{cls.__name__}_{suffix}\\\"\",\n \"def register_class(cls):\\n if cls is RegisteredType:\\n raise \\\"Please do _not_ register RegisteredType!\\\"\\n \\n cid = RegisteredType._reg[autoid]\\n RegisteredType._reg['classes'][cls] = cid\\n RegisteredType._reg['classids'][cid] = cls\\n RegisteredType._reg['autoid'] += 1\",\n \"def make_class(attributes, base_classes=()):\\r\\n \\\"*** YOUR CODE HERE ***\\\"\",\n \"def on_Add_new_class_button_clicked(self):\\n Add_new_class = Shangke_message()\\n Add_new_class.exec_()\\n result = Shangke_message.result\\n # print(result)\\n self.lineEdit.setText(result['Cname'])\\n self.lineEdit_2.setText(result['Sclass'])\\n self.lineEdit_3.setText(result['ClassTime'])\\n self.lineEdit_4.setText(result['Tno'])\\n self.lineEdit_6.setText(result['Date'])\",\n \"def setup_java_class(content_to_add):\\n template = \\\"\\\"\\\"\\npublic class Lambda {\\n\\n public static void main(String args[]) {\\n %s\\n }\\n}\\n \\\"\\\"\\\"\\n return template % content_to_add\",\n \"def set_key_class(self, key_class):\\r\\n self.key_class = key_class\",\n \"def full_classname(cls: type) -> str:\\n return ClassImporter.full_classname(cls)\",\n \"def create_class(name, attr_defs):\\r\\n meta = {'metaclass': Class }\\r\\n def update(clsdic):\\r\\n for att, val in attr_defs.items():\\r\\n clsdic[att] = val\\r\\n return types.new_class(name, kwds=meta, exec_body=update)\",\n \"def test_add_nested_class(self):\\n test_node = class_dependency.JavaClass(self.TEST_PKG, self.TEST_CLS)\\n test_node.add_nested_class(self.UNIQUE_KEY_1)\\n self.assertEqual(test_node.nested_classes, {self.UNIQUE_KEY_1})\",\n \"def setup_class(cls):\\n super().setup_class()\\n cls.add_item(\\\"skill\\\", str(cls.GENERIC_SELLER.public_id), local=False)\",\n \"def new(class_name:str, label:int,\\n is_fixed_shape:bool=False, data_shape:tuple=()):\\n\\n if DG_ClassWrapper.does_class_exist(class_name, label):\\n return None\\n\\n new_class = DG_ClassWrapper.DG_Class(class_name, label, data_size, is_fixed_size)\\n\\n DG_ClassWrapper.class_list.append(new_class)\\n return new_class\",\n \"def networkClassCreator(className,*args):\\n\\n print 'In networkClassCreator: ',args\\n return WorldManipulationEvent(['create',className,args])\",\n \"def class_names(self):\\n raise NotImplementedError\",\n \"def do_create(self, arg):\\n\\n args = shlex.split(arg)\\n if len(args) == 0:\\n print(\\\"** class name missing **\\\")\\n\\n elif args[0] in models.classes:\\n new_instance = models.classes[args[0]]()\\n print(new_instance.id)\\n \\\"\\\"\\\"saves it (to the JSON file) \\\"\\\"\\\"\\n models.storage.save()\\n\\n else:\\n print(\\\"** class doesn't exist **\\\")\",\n \"def __init__(self):\\n self.label = \\\"Change Field Name\\\"\\n self.alias = \\\"Field name\\\"\\n\\n # List of tool classes associated with this toolbox\\n self.tools = [FieldName]\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6673873","0.65873694","0.65540683","0.65310895","0.62807566","0.61844677","0.61496955","0.61109734","0.60883236","0.5851665","0.5794981","0.57527643","0.57015514","0.56917053","0.5677711","0.5670707","0.566091","0.56086993","0.55906165","0.55896807","0.55784124","0.55692834","0.5566955","0.55630785","0.5561454","0.5515173","0.5503372","0.5483222","0.54812634","0.54811925","0.54811925","0.5474807","0.5472592","0.5470586","0.5466878","0.5466126","0.5466126","0.54289246","0.54200566","0.54057896","0.5392547","0.5385013","0.53797156","0.5369056","0.535473","0.5337876","0.5337009","0.5327601","0.53220147","0.531626","0.5311009","0.5305926","0.53040504","0.5285762","0.5270148","0.52667546","0.52255726","0.52248913","0.52167976","0.5215237","0.51940286","0.5190251","0.51750946","0.51750076","0.51749617","0.5159696","0.5155285","0.5143768","0.51436985","0.5143001","0.5143001","0.5142063","0.5129938","0.5128078","0.5119277","0.511717","0.51082367","0.50988746","0.50988746","0.50896966","0.50876224","0.5079167","0.50670874","0.50630397","0.50614303","0.5061028","0.50572926","0.5054012","0.5053659","0.50314873","0.50289285","0.5026541","0.5014909","0.5010115","0.50093615","0.5007863","0.50035906","0.5001975","0.49960822","0.4990552"],"string":"[\n \"0.6673873\",\n \"0.65873694\",\n \"0.65540683\",\n \"0.65310895\",\n \"0.62807566\",\n \"0.61844677\",\n \"0.61496955\",\n \"0.61109734\",\n \"0.60883236\",\n \"0.5851665\",\n \"0.5794981\",\n \"0.57527643\",\n \"0.57015514\",\n \"0.56917053\",\n \"0.5677711\",\n \"0.5670707\",\n \"0.566091\",\n \"0.56086993\",\n \"0.55906165\",\n \"0.55896807\",\n \"0.55784124\",\n \"0.55692834\",\n \"0.5566955\",\n \"0.55630785\",\n \"0.5561454\",\n \"0.5515173\",\n \"0.5503372\",\n \"0.5483222\",\n \"0.54812634\",\n \"0.54811925\",\n \"0.54811925\",\n \"0.5474807\",\n \"0.5472592\",\n \"0.5470586\",\n \"0.5466878\",\n \"0.5466126\",\n \"0.5466126\",\n \"0.54289246\",\n \"0.54200566\",\n \"0.54057896\",\n \"0.5392547\",\n \"0.5385013\",\n \"0.53797156\",\n \"0.5369056\",\n \"0.535473\",\n \"0.5337876\",\n \"0.5337009\",\n \"0.5327601\",\n \"0.53220147\",\n \"0.531626\",\n \"0.5311009\",\n \"0.5305926\",\n \"0.53040504\",\n \"0.5285762\",\n \"0.5270148\",\n \"0.52667546\",\n \"0.52255726\",\n \"0.52248913\",\n \"0.52167976\",\n \"0.5215237\",\n \"0.51940286\",\n \"0.5190251\",\n \"0.51750946\",\n \"0.51750076\",\n \"0.51749617\",\n \"0.5159696\",\n \"0.5155285\",\n \"0.5143768\",\n \"0.51436985\",\n \"0.5143001\",\n \"0.5143001\",\n \"0.5142063\",\n \"0.5129938\",\n \"0.5128078\",\n \"0.5119277\",\n \"0.511717\",\n \"0.51082367\",\n \"0.50988746\",\n \"0.50988746\",\n \"0.50896966\",\n \"0.50876224\",\n \"0.5079167\",\n \"0.50670874\",\n \"0.50630397\",\n \"0.50614303\",\n \"0.5061028\",\n \"0.50572926\",\n \"0.5054012\",\n \"0.5053659\",\n \"0.50314873\",\n \"0.50289285\",\n \"0.5026541\",\n \"0.5014909\",\n \"0.5010115\",\n \"0.50093615\",\n \"0.5007863\",\n \"0.50035906\",\n \"0.5001975\",\n \"0.49960822\",\n \"0.4990552\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.69511896"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":24994,"cells":{"query":{"kind":"string","value":"Process the multi_step filed."},"document":{"kind":"string","value":"def multi_step_field(self, info):\n\n result = list()\n\n for i, v in enumerate(self.parser.split(info)):\n if re.search(r'^\\d+', v):\n result.append(v)\n else:\n result[-1] += ' %s' % v\n\n return result"},"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 do_step(self) -> None:","def process_step(self, request, step, form):\n pass","def _step(self):\n pass","def process_steps(self, df, **kwargs):\n pass","def step(self, **kwargs):\n pass","def _step(self) -> None:","def perform_step(self) -> None:\n pass","def step(self):\n\n pass","def train_loop_post(self, current_step):\r\n pass","def _insertAllSteps(self): \n self.uMics = self.inputCoordinatesTiltedPairs.get().getUntilted().getMicrographs()\n self.tMics = self.inputCoordinatesTiltedPairs.get().getTilted().getMicrographs()\n\n self.inputMics = self._createSetOfParticles('auxMics')\n self.inputMics.copyInfo(self.uMics)\n self.inputMics.setStore(False)\n \n for micU, micT in izip(self.uMics, self.tMics):\n micU.cleanObjId()\n micT.cleanObjId()\n self.inputMics.append(micU)\n self.inputMics.append(micT)\n\n self.samplingInput = self.uMics.getSamplingRate()\n \n\n if self.downsampleType.get() != OTHER:\n # If 'same as picking' or 'original' get sampling rate from input micrographs\n #TODO: Review this when downsampling before picking is possible\n self.samplingFinal = self.samplingInput\n else:\n # If 'other' multiply the input sampling rate by the factor provided\n self.samplingFinal = self.samplingInput*self.downFactor.get()\n \n # Write pos files for each micrograph\n firstStepId = self._insertFunctionStep('writePosFilesStep')\n \n # For each micrograph insert the steps\n #run in parallel\n \n deps = []\n for mic in self.inputMics:\n localDeps = [firstStepId]\n micrographToExtract = mic.getFileName()\n micName = removeBaseExt(mic.getFileName())\n micId = mic.getObjId()\n\n # If downsample type is 'other' perform a downsample\n if self.downsampleType == OTHER:\n fnDownsampled = self._getTmpPath(micName+\"_downsampled.xmp\")\n downFactor = self.downFactor.get()\n args = \"-i %(micrographToExtract)s -o %(fnDownsampled)s --step %(downFactor)f --method fourier\"\n localDeps=[self._insertRunJobStep(\"xmipp_transform_downsample\", args % locals(),prerequisites=localDeps)]\n micrographToExtract = fnDownsampled\n \n # If remove dust \n if self.doRemoveDust:\n fnNoDust = self._getTmpPath(micName+\"_noDust.xmp\")\n \n thresholdDust = self.thresholdDust.get() #TODO: remove this extra variable\n args=\" -i %(micrographToExtract)s -o %(fnNoDust)s --bad_pixels outliers %(thresholdDust)f\"\n localDeps=[self._insertRunJobStep(\"xmipp_transform_filter\", args % locals(),prerequisites=localDeps)]\n micrographToExtract = fnNoDust\n \n #self._insertFunctionStep('getCTF', micId, micName, micrographToExtract)\n micName = removeBaseExt(mic.getFileName())\n \n # Actually extract\n deps.append(self._insertFunctionStep('extractParticlesStep', micId, micName, \n None, micrographToExtract, prerequisites=localDeps))\n # TODO: Delete temporary files\n \n # Insert step to create output objects \n self._insertFunctionStep('createOutputStep', prerequisites=deps)","def process_steps(steplist, build, buildslave, build_status, basedir):\n for step in steplist:\n step.setBuild(build)\n step.setBuildSlave(buildslave)\n step.setStepStatus(build_status.addStepWithName(step.name))\n step.setDefaultWorkdir(os.path.join(basedir, 'build'))\n step.workdir = os.path.join(basedir, 'build')","def step(self, step=None):\n pass","def step(self):\n curr_step = self.steplist[self.curr_step_idx] #dictionary\n insn_type = curr_step[\"type\"]\n\n #case over insn_types\n if insn_type == \"init\":\n self.exec_init(curr_step)\n self.curr_step_idx += 1\n\n elif insn_type == \"preprocess\":\n self.exec_preprocess(curr_step)\n self.curr_step_idx += 1\n\n elif insn_type == \"augment\":\n self.exec_augment(curr_step)\n self.curr_step_idx += 1\n \n elif insn_type ==\"combine\":\n self.exec_combine(curr_step)\n self.curr_step_idx += 1\n\n elif insn_type ==\"attention\":\n self.exec_attention(curr_step)\n self.curr_step_idx += 1","def step(self):\n raise NotImplementedError","def step(self):\n self.function()","def step(self):\r\n raise NotImplementedError","def processInputs(self):","def step(self, model):\n pass","def step(self, model):\n pass","def on_eval_batch_begin(self, step, logs=None):","def getSteps():","def step(self, action):","def run(self):\n\n step = self.steps['diagnostics_files']\n step.cores = self.config.getint('make_diagnostics_files', 'cores')\n\n # run the step\n super().run()","def step_impl(context):\n pass","def step_impl(context):\n pass","def _main(self):\n\n i = 0\n\n for i, step in enumerate(self._run_list):\n return_code = self._check_step_completed(i)\n\n if return_code == 0:\n logger.debug('Successful: \"{}\".'.format(list(step.keys())[0]))\n else:\n return_code = 1\n self._submit_step(i)\n\n # do not enter while loop for continuous monitoring\n if not self.monitor:\n break\n\n time.sleep(1)\n while return_code == 1 and self.monitor:\n time.sleep(5)\n return_code = self._check_step_completed(i)\n\n if return_code == 2:\n module, f_config = self._get_command_config(i)\n raise ExecutionError('Pipeline failed at step '\n '{} \"{}\" {}'\n .format(i, module, f_config))\n\n if i + 1 == len(self._run_list) and return_code == 0:\n logger.info('Pipeline job \"{}\" is complete.'\n .format(self._config.name))\n logger.debug('Output directory is: \"{}\"'\n .format(self._config.dirout))","def build_step(self):\n pass","def build_step(self):\n pass","def step(self):\n raise NotImplementedError()","def step(self):\n raise NotImplementedError()","def step(self):\n raise NotImplementedError()","async def on_step(self, iteration: int):\n raise NotImplementedError","def build_step(self):\n\n pass","def process():","def step(self):\n #1. Time progresses\n self.time_operator.step()\n \n #2. Form and dissolve relationships\"\n self.relationship_operator.step()\n\n #3. HIV transmission\n self.infection_operator.step()","def process_step(self, observation, reward, done, info):\n observation = self.process_observation(observation)\n reward = self.process_reward(reward)\n info = self.process_info(info)\n return observation, reward, done, info","def process(self):\n pass","def process(self):","def process(self):","def process(self):","def eval_step(self, *args, **kwargs):\n raise NotImplementedError","def run_step(self):\n self.control_instance.run_step()","def step(self, state):","def perform_step(self, action):\n pass","def step_async(self, actions):","def postprocess_step(self, t, y):\n pass","def exec_preprocess(self, curr_step):\n assert(self.curr_step_idx > 0 and self.dlist is not None), \"Step Error: Must call init before preprocess\" \n\n #verify raw data & dlist\n self.B_VER(self.sess_path, self.dlist)\n\n #move & preprocess each folder\n funclist = curr_step[\"funclist\"]\n raw_datadir = self.sess_path\n dest_datadir = self.sess_path\n new_dlist = []\n for i, folder in enumerate(self.dlist):\n flist = funclist[i]\n new_folder = self.data_utils.MOVE(raw_datadir, folder, dest_datadir, flist=flist, preview=False)\n new_dlist.append(new_folder)\n self.dlist = new_dlist\n self.default_vis(curr_step)","def on_eval_batch_end(self, step, logs=None):","def step(self, closure=None):\n for group in self.param_groups:\n for p in group['params']:\n if p.grad is None:\n continue\n # Want to update step by workers sharing shared_step?\n # There are two different, step and steps\n self.state[p]['steps'] = self.state[p]['shared_step'].item()\n self.state[p]['shared_step'] += 1\n # But does the below not override steps?\n # -> No, because Adam step updates step, not step\"s\"\n super().step(closure)","def step(self):\n while self.state != STATE_TERMINAL:\n self.step_strategies[self.state]()","def step(self, memories):\n return","def compute_step(self):\n self._apply_controls(step=self.step, post=True)\n self._step += 1\n for gate_layer in self._tebd_propagator.gate_layers:\n self._t_mps.apply_nn_gate_layer(gate_layer)\n self._t_mps.apply_process_tensors(self.step,\n self._process_tensors)\n for gate_layer in self._tebd_propagator.gate_layers:\n self._t_mps.apply_nn_gate_layer(gate_layer)\n self._apply_controls(step=self.step, post=False)\n self._append_results()","def _run_step(self, step, new_log_file):\n logger = self.logger\n config = self.config\n cwd = os.getcwd()\n available_cores, _ = get_available_cores_and_nodes(config)\n step.cores = min(step.cores, available_cores)\n if step.min_cores is not None:\n if step.cores < step.min_cores:\n raise ValueError(\n 'Available cores for {} is below the minimum of {}'\n ''.format(step.cores, step.min_cores))\n\n missing_files = list()\n for input_file in step.inputs:\n if not os.path.exists(input_file):\n missing_files.append(input_file)\n\n if len(missing_files) > 0:\n raise OSError(\n 'input file(s) missing in step {} of {}/{}/{}: {}'.format(\n step.name, step.mpas_core.name, step.test_group.name,\n step.test_case.subdir, missing_files))\n\n test_name = step.path.replace('/', '_')\n if new_log_file:\n log_filename = '{}/{}.log'.format(cwd, step.name)\n step.log_filename = log_filename\n step_logger = None\n else:\n step_logger = logger\n log_filename = None\n with LoggingContext(name=test_name, logger=step_logger,\n log_filename=log_filename) as step_logger:\n step.logger = step_logger\n os.chdir(step.work_dir)\n step.run()\n\n missing_files = list()\n for output_file in step.outputs:\n if not os.path.exists(output_file):\n missing_files.append(output_file)\n\n if len(missing_files) > 0:\n raise OSError(\n 'output file(s) missing in step {} of {}/{}/{}: {}'.format(\n step.name, step.mpas_core.name, step.test_group.name,\n step.test_case.subdir, missing_files))","def _step(self, whence):\n pass","def process(self):\n # Opening and preprocessing of the input file\n if self.options.mbtiles_fromdisk or self.options.mbtiles_todisk:\n if self.options.mbtiles_fromdisk:\n i_parm=10\n if self.options.mbtiles_todisk:\n i_parm=11\n if self.options.verbose:\n print \"GDAL2MbTiles :mbtiles from/to disk [\",i_parm,\"] mbtiles_fromdisk[\",self.options.mbtiles_fromdisk,\"] mbtiles_todisk[\",self.options.mbtiles_todisk,\"]\"\n self.mbtiles_setup(i_parm)\n return\n else:\n if self.options.verbose:\n print \"GDAL2MbTiles :tile creation mbtiles[\",self.options.mbtiles,\"]\"\n self.open_input()\n # Generation of main metadata files and HTML viewers\n self.generate_metadata()\n # Generation of the lowest tiles\n self.generate_base_tiles()\n # Generation of the overview tiles (higher in the pyramid)\n self.generate_overview_tiles()\n # Generating of KML\n self.generate_kml()","def step(self, n, dlist):\n pass","def run_one_step(self):\n pass","def perform_step(self, step, batch):\n\n # perform a min step\n self.__max_step(batch)\n self.__min_step(batch)\n\n l_suff_stats = self.shuffle_up_stats(batch)\n obj = self.main_obj(batch, l_suff_stats)\n constraints = self.main_constraints(batch, l_suff_stats)\n\n self.cli.print(self.fmtstr % (step, obj.detach().numpy(), *[item for sublist in zip(self.lagrange_mults, constraints) for item in sublist]))","def record(self, step):","def step(self, action):\n pass","def step(self, action):\n pass","def next_step(self):\n self.proceed()\n self.execute_current()","def handleChainedProcessingTweak(self):\n self.logger.info(\"Handling chained processing job\")\n\n # check the jobs input files\n inputFile = (\"file:../%s/%s.root\" % (self.step.data.input.inputStepName,\n self.step.data.input.inputOutputModule))\n\n self.tweak.addParameter('process.source.fileNames', \"customTypeCms.untracked.vstring(%s)\" % [inputFile])\n self.tweak.addParameter(\"process.maxEvents\", \"customTypeCms.untracked.PSet(input=cms.untracked.int32(-1))\")\n self.logger.info(\"Chained PSet tweaked with maxEvents: -1, and fileNames: %s\", inputFile)\n return","def run(self):\n with self.get_connection() as conn:\n #self._create_new_batch_and_step_audit(conn)\n \"\"\"Kick off the transformation job.\"\"\"\n if self.run_all_steps:\n self.run_all()\n else:\n self.skipped_steps = []\n self.skipped_tables = []\n step_runner = self.step_lambda_map[self.etl_step]\n step_runner()","def step(self, timestamp=0.0, **keywords):\n self.services.debug('step() method called')\n pass","def postprocess_step(self, t, y):\n return","def getCurrentStep():","def process(self):\n raise NotImplementedError","def step(self):\n raise TaskError(\"Task %s: subclass should override step() method!\" %\n self)","def process_inputs(self, inputs):","def step(self, action):\n raise NotImplementedError","def stepFinished(build, step, results):","def after_step():\n raise NotImplementedError","def perform_mult_steps(self, num_steps, tc, batch_size):\n\n self.sample_v()\n self.cli.empty().print(self.titlestr % (\"k\", \"objective\", *[f\"lm_{i} x constr_{i}\" for i in range(len(self.lagrange_mults))]))\n\n # perform a min step\n for s in range(num_steps):\n batch = tc.sample(batch_size, ['add_act', 'grad_ranking', 'add_pi'])\n self.perform_step(s, batch)","def step(self, d=1):\n raise NotImplementedError()","def _insertAllSteps(self):\n \n # Get pointer to input micrographs \n self.particlePickingRun = self.xmippParticlePicking.get()\n \n copyId = self._insertFunctionStep('copyInputFilesStep')\n # Get micrographs to pick\n #self.inputMicrographs.set(self.getInputMicrographs())\n \n deps = []\n for mic in self.getInputMicrographs():\n stepId = self._insertFunctionStep('autopickMicrographStep', mic.getFileName(), prerequisites=[copyId])\n deps.append(stepId)\n \n self._insertFunctionStep('_createOutput',self._getExtraPath(), prerequisites=deps)","def execute_step(self):\n if self.get_param_value('verbose'):\n j = self.current_step_index\n print(f\"{self.name}, step {j} \"\n f\"({self.routine_template.step_name(index=j)}), executing...\")\n\n self.current_step.run()\n self.current_step.post_run() # optional. Update results for example.\n\n self.routine_steps.append(self.current_step)\n self.current_step_index += 1","def run(self):\r\n try:\r\n self.loader.find_and_load_step_definitions()\r\n except StepLoadingError, e:\r\n print \"Error loading step definitions:\\n\", e\r\n return\r\n\r\n results = []\r\n if self.explicit_features:\r\n features_files = self.explicit_features\r\n else:\r\n features_files = self.loader.find_feature_files()\r\n if self.random:\r\n random.shuffle(features_files)\r\n\r\n if not features_files:\r\n self.output.print_no_features_found(self.loader.base_dir)\r\n return\r\n\r\n processes = Pool(processes=self.parallelization)\r\n test_results_it = processes.imap_unordered(\r\n worker_process, [(self, filename) for filename in features_files]\r\n )\r\n \r\n all_total = ParallelTotalResult()\r\n for result in test_results_it:\r\n all_total += result['total']\r\n sys.stdout.write(result['stdout'])\r\n sys.stderr.write(result['stderr'])\r\n\r\n return all_total","def step_forward(self):","def step(self):\n value = self.current_event[\"step\"][\"value\"]\n self.current_value.append(value)","def do(self):\n super().do()\n logger.info(\"TrainPipeStep started...\")\n records = self._get_current_step_records()\n logger.debug(\"load pipestep records: {}\".format(records))\n self.num_models = len(records)\n self.num_epochs = self.num_models * TrainerConfig.epochs\n self.update_status(Status.running)\n self.master = create_master()\n self._train_multi_models(records)\n self.master.join()\n ReportServer().output_step_all_records(step_name=self.task.step_name)\n self.master.close()\n ReportServer().backup_output_path()\n self.update_status(Status.finished)","def _postprocess(self):","def step ( self ) :\n return self.__step","def post_process(self, relevant_targets):\r\n pass","def _step(self, action: types.NestedArray) -> ts.TimeStep:","def processing(self):\n pass","def add_step_hook(h):\n add_hook(step, h)","def run(self):\n logger = self.logger\n cwd = os.getcwd()\n for step_name in self.steps_to_run:\n step = self.steps[step_name]\n if step.cached:\n logger.info(' * Cached: {}'.format(step_name))\n continue\n step.config = self.config\n new_log_file = self.new_step_log_file\n if self.log_filename is not None:\n step.log_filename = self.log_filename\n do_local_logging = True\n else:\n # We only want to do local log output if the step output is\n # being redirected to a file. Otherwise, we assume we're\n # probably just running one step and the local logging is\n # redundant and unnecessary\n do_local_logging = new_log_file\n\n if do_local_logging:\n logger.info(' * Running {}'.format(step_name))\n try:\n self._run_step(step, new_log_file)\n except BaseException:\n if do_local_logging:\n logger.info(' Failed')\n raise\n\n if do_local_logging:\n logger.info(' Complete')\n\n os.chdir(cwd)","def runDocumentStepByStep(self):\n self.runDocument(stepByStep = True)","def step(self, action):\n raise NotImplementedError()","def prepare_step(self, i=None):\n\n if i is None:\n i = self.current_step_index\n\n # Setting step class and settings\n step_class = self.get_step_class_at_index(i)\n step_settings = self.get_step_settings_at_index(i)\n step_label = self.get_step_label_at_index(i)\n\n # Setting the temporary values\n self.current_step_tmp_vals = self.get_step_tmp_vals_at_index(i)\n\n # Update print\n if self.get_param_value('verbose'):\n print(f\"{self.name}, step {i} \"\n f\"({self.routine_template.step_name(index=i)}), preparing...\")\n qubits = step_settings.pop('qubits', self.qubits)\n dev = step_settings.pop('dev', self.dev)\n autocalib_settings = self.settings.copy(\n overwrite_dict=step_settings.pop('settings', {}))\n # Executing the step with corresponding settings\n if issubclass(step_class, qbcal.SingleQubitGateCalibExperiment) or \\\n issubclass(step_class, QuantumExperiment):\n step = step_class(qubits=qubits,\n routine=self,\n dev=dev,\n step_label=step_label,\n settings=autocalib_settings,\n **step_settings)\n elif issubclass(step_class, IntermediateStep):\n step = step_class(routine=self,\n dev=dev,\n step_label=step_label,\n qubits=qubits,\n autorun=False,\n settings=autocalib_settings,\n **step_settings)\n elif issubclass(step_class, AutomaticCalibrationRoutine):\n step = step_class(routine=self,\n dev=dev,\n step_label=step_label,\n qubits=qubits,\n autorun=False,\n settings=autocalib_settings,\n **step_settings)\n else:\n raise ValueError(f\"automatic subroutine is not compatible (yet)\"\n f\"with the current step class {step_class}\")\n self.current_step = step\n self.current_step_settings = step_settings","def step(self):\n self.driver.step()","def split_step_for_parallel_groups(self, index):\n # Get the details of the step to be replaced\n step = self.routine_template[index]\n step_class = step[0]\n step_label = step[1]\n step_settings = step[2]\n try:\n step_tmp_settings = step[3]\n except IndexError:\n step_tmp_settings = []\n\n # Look for the keyword 'parallel_groups' in the settings\n lookups = [\n step_label,\n step_class.get_lookup_class().__name__, 'General'\n ]\n parallel_groups = self.get_param_value('parallel_groups',\n sublookups=lookups,\n leaf=True)\n if parallel_groups is not None:\n new_step_index = index\n # Remove existing step\n self.routine_template.pop(index)\n for parallel_group in parallel_groups:\n # Find the qubits belonging to parallel_group\n qubits_filtered = [\n qb for qb in self.qubits if\n (qb.name == parallel_group or\n parallel_group in self.get_qubit_groups(qb.name))\n ]\n # Create a new step for qubits_filtered only and add it to the\n # routine template\n if len(qubits_filtered) != 0:\n new_settings = copy.deepcopy(step_settings)\n new_settings['qubits'] = qubits_filtered\n self.add_step(step_class,\n step_label,\n new_settings,\n step_tmp_settings,\n index=new_step_index)\n new_step_index += 1","def process(self):\n level = self.parameter['level-of-operation']\n assert_file_grp_cardinality(self.input_file_grp, 1)\n assert_file_grp_cardinality(self.output_file_grp, 1)\n\n for (n, input_file) in enumerate(self.input_files):\n self.logger.info(\"INPUT FILE %i / %s\", n, input_file.pageId or input_file.ID)\n file_id = make_file_id(input_file, self.output_file_grp)\n\n pcgts = page_from_file(self.workspace.download_file(input_file))\n self.add_metadata(pcgts)\n page_id = pcgts.pcGtsId or input_file.pageId or input_file.ID # (PageType has no id)\n page = pcgts.get_Page()\n \n page_image, page_xywh, page_image_info = self.workspace.image_from_page(\n page, page_id, feature_filter='binarized')\n if self.parameter['dpi'] > 0:\n zoom = 300.0/self.parameter['dpi']\n elif page_image_info.resolution != 1:\n dpi = page_image_info.resolution\n if page_image_info.resolutionUnit == 'cm':\n dpi *= 2.54\n self.logger.info('Page \"%s\" uses %f DPI', page_id, dpi)\n zoom = 300.0/dpi\n else:\n zoom = 1\n \n if level == 'page':\n self.process_page(page, page_image, page_xywh, zoom,\n input_file.pageId, file_id)\n else:\n if level == 'table':\n regions = page.get_TableRegion()\n else: # region\n regions = page.get_AllRegions(classes=['Text'], order='reading-order')\n if not regions:\n self.logger.warning('Page \"%s\" contains no text regions', page_id)\n for region in regions:\n region_image, region_xywh = self.workspace.image_from_segment(\n region, page_image, page_xywh, feature_filter='binarized')\n if level == 'region':\n self.process_region(region, region_image, region_xywh, zoom,\n input_file.pageId, file_id + '_' + region.id)\n continue\n lines = region.get_TextLine()\n if not lines:\n self.logger.warning('Page \"%s\" region \"%s\" contains no text lines',\n page_id, region.id)\n for line in lines:\n line_image, line_xywh = self.workspace.image_from_segment(\n line, region_image, region_xywh, feature_filter='binarized')\n self.process_line(line, line_image, line_xywh, zoom,\n input_file.pageId, region.id,\n file_id + '_' + region.id + '_' + line.id)\n\n # update METS (add the PAGE file):\n file_path = os.path.join(self.output_file_grp, file_id + '.xml')\n pcgts.set_pcGtsId(file_id)\n out = self.workspace.add_file(\n ID=file_id,\n file_grp=self.output_file_grp,\n pageId=input_file.pageId,\n local_filename=file_path,\n mimetype=MIMETYPE_PAGE,\n content=to_xml(pcgts))\n self.logger.info('created file ID: %s, file_grp: %s, path: %s',\n file_id, self.output_file_grp, out.local_filename)","def steps(self,num_steps):\n if self.last_sensation == TERMINAL_STATE:\n self.start_episode()\n for step in range(num_steps):\n next_sensation,reward = self.env(self.next_action)\n self.collect_data(self.last_sensation, self.next_action, reward, next_sensation)\n self.next_action = self.agent(next_sensation,reward)\n self.last_sensation = next_sensation\n if self.last_sensation == TERMINAL_STATE:\n self.start_episode()","def rf_stepMode(self, selTree, treeDict):\n for step in treeDict['steps']:\n newStep = TreeNode(nodeType='step', nodeLabel=step, nodeName=step)\n self.addTopLevelItem(newStep)\n for node in treeDict['tree']['_order']:\n newItem = TreeNode(**treeDict['tree'][node])\n if len(node.split('/')) == 1:\n newStep.addChild(newItem)\n else:\n rootPath = \"%s/%s\" % (step, '/'.join(node.split('/')[:-1]))\n parent = self._getItemFromTreePath(rootPath)\n parent.addChild(newItem)\n if getattr(newItem, 'nodeType') == 'shotNode':\n newItem._tree = selTree\n newItem._step = step\n newItem._itemPath = node\n newItem._dataPath = os.path.join(self.pm._treePath, selTree)\n for fld in node.split('/'):\n newItem._dataPath = os.path.join(newItem._dataPath, fld)\n newItem._dataPath = pFile.conformPath(newItem._dataPath)\n newItem._ltPath = pFile.conformPath(os.path.join(newItem._dataPath, 'lt', step))\n newItem._dataFile = \"%s.py\" % newItem._dataPath","def step(self):\n for layer in self.layers:\n layer.step()","def process_example(self):\n\n name_files, transition_funcs = self.treat.get_transition_functions()\n for name_file, transition_func in zip(name_files, transition_funcs):\n print(f\"Name file: {name_file}\")\n self.afd(transition_func, self.q0, self.qfs, self.words)\n print('-'*50)","def step(self):\n self.log.info(\"Stepping %r\", self)\n # get enabled transitions before reseting inputs\n scope_transitions = self.get_enabled_transitions_by_scope()\n\n # reset inputs/outputs at the start of a big step\n if self.enabled_inputs:\n self.log.info(\"Reseting inputs and outputs at start of big step...\")\n self.enabled_inputs = set()\n self.outputs = set()\n self.locals = set()\n\n # execute transitions\n # - note that each scope is non-overlapping by definition\n updates = dict()\n for scope, transitions in scope_transitions.items():\n if len(transitions) > 1: # non-determinism\n pass\n transition = transitions[0]\n self._execute_transition(transition, updates)\n\n # update variables\n self.variables.update(updates)\n self.log.info(\"Variables now %r\", self.variables)","def step(self):\n # Pull data from the first available input channel.\n\n input_bag = self.get()\n\n # todo add timer\n self.handle_results(input_bag, input_bag.apply(self._stack))","def process_thread(self):"],"string":"[\n \"def do_step(self) -> None:\",\n \"def process_step(self, request, step, form):\\n pass\",\n \"def _step(self):\\n pass\",\n \"def process_steps(self, df, **kwargs):\\n pass\",\n \"def step(self, **kwargs):\\n pass\",\n \"def _step(self) -> None:\",\n \"def perform_step(self) -> None:\\n pass\",\n \"def step(self):\\n\\n pass\",\n \"def train_loop_post(self, current_step):\\r\\n pass\",\n \"def _insertAllSteps(self): \\n self.uMics = self.inputCoordinatesTiltedPairs.get().getUntilted().getMicrographs()\\n self.tMics = self.inputCoordinatesTiltedPairs.get().getTilted().getMicrographs()\\n\\n self.inputMics = self._createSetOfParticles('auxMics')\\n self.inputMics.copyInfo(self.uMics)\\n self.inputMics.setStore(False)\\n \\n for micU, micT in izip(self.uMics, self.tMics):\\n micU.cleanObjId()\\n micT.cleanObjId()\\n self.inputMics.append(micU)\\n self.inputMics.append(micT)\\n\\n self.samplingInput = self.uMics.getSamplingRate()\\n \\n\\n if self.downsampleType.get() != OTHER:\\n # If 'same as picking' or 'original' get sampling rate from input micrographs\\n #TODO: Review this when downsampling before picking is possible\\n self.samplingFinal = self.samplingInput\\n else:\\n # If 'other' multiply the input sampling rate by the factor provided\\n self.samplingFinal = self.samplingInput*self.downFactor.get()\\n \\n # Write pos files for each micrograph\\n firstStepId = self._insertFunctionStep('writePosFilesStep')\\n \\n # For each micrograph insert the steps\\n #run in parallel\\n \\n deps = []\\n for mic in self.inputMics:\\n localDeps = [firstStepId]\\n micrographToExtract = mic.getFileName()\\n micName = removeBaseExt(mic.getFileName())\\n micId = mic.getObjId()\\n\\n # If downsample type is 'other' perform a downsample\\n if self.downsampleType == OTHER:\\n fnDownsampled = self._getTmpPath(micName+\\\"_downsampled.xmp\\\")\\n downFactor = self.downFactor.get()\\n args = \\\"-i %(micrographToExtract)s -o %(fnDownsampled)s --step %(downFactor)f --method fourier\\\"\\n localDeps=[self._insertRunJobStep(\\\"xmipp_transform_downsample\\\", args % locals(),prerequisites=localDeps)]\\n micrographToExtract = fnDownsampled\\n \\n # If remove dust \\n if self.doRemoveDust:\\n fnNoDust = self._getTmpPath(micName+\\\"_noDust.xmp\\\")\\n \\n thresholdDust = self.thresholdDust.get() #TODO: remove this extra variable\\n args=\\\" -i %(micrographToExtract)s -o %(fnNoDust)s --bad_pixels outliers %(thresholdDust)f\\\"\\n localDeps=[self._insertRunJobStep(\\\"xmipp_transform_filter\\\", args % locals(),prerequisites=localDeps)]\\n micrographToExtract = fnNoDust\\n \\n #self._insertFunctionStep('getCTF', micId, micName, micrographToExtract)\\n micName = removeBaseExt(mic.getFileName())\\n \\n # Actually extract\\n deps.append(self._insertFunctionStep('extractParticlesStep', micId, micName, \\n None, micrographToExtract, prerequisites=localDeps))\\n # TODO: Delete temporary files\\n \\n # Insert step to create output objects \\n self._insertFunctionStep('createOutputStep', prerequisites=deps)\",\n \"def process_steps(steplist, build, buildslave, build_status, basedir):\\n for step in steplist:\\n step.setBuild(build)\\n step.setBuildSlave(buildslave)\\n step.setStepStatus(build_status.addStepWithName(step.name))\\n step.setDefaultWorkdir(os.path.join(basedir, 'build'))\\n step.workdir = os.path.join(basedir, 'build')\",\n \"def step(self, step=None):\\n pass\",\n \"def step(self):\\n curr_step = self.steplist[self.curr_step_idx] #dictionary\\n insn_type = curr_step[\\\"type\\\"]\\n\\n #case over insn_types\\n if insn_type == \\\"init\\\":\\n self.exec_init(curr_step)\\n self.curr_step_idx += 1\\n\\n elif insn_type == \\\"preprocess\\\":\\n self.exec_preprocess(curr_step)\\n self.curr_step_idx += 1\\n\\n elif insn_type == \\\"augment\\\":\\n self.exec_augment(curr_step)\\n self.curr_step_idx += 1\\n \\n elif insn_type ==\\\"combine\\\":\\n self.exec_combine(curr_step)\\n self.curr_step_idx += 1\\n\\n elif insn_type ==\\\"attention\\\":\\n self.exec_attention(curr_step)\\n self.curr_step_idx += 1\",\n \"def step(self):\\n raise NotImplementedError\",\n \"def step(self):\\n self.function()\",\n \"def step(self):\\r\\n raise NotImplementedError\",\n \"def processInputs(self):\",\n \"def step(self, model):\\n pass\",\n \"def step(self, model):\\n pass\",\n \"def on_eval_batch_begin(self, step, logs=None):\",\n \"def getSteps():\",\n \"def step(self, action):\",\n \"def run(self):\\n\\n step = self.steps['diagnostics_files']\\n step.cores = self.config.getint('make_diagnostics_files', 'cores')\\n\\n # run the step\\n super().run()\",\n \"def step_impl(context):\\n pass\",\n \"def step_impl(context):\\n pass\",\n \"def _main(self):\\n\\n i = 0\\n\\n for i, step in enumerate(self._run_list):\\n return_code = self._check_step_completed(i)\\n\\n if return_code == 0:\\n logger.debug('Successful: \\\"{}\\\".'.format(list(step.keys())[0]))\\n else:\\n return_code = 1\\n self._submit_step(i)\\n\\n # do not enter while loop for continuous monitoring\\n if not self.monitor:\\n break\\n\\n time.sleep(1)\\n while return_code == 1 and self.monitor:\\n time.sleep(5)\\n return_code = self._check_step_completed(i)\\n\\n if return_code == 2:\\n module, f_config = self._get_command_config(i)\\n raise ExecutionError('Pipeline failed at step '\\n '{} \\\"{}\\\" {}'\\n .format(i, module, f_config))\\n\\n if i + 1 == len(self._run_list) and return_code == 0:\\n logger.info('Pipeline job \\\"{}\\\" is complete.'\\n .format(self._config.name))\\n logger.debug('Output directory is: \\\"{}\\\"'\\n .format(self._config.dirout))\",\n \"def build_step(self):\\n pass\",\n \"def build_step(self):\\n pass\",\n \"def step(self):\\n raise NotImplementedError()\",\n \"def step(self):\\n raise NotImplementedError()\",\n \"def step(self):\\n raise NotImplementedError()\",\n \"async def on_step(self, iteration: int):\\n raise NotImplementedError\",\n \"def build_step(self):\\n\\n pass\",\n \"def process():\",\n \"def step(self):\\n #1. Time progresses\\n self.time_operator.step()\\n \\n #2. Form and dissolve relationships\\\"\\n self.relationship_operator.step()\\n\\n #3. HIV transmission\\n self.infection_operator.step()\",\n \"def process_step(self, observation, reward, done, info):\\n observation = self.process_observation(observation)\\n reward = self.process_reward(reward)\\n info = self.process_info(info)\\n return observation, reward, done, info\",\n \"def process(self):\\n pass\",\n \"def process(self):\",\n \"def process(self):\",\n \"def process(self):\",\n \"def eval_step(self, *args, **kwargs):\\n raise NotImplementedError\",\n \"def run_step(self):\\n self.control_instance.run_step()\",\n \"def step(self, state):\",\n \"def perform_step(self, action):\\n pass\",\n \"def step_async(self, actions):\",\n \"def postprocess_step(self, t, y):\\n pass\",\n \"def exec_preprocess(self, curr_step):\\n assert(self.curr_step_idx > 0 and self.dlist is not None), \\\"Step Error: Must call init before preprocess\\\" \\n\\n #verify raw data & dlist\\n self.B_VER(self.sess_path, self.dlist)\\n\\n #move & preprocess each folder\\n funclist = curr_step[\\\"funclist\\\"]\\n raw_datadir = self.sess_path\\n dest_datadir = self.sess_path\\n new_dlist = []\\n for i, folder in enumerate(self.dlist):\\n flist = funclist[i]\\n new_folder = self.data_utils.MOVE(raw_datadir, folder, dest_datadir, flist=flist, preview=False)\\n new_dlist.append(new_folder)\\n self.dlist = new_dlist\\n self.default_vis(curr_step)\",\n \"def on_eval_batch_end(self, step, logs=None):\",\n \"def step(self, closure=None):\\n for group in self.param_groups:\\n for p in group['params']:\\n if p.grad is None:\\n continue\\n # Want to update step by workers sharing shared_step?\\n # There are two different, step and steps\\n self.state[p]['steps'] = self.state[p]['shared_step'].item()\\n self.state[p]['shared_step'] += 1\\n # But does the below not override steps?\\n # -> No, because Adam step updates step, not step\\\"s\\\"\\n super().step(closure)\",\n \"def step(self):\\n while self.state != STATE_TERMINAL:\\n self.step_strategies[self.state]()\",\n \"def step(self, memories):\\n return\",\n \"def compute_step(self):\\n self._apply_controls(step=self.step, post=True)\\n self._step += 1\\n for gate_layer in self._tebd_propagator.gate_layers:\\n self._t_mps.apply_nn_gate_layer(gate_layer)\\n self._t_mps.apply_process_tensors(self.step,\\n self._process_tensors)\\n for gate_layer in self._tebd_propagator.gate_layers:\\n self._t_mps.apply_nn_gate_layer(gate_layer)\\n self._apply_controls(step=self.step, post=False)\\n self._append_results()\",\n \"def _run_step(self, step, new_log_file):\\n logger = self.logger\\n config = self.config\\n cwd = os.getcwd()\\n available_cores, _ = get_available_cores_and_nodes(config)\\n step.cores = min(step.cores, available_cores)\\n if step.min_cores is not None:\\n if step.cores < step.min_cores:\\n raise ValueError(\\n 'Available cores for {} is below the minimum of {}'\\n ''.format(step.cores, step.min_cores))\\n\\n missing_files = list()\\n for input_file in step.inputs:\\n if not os.path.exists(input_file):\\n missing_files.append(input_file)\\n\\n if len(missing_files) > 0:\\n raise OSError(\\n 'input file(s) missing in step {} of {}/{}/{}: {}'.format(\\n step.name, step.mpas_core.name, step.test_group.name,\\n step.test_case.subdir, missing_files))\\n\\n test_name = step.path.replace('/', '_')\\n if new_log_file:\\n log_filename = '{}/{}.log'.format(cwd, step.name)\\n step.log_filename = log_filename\\n step_logger = None\\n else:\\n step_logger = logger\\n log_filename = None\\n with LoggingContext(name=test_name, logger=step_logger,\\n log_filename=log_filename) as step_logger:\\n step.logger = step_logger\\n os.chdir(step.work_dir)\\n step.run()\\n\\n missing_files = list()\\n for output_file in step.outputs:\\n if not os.path.exists(output_file):\\n missing_files.append(output_file)\\n\\n if len(missing_files) > 0:\\n raise OSError(\\n 'output file(s) missing in step {} of {}/{}/{}: {}'.format(\\n step.name, step.mpas_core.name, step.test_group.name,\\n step.test_case.subdir, missing_files))\",\n \"def _step(self, whence):\\n pass\",\n \"def process(self):\\n # Opening and preprocessing of the input file\\n if self.options.mbtiles_fromdisk or self.options.mbtiles_todisk:\\n if self.options.mbtiles_fromdisk:\\n i_parm=10\\n if self.options.mbtiles_todisk:\\n i_parm=11\\n if self.options.verbose:\\n print \\\"GDAL2MbTiles :mbtiles from/to disk [\\\",i_parm,\\\"] mbtiles_fromdisk[\\\",self.options.mbtiles_fromdisk,\\\"] mbtiles_todisk[\\\",self.options.mbtiles_todisk,\\\"]\\\"\\n self.mbtiles_setup(i_parm)\\n return\\n else:\\n if self.options.verbose:\\n print \\\"GDAL2MbTiles :tile creation mbtiles[\\\",self.options.mbtiles,\\\"]\\\"\\n self.open_input()\\n # Generation of main metadata files and HTML viewers\\n self.generate_metadata()\\n # Generation of the lowest tiles\\n self.generate_base_tiles()\\n # Generation of the overview tiles (higher in the pyramid)\\n self.generate_overview_tiles()\\n # Generating of KML\\n self.generate_kml()\",\n \"def step(self, n, dlist):\\n pass\",\n \"def run_one_step(self):\\n pass\",\n \"def perform_step(self, step, batch):\\n\\n # perform a min step\\n self.__max_step(batch)\\n self.__min_step(batch)\\n\\n l_suff_stats = self.shuffle_up_stats(batch)\\n obj = self.main_obj(batch, l_suff_stats)\\n constraints = self.main_constraints(batch, l_suff_stats)\\n\\n self.cli.print(self.fmtstr % (step, obj.detach().numpy(), *[item for sublist in zip(self.lagrange_mults, constraints) for item in sublist]))\",\n \"def record(self, step):\",\n \"def step(self, action):\\n pass\",\n \"def step(self, action):\\n pass\",\n \"def next_step(self):\\n self.proceed()\\n self.execute_current()\",\n \"def handleChainedProcessingTweak(self):\\n self.logger.info(\\\"Handling chained processing job\\\")\\n\\n # check the jobs input files\\n inputFile = (\\\"file:../%s/%s.root\\\" % (self.step.data.input.inputStepName,\\n self.step.data.input.inputOutputModule))\\n\\n self.tweak.addParameter('process.source.fileNames', \\\"customTypeCms.untracked.vstring(%s)\\\" % [inputFile])\\n self.tweak.addParameter(\\\"process.maxEvents\\\", \\\"customTypeCms.untracked.PSet(input=cms.untracked.int32(-1))\\\")\\n self.logger.info(\\\"Chained PSet tweaked with maxEvents: -1, and fileNames: %s\\\", inputFile)\\n return\",\n \"def run(self):\\n with self.get_connection() as conn:\\n #self._create_new_batch_and_step_audit(conn)\\n \\\"\\\"\\\"Kick off the transformation job.\\\"\\\"\\\"\\n if self.run_all_steps:\\n self.run_all()\\n else:\\n self.skipped_steps = []\\n self.skipped_tables = []\\n step_runner = self.step_lambda_map[self.etl_step]\\n step_runner()\",\n \"def step(self, timestamp=0.0, **keywords):\\n self.services.debug('step() method called')\\n pass\",\n \"def postprocess_step(self, t, y):\\n return\",\n \"def getCurrentStep():\",\n \"def process(self):\\n raise NotImplementedError\",\n \"def step(self):\\n raise TaskError(\\\"Task %s: subclass should override step() method!\\\" %\\n self)\",\n \"def process_inputs(self, inputs):\",\n \"def step(self, action):\\n raise NotImplementedError\",\n \"def stepFinished(build, step, results):\",\n \"def after_step():\\n raise NotImplementedError\",\n \"def perform_mult_steps(self, num_steps, tc, batch_size):\\n\\n self.sample_v()\\n self.cli.empty().print(self.titlestr % (\\\"k\\\", \\\"objective\\\", *[f\\\"lm_{i} x constr_{i}\\\" for i in range(len(self.lagrange_mults))]))\\n\\n # perform a min step\\n for s in range(num_steps):\\n batch = tc.sample(batch_size, ['add_act', 'grad_ranking', 'add_pi'])\\n self.perform_step(s, batch)\",\n \"def step(self, d=1):\\n raise NotImplementedError()\",\n \"def _insertAllSteps(self):\\n \\n # Get pointer to input micrographs \\n self.particlePickingRun = self.xmippParticlePicking.get()\\n \\n copyId = self._insertFunctionStep('copyInputFilesStep')\\n # Get micrographs to pick\\n #self.inputMicrographs.set(self.getInputMicrographs())\\n \\n deps = []\\n for mic in self.getInputMicrographs():\\n stepId = self._insertFunctionStep('autopickMicrographStep', mic.getFileName(), prerequisites=[copyId])\\n deps.append(stepId)\\n \\n self._insertFunctionStep('_createOutput',self._getExtraPath(), prerequisites=deps)\",\n \"def execute_step(self):\\n if self.get_param_value('verbose'):\\n j = self.current_step_index\\n print(f\\\"{self.name}, step {j} \\\"\\n f\\\"({self.routine_template.step_name(index=j)}), executing...\\\")\\n\\n self.current_step.run()\\n self.current_step.post_run() # optional. Update results for example.\\n\\n self.routine_steps.append(self.current_step)\\n self.current_step_index += 1\",\n \"def run(self):\\r\\n try:\\r\\n self.loader.find_and_load_step_definitions()\\r\\n except StepLoadingError, e:\\r\\n print \\\"Error loading step definitions:\\\\n\\\", e\\r\\n return\\r\\n\\r\\n results = []\\r\\n if self.explicit_features:\\r\\n features_files = self.explicit_features\\r\\n else:\\r\\n features_files = self.loader.find_feature_files()\\r\\n if self.random:\\r\\n random.shuffle(features_files)\\r\\n\\r\\n if not features_files:\\r\\n self.output.print_no_features_found(self.loader.base_dir)\\r\\n return\\r\\n\\r\\n processes = Pool(processes=self.parallelization)\\r\\n test_results_it = processes.imap_unordered(\\r\\n worker_process, [(self, filename) for filename in features_files]\\r\\n )\\r\\n \\r\\n all_total = ParallelTotalResult()\\r\\n for result in test_results_it:\\r\\n all_total += result['total']\\r\\n sys.stdout.write(result['stdout'])\\r\\n sys.stderr.write(result['stderr'])\\r\\n\\r\\n return all_total\",\n \"def step_forward(self):\",\n \"def step(self):\\n value = self.current_event[\\\"step\\\"][\\\"value\\\"]\\n self.current_value.append(value)\",\n \"def do(self):\\n super().do()\\n logger.info(\\\"TrainPipeStep started...\\\")\\n records = self._get_current_step_records()\\n logger.debug(\\\"load pipestep records: {}\\\".format(records))\\n self.num_models = len(records)\\n self.num_epochs = self.num_models * TrainerConfig.epochs\\n self.update_status(Status.running)\\n self.master = create_master()\\n self._train_multi_models(records)\\n self.master.join()\\n ReportServer().output_step_all_records(step_name=self.task.step_name)\\n self.master.close()\\n ReportServer().backup_output_path()\\n self.update_status(Status.finished)\",\n \"def _postprocess(self):\",\n \"def step ( self ) :\\n return self.__step\",\n \"def post_process(self, relevant_targets):\\r\\n pass\",\n \"def _step(self, action: types.NestedArray) -> ts.TimeStep:\",\n \"def processing(self):\\n pass\",\n \"def add_step_hook(h):\\n add_hook(step, h)\",\n \"def run(self):\\n logger = self.logger\\n cwd = os.getcwd()\\n for step_name in self.steps_to_run:\\n step = self.steps[step_name]\\n if step.cached:\\n logger.info(' * Cached: {}'.format(step_name))\\n continue\\n step.config = self.config\\n new_log_file = self.new_step_log_file\\n if self.log_filename is not None:\\n step.log_filename = self.log_filename\\n do_local_logging = True\\n else:\\n # We only want to do local log output if the step output is\\n # being redirected to a file. Otherwise, we assume we're\\n # probably just running one step and the local logging is\\n # redundant and unnecessary\\n do_local_logging = new_log_file\\n\\n if do_local_logging:\\n logger.info(' * Running {}'.format(step_name))\\n try:\\n self._run_step(step, new_log_file)\\n except BaseException:\\n if do_local_logging:\\n logger.info(' Failed')\\n raise\\n\\n if do_local_logging:\\n logger.info(' Complete')\\n\\n os.chdir(cwd)\",\n \"def runDocumentStepByStep(self):\\n self.runDocument(stepByStep = True)\",\n \"def step(self, action):\\n raise NotImplementedError()\",\n \"def prepare_step(self, i=None):\\n\\n if i is None:\\n i = self.current_step_index\\n\\n # Setting step class and settings\\n step_class = self.get_step_class_at_index(i)\\n step_settings = self.get_step_settings_at_index(i)\\n step_label = self.get_step_label_at_index(i)\\n\\n # Setting the temporary values\\n self.current_step_tmp_vals = self.get_step_tmp_vals_at_index(i)\\n\\n # Update print\\n if self.get_param_value('verbose'):\\n print(f\\\"{self.name}, step {i} \\\"\\n f\\\"({self.routine_template.step_name(index=i)}), preparing...\\\")\\n qubits = step_settings.pop('qubits', self.qubits)\\n dev = step_settings.pop('dev', self.dev)\\n autocalib_settings = self.settings.copy(\\n overwrite_dict=step_settings.pop('settings', {}))\\n # Executing the step with corresponding settings\\n if issubclass(step_class, qbcal.SingleQubitGateCalibExperiment) or \\\\\\n issubclass(step_class, QuantumExperiment):\\n step = step_class(qubits=qubits,\\n routine=self,\\n dev=dev,\\n step_label=step_label,\\n settings=autocalib_settings,\\n **step_settings)\\n elif issubclass(step_class, IntermediateStep):\\n step = step_class(routine=self,\\n dev=dev,\\n step_label=step_label,\\n qubits=qubits,\\n autorun=False,\\n settings=autocalib_settings,\\n **step_settings)\\n elif issubclass(step_class, AutomaticCalibrationRoutine):\\n step = step_class(routine=self,\\n dev=dev,\\n step_label=step_label,\\n qubits=qubits,\\n autorun=False,\\n settings=autocalib_settings,\\n **step_settings)\\n else:\\n raise ValueError(f\\\"automatic subroutine is not compatible (yet)\\\"\\n f\\\"with the current step class {step_class}\\\")\\n self.current_step = step\\n self.current_step_settings = step_settings\",\n \"def step(self):\\n self.driver.step()\",\n \"def split_step_for_parallel_groups(self, index):\\n # Get the details of the step to be replaced\\n step = self.routine_template[index]\\n step_class = step[0]\\n step_label = step[1]\\n step_settings = step[2]\\n try:\\n step_tmp_settings = step[3]\\n except IndexError:\\n step_tmp_settings = []\\n\\n # Look for the keyword 'parallel_groups' in the settings\\n lookups = [\\n step_label,\\n step_class.get_lookup_class().__name__, 'General'\\n ]\\n parallel_groups = self.get_param_value('parallel_groups',\\n sublookups=lookups,\\n leaf=True)\\n if parallel_groups is not None:\\n new_step_index = index\\n # Remove existing step\\n self.routine_template.pop(index)\\n for parallel_group in parallel_groups:\\n # Find the qubits belonging to parallel_group\\n qubits_filtered = [\\n qb for qb in self.qubits if\\n (qb.name == parallel_group or\\n parallel_group in self.get_qubit_groups(qb.name))\\n ]\\n # Create a new step for qubits_filtered only and add it to the\\n # routine template\\n if len(qubits_filtered) != 0:\\n new_settings = copy.deepcopy(step_settings)\\n new_settings['qubits'] = qubits_filtered\\n self.add_step(step_class,\\n step_label,\\n new_settings,\\n step_tmp_settings,\\n index=new_step_index)\\n new_step_index += 1\",\n \"def process(self):\\n level = self.parameter['level-of-operation']\\n assert_file_grp_cardinality(self.input_file_grp, 1)\\n assert_file_grp_cardinality(self.output_file_grp, 1)\\n\\n for (n, input_file) in enumerate(self.input_files):\\n self.logger.info(\\\"INPUT FILE %i / %s\\\", n, input_file.pageId or input_file.ID)\\n file_id = make_file_id(input_file, self.output_file_grp)\\n\\n pcgts = page_from_file(self.workspace.download_file(input_file))\\n self.add_metadata(pcgts)\\n page_id = pcgts.pcGtsId or input_file.pageId or input_file.ID # (PageType has no id)\\n page = pcgts.get_Page()\\n \\n page_image, page_xywh, page_image_info = self.workspace.image_from_page(\\n page, page_id, feature_filter='binarized')\\n if self.parameter['dpi'] > 0:\\n zoom = 300.0/self.parameter['dpi']\\n elif page_image_info.resolution != 1:\\n dpi = page_image_info.resolution\\n if page_image_info.resolutionUnit == 'cm':\\n dpi *= 2.54\\n self.logger.info('Page \\\"%s\\\" uses %f DPI', page_id, dpi)\\n zoom = 300.0/dpi\\n else:\\n zoom = 1\\n \\n if level == 'page':\\n self.process_page(page, page_image, page_xywh, zoom,\\n input_file.pageId, file_id)\\n else:\\n if level == 'table':\\n regions = page.get_TableRegion()\\n else: # region\\n regions = page.get_AllRegions(classes=['Text'], order='reading-order')\\n if not regions:\\n self.logger.warning('Page \\\"%s\\\" contains no text regions', page_id)\\n for region in regions:\\n region_image, region_xywh = self.workspace.image_from_segment(\\n region, page_image, page_xywh, feature_filter='binarized')\\n if level == 'region':\\n self.process_region(region, region_image, region_xywh, zoom,\\n input_file.pageId, file_id + '_' + region.id)\\n continue\\n lines = region.get_TextLine()\\n if not lines:\\n self.logger.warning('Page \\\"%s\\\" region \\\"%s\\\" contains no text lines',\\n page_id, region.id)\\n for line in lines:\\n line_image, line_xywh = self.workspace.image_from_segment(\\n line, region_image, region_xywh, feature_filter='binarized')\\n self.process_line(line, line_image, line_xywh, zoom,\\n input_file.pageId, region.id,\\n file_id + '_' + region.id + '_' + line.id)\\n\\n # update METS (add the PAGE file):\\n file_path = os.path.join(self.output_file_grp, file_id + '.xml')\\n pcgts.set_pcGtsId(file_id)\\n out = self.workspace.add_file(\\n ID=file_id,\\n file_grp=self.output_file_grp,\\n pageId=input_file.pageId,\\n local_filename=file_path,\\n mimetype=MIMETYPE_PAGE,\\n content=to_xml(pcgts))\\n self.logger.info('created file ID: %s, file_grp: %s, path: %s',\\n file_id, self.output_file_grp, out.local_filename)\",\n \"def steps(self,num_steps):\\n if self.last_sensation == TERMINAL_STATE:\\n self.start_episode()\\n for step in range(num_steps):\\n next_sensation,reward = self.env(self.next_action)\\n self.collect_data(self.last_sensation, self.next_action, reward, next_sensation)\\n self.next_action = self.agent(next_sensation,reward)\\n self.last_sensation = next_sensation\\n if self.last_sensation == TERMINAL_STATE:\\n self.start_episode()\",\n \"def rf_stepMode(self, selTree, treeDict):\\n for step in treeDict['steps']:\\n newStep = TreeNode(nodeType='step', nodeLabel=step, nodeName=step)\\n self.addTopLevelItem(newStep)\\n for node in treeDict['tree']['_order']:\\n newItem = TreeNode(**treeDict['tree'][node])\\n if len(node.split('/')) == 1:\\n newStep.addChild(newItem)\\n else:\\n rootPath = \\\"%s/%s\\\" % (step, '/'.join(node.split('/')[:-1]))\\n parent = self._getItemFromTreePath(rootPath)\\n parent.addChild(newItem)\\n if getattr(newItem, 'nodeType') == 'shotNode':\\n newItem._tree = selTree\\n newItem._step = step\\n newItem._itemPath = node\\n newItem._dataPath = os.path.join(self.pm._treePath, selTree)\\n for fld in node.split('/'):\\n newItem._dataPath = os.path.join(newItem._dataPath, fld)\\n newItem._dataPath = pFile.conformPath(newItem._dataPath)\\n newItem._ltPath = pFile.conformPath(os.path.join(newItem._dataPath, 'lt', step))\\n newItem._dataFile = \\\"%s.py\\\" % newItem._dataPath\",\n \"def step(self):\\n for layer in self.layers:\\n layer.step()\",\n \"def process_example(self):\\n\\n name_files, transition_funcs = self.treat.get_transition_functions()\\n for name_file, transition_func in zip(name_files, transition_funcs):\\n print(f\\\"Name file: {name_file}\\\")\\n self.afd(transition_func, self.q0, self.qfs, self.words)\\n print('-'*50)\",\n \"def step(self):\\n self.log.info(\\\"Stepping %r\\\", self)\\n # get enabled transitions before reseting inputs\\n scope_transitions = self.get_enabled_transitions_by_scope()\\n\\n # reset inputs/outputs at the start of a big step\\n if self.enabled_inputs:\\n self.log.info(\\\"Reseting inputs and outputs at start of big step...\\\")\\n self.enabled_inputs = set()\\n self.outputs = set()\\n self.locals = set()\\n\\n # execute transitions\\n # - note that each scope is non-overlapping by definition\\n updates = dict()\\n for scope, transitions in scope_transitions.items():\\n if len(transitions) > 1: # non-determinism\\n pass\\n transition = transitions[0]\\n self._execute_transition(transition, updates)\\n\\n # update variables\\n self.variables.update(updates)\\n self.log.info(\\\"Variables now %r\\\", self.variables)\",\n \"def step(self):\\n # Pull data from the first available input channel.\\n\\n input_bag = self.get()\\n\\n # todo add timer\\n self.handle_results(input_bag, input_bag.apply(self._stack))\",\n \"def process_thread(self):\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6953273","0.6896622","0.6519482","0.6498906","0.6467285","0.64277387","0.63524014","0.62364155","0.61352557","0.61075705","0.6049684","0.5984105","0.5969542","0.59558064","0.5954331","0.5935271","0.5926765","0.58631474","0.58631474","0.5861994","0.5847282","0.5839918","0.58369464","0.58212095","0.58212095","0.58031344","0.580223","0.580223","0.57864386","0.57864386","0.57864386","0.57813317","0.57796645","0.5774947","0.5772692","0.57564896","0.57417685","0.5726969","0.5726969","0.5726969","0.57221085","0.5720723","0.5720699","0.5704449","0.56781113","0.56769615","0.5651039","0.56502277","0.56480575","0.5631278","0.56282336","0.5609764","0.56077397","0.5597786","0.5581725","0.55719584","0.55649376","0.5555086","0.5552677","0.5550264","0.5550264","0.5540705","0.5539315","0.5532728","0.55302495","0.5529836","0.5527345","0.5513201","0.5504905","0.55039215","0.5471261","0.54624826","0.54528743","0.54377437","0.54313064","0.54267013","0.5417726","0.54148436","0.54039216","0.5387129","0.53778356","0.5365037","0.5363896","0.5354457","0.53542185","0.53517425","0.5335316","0.5328818","0.53287673","0.5327911","0.5324344","0.53212506","0.5319625","0.53111994","0.5307277","0.5292475","0.52806354","0.52804196","0.5279638","0.5272161","0.52665406"],"string":"[\n \"0.6953273\",\n \"0.6896622\",\n \"0.6519482\",\n \"0.6498906\",\n \"0.6467285\",\n \"0.64277387\",\n \"0.63524014\",\n \"0.62364155\",\n \"0.61352557\",\n \"0.61075705\",\n \"0.6049684\",\n \"0.5984105\",\n \"0.5969542\",\n \"0.59558064\",\n \"0.5954331\",\n \"0.5935271\",\n \"0.5926765\",\n \"0.58631474\",\n \"0.58631474\",\n \"0.5861994\",\n \"0.5847282\",\n \"0.5839918\",\n \"0.58369464\",\n \"0.58212095\",\n \"0.58212095\",\n \"0.58031344\",\n \"0.580223\",\n \"0.580223\",\n \"0.57864386\",\n \"0.57864386\",\n \"0.57864386\",\n \"0.57813317\",\n \"0.57796645\",\n \"0.5774947\",\n \"0.5772692\",\n \"0.57564896\",\n \"0.57417685\",\n \"0.5726969\",\n \"0.5726969\",\n \"0.5726969\",\n \"0.57221085\",\n \"0.5720723\",\n \"0.5720699\",\n \"0.5704449\",\n \"0.56781113\",\n \"0.56769615\",\n \"0.5651039\",\n \"0.56502277\",\n \"0.56480575\",\n \"0.5631278\",\n \"0.56282336\",\n \"0.5609764\",\n \"0.56077397\",\n \"0.5597786\",\n \"0.5581725\",\n \"0.55719584\",\n \"0.55649376\",\n \"0.5555086\",\n \"0.5552677\",\n \"0.5550264\",\n \"0.5550264\",\n \"0.5540705\",\n \"0.5539315\",\n \"0.5532728\",\n \"0.55302495\",\n \"0.5529836\",\n \"0.5527345\",\n \"0.5513201\",\n \"0.5504905\",\n \"0.55039215\",\n \"0.5471261\",\n \"0.54624826\",\n \"0.54528743\",\n \"0.54377437\",\n \"0.54313064\",\n \"0.54267013\",\n \"0.5417726\",\n \"0.54148436\",\n \"0.54039216\",\n \"0.5387129\",\n \"0.53778356\",\n \"0.5365037\",\n \"0.5363896\",\n \"0.5354457\",\n \"0.53542185\",\n \"0.53517425\",\n \"0.5335316\",\n \"0.5328818\",\n \"0.53287673\",\n \"0.5327911\",\n \"0.5324344\",\n \"0.53212506\",\n \"0.5319625\",\n \"0.53111994\",\n \"0.5307277\",\n \"0.5292475\",\n \"0.52806354\",\n \"0.52804196\",\n \"0.5279638\",\n \"0.5272161\",\n \"0.52665406\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":24995,"cells":{"query":{"kind":"string","value":"Sample from the provided binary quadratic model."},"document":{"kind":"string","value":"def sample(self, bqm, chain_strength=1.0, **parameters):\n\n # solve the problem on the child system\n child = self.child\n\n # apply the embedding to the given problem to map it to the child sampler\n __, target_edgelist, target_adjacency = child.structure\n\n # add self-loops to edgelist to handle singleton variables\n source_edgelist = list(bqm.quadratic) + [(v, v) for v in bqm.linear]\n\n # get the embedding\n embedding = minorminer.find_embedding(source_edgelist, target_edgelist)\n\n if bqm and not embedding:\n raise ValueError(\"no embedding found\")\n\n bqm_embedded = dimod.embed_bqm(bqm, embedding, target_adjacency, chain_strength=chain_strength)\n\n response = child.sample(bqm_embedded, **parameters)\n\n return dimod.unembed_response(response, embedding, source_bqm=bqm)"},"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 sample(self,noise,s):\n rhs=self.prior.sqrtM*noise\n self.prior.Msolver.solve(s,rhs)","def sample(self, bqm, fixed_variables=None, **parameters):\n return super().sample(bqm, fixed_variables=fixed_variables, **parameters)","def sample(self, bqm, **parameters):\n return self.child.sample(bqm, **parameters)","def _construct_sample_from_input(self):\n xi = T.matrix()\n xo = T.matrix()\n irs = self.ir_steps\n oputs = [self.obs_transform(self.s0)]\n oputs.extend([self.obs_transform(self.si[i]) for i in range(irs)])\n _, hi_zmuv = self._construct_zmuv_samples(xi, 1)\n sample_func = theano.function(inputs=[xi, xo], outputs=oputs, \\\n givens={ self.x_in: xi, \\\n self.x_out: xo, \\\n self.hi_zmuv: hi_zmuv }, \\\n updates=self.scan_updates)\n def conditional_sampler(XI, XO=None, guided_decoding=False):\n XI = to_fX( XI )\n if XO is None:\n XO = XI\n XO = to_fX( XO )\n # set model to desired generation mode\n old_switch = self.train_switch.get_value(borrow=False)\n if guided_decoding:\n # take samples from guide policies (i.e. variational q)\n self.set_train_switch(switch_val=1.0)\n else:\n # take samples from model's generative policy\n self.set_train_switch(switch_val=0.0)\n # draw guided/unguided conditional samples\n model_samps = sample_func(XI, XO)\n # set model back to either training or generation mode\n self.set_train_switch(switch_val=old_switch)\n return model_samps\n return conditional_sampler","def qaoa_sample(\n problem_instance: BinaryProblem,\n beta: numpy.ndarray,\n gamma: numpy.ndarray,\n num_samples: int,\n backend: str = \"qcware/cpu\",\n):\n pass","def _sample(self, X, y):\n self._validate_estimator()\n X_res, y_res = self.tomek_.fit_sample(X, y)\n\n return self.smote_.fit_sample(X_res, y_res)","def sample(self, observation):\n raise NotImplementedError","def sample_qubo(self, Q, **parameters):\n return self.child.sample_qubo(Q, **parameters)","def model_quadratic(train_x, train_y, test_x):\n train_x = train_x.rename('x', axis=1)\n train_x = sm.add_constant(train_x)\n train_df = train_x.copy()\n train_df['y'] = train_y\n model_fit = sm.formula.ols('y ~ np.power(x, 2) + x + const', data=train_df).fit()\n model_info = {'model': 'quadratic', 'R2': model_fit.rsquared, 'f_pvalue': model_fit.f_pvalue,\n 'const': model_fit.params.const}\n test_x = test_x.rename('x')\n test_x = sm.add_constant(test_x)\n predictions = model_fit.predict(test_x)\n return predictions, model_info","def sample(self, x):","def sample(pi, sigma, mu):\n # print(\"sample: pi:\", pi.size(), pi)\n categorical = Categorical(pi)\n pis = list(categorical.sample().data)\n sample = Variable(sigma.data.new(sigma.size(0), sigma.size(2)).normal_())\n for i, idx in enumerate(pis):\n sample[i] = sample[i].mul(sigma[i,idx]).add(mu[i,idx])\n return sample","def test_quadratic_features_explicit():\n X_observed = QuadraticFeatures().fit_transform(X_standardized)\n X_expected = np.hstack(\n [\n X_standardized,\n (X_standardized[:, 0] * X_standardized[:, 0]).reshape((-1, 1)),\n (X_standardized[:, 1] * X_standardized[:, 1]).reshape((-1, 1)),\n (X_standardized[:, 0] * X_standardized[:, 1]).reshape((-1, 1)),\n ]\n )\n np.testing.assert_array_equal(X_observed, X_expected)","def _get_sample(self):\n mu = self._get_mean().reshape((1, self.out_dim))\n sigma = self.variables[\"s\"]\n sample = self.random.normal(mu, sigma)\n sample = sample.reshape(self.out_dim)\n return sample","def sample(self, probs):\n all_abstain = (self.label_matrix == -1).sum(axis=1) == self.label_matrix.shape[1]\n self.is_in_pool = (self.ground_truth_labels == -1) & ~ all_abstain & (self.y_train != -1)\n self.valid_buckets = np.unique(self.unique_inverse[self.is_in_pool])\n self.is_valid_bucket = np.array([\n True if i in self.valid_buckets else False for i in range(len(self.unique_idx))])\n self.bucket_probs = probs.detach().numpy()[self.unique_idx]\n\n pick = random.uniform(0, 1)\n if pick < self.randomness:\n # Choose random bucket instead of following a specific query strategy\n chosen_bucket = np.random.choice(self.valid_buckets)\n else:\n chosen_bucket = np.random.choice(self.query())\n\n return random.choice(np.where((self.unique_inverse == chosen_bucket) & self.is_in_pool)[0])","def sample(self, shape):\n\t\traise NotImplementedError()","def quadratic_fit(self, xy, W):\n\t\t# first construct the independent matrix\n\t\ty = xy[:,1]\n\t\tx = xy[:,0]\n\t\tX = np.column_stack([np.ones(len(x)),\n\t\t\t\t\t\t\tx, np.power(x,2)])\n\n\t\twls_model = sm.WLS(y, X, weights = 1.0/W)\t\n\t\twls_model_results = wls_model.fit()\n\t\t[c,b,a] = wls_model_results.params\t\n\t\treturn [a,b,c]","def sample(self, state, model_args, model_kwargs):\n raise NotImplementedError","def subsample(self, dQ):\n # Assumes self contains sorted Qo and associated T, L\n # Note: calc_Qo is already sorted\n Q = np.arange(self.Qo[0], self.Qo[-1], dQ)\n idx = np.unique(np.searchsorted(self.Qo, Q))\n #print len(idx), len(self.Qo)\n\n self.T, self.dT = self.T[idx], self.dT[idx]\n self.L, self.dL = self.L[idx], self.dL[idx]\n self.Qo, self.dQo = self.Qo[idx], self.dQo[idx]\n if self.R is not None:\n self.R = self.R[idx]\n if self.dR is not None:\n self.dR = self.dR[idx]\n self._set_calc(self.T, self.L)","def sample(self):\n u = np.asarray(np.random.uniform())\n return self.invert(u)","def sample(self):\n raise NotImplementedError","def sample(self):\n raise NotImplementedError","def _sample_beta_and_sigma_y(self):\n phi_X = self.phi(self.X, self.W, add_bias=True)\n cov_j = self.B0 + phi_X.T @ phi_X\n mu_j = np.tile((self.B0 @ self.b0), (self.J, 1)).T + \\\n (phi_X.T @ self.Y)\n # multi-output generalization of mvn sample code\n L = np.linalg.cholesky(cov_j)\n Z = self.rng.normal(size=self.beta.shape).T\n LZ = solve_triangular(L, Z, lower=True, trans='T')\n L_mu = dpotrs(L, mu_j, lower=True)[0]\n self.beta[:] = (LZ + L_mu).T\n # sample from inverse gamma\n a_post = self.gamma_a0 + .5 * self.N\n b_post = self.gamma_b0 + .5 * np.diag(\n (self.Y.T @ self.Y) + \\\n (self.b0 @ self.B0 @ self.b0.T) + \\\n (mu_j.T @ np.linalg.solve(cov_j, mu_j))\n )\n self.sigma_y = 1. / self.rng.gamma(a_post, 1./b_post)","def sample(self):\n sampleIndices = self.random_state.choice(len(self.X), int(len(self.X)*self.sample_ratio), replace=False)\n\n return self.X[sampleIndices]\n pass","def test_quadratic_features_single_column_input_explicit():\n X_observed = QuadraticFeatures().fit_transform(X_standardized[:, 0].reshape((-1, 1)))\n X_expected = np.hstack([X_standardized[:, [0]], (X_standardized[:, 0] * X_standardized[:, 0]).reshape((-1, 1)),])\n np.testing.assert_array_equal(X_observed, X_expected)","def sample(self):\n high = self.high.type(torch.float64) if self.dtype.is_floating_point else self.high.type(torch.int64) + 1\n sample = torch.empty(self.shape, dtype=torch.float64)\n\n # Masking arrays which classify the coordinates according to interval\n # type\n unbounded = ~self.bounded_below & ~self.bounded_above\n upp_bounded = ~self.bounded_below & self.bounded_above\n low_bounded = self.bounded_below & ~self.bounded_above\n bounded = self.bounded_below & self.bounded_above\n\n # Vectorized sampling by interval type\n sample[unbounded] = torch.randn(unbounded[unbounded].shape, dtype=torch.float64)\n\n sample[low_bounded] = (-torch.rand(low_bounded[low_bounded].shape, dtype=torch.float64)).exponential_() + \\\n self.low[low_bounded]\n\n sample[upp_bounded] = self.high[upp_bounded] - (\n -torch.rand(upp_bounded[upp_bounded].shape, dtype=torch.float64)).exponential_()\n\n sample[bounded] = (self.low[bounded] - high[bounded]) * torch.rand(bounded[bounded].shape,\n dtype=torch.float64) + high[bounded]\n\n if not self.dtype.is_floating_point: # integer\n sample = torch.floor(sample)\n\n return sample.type(self.dtype)","def draw_bs_sample(data):\n return rg.choice(data, size=len(data))","def next_sample(self, z):\n xp = self.A @ self.x\n Pp = self.A @ self.P @ self.A.T + self.Q\n\n self.K = Pp @ self.H.T * inv(self.H @ Pp @ self.H.T + self.R)\n\n self.x = xp + self.K @ (np.array(np.array([[z]]) - self.H @ xp))\n self.P = Pp - self.K @ self.H @ Pp\n\n self.volt = self.x[0]\n return self.volt","def sample_from_unit_ball(rng, dim):\n vec = rng.randn(dim)\n return vec / np.sqrt(np.sum(vec**2))","def sample(self, nframes):\n if not self.__is_valid:\n raise GmParamError(\"\"\"Parameters of the model has not been \n set yet, please set them using self.set_param()\"\"\")\n\n # State index (ie hidden var)\n sti = gen_rand_index(self.w, nframes)\n # standard gaussian samples\n x = randn(nframes, self.d) \n\n if self.mode == 'diag':\n x = self.mu[sti, :] + x * N.sqrt(self.va[sti, :])\n elif self.mode == 'full':\n # Faster:\n cho = N.zeros((self.k, self.va.shape[1], self.va.shape[1]))\n for i in range(self.k):\n # Using cholesky looks more stable than sqrtm; sqrtm is not\n # available in numpy anyway, only in scipy...\n cho[i] = lin.cholesky(self.va[i*self.d:i*self.d+self.d, :])\n\n for s in range(self.k):\n tmpind = N.where(sti == s)[0]\n x[tmpind] = N.dot(x[tmpind], cho[s].T) + self.mu[s]\n else:\n raise GmParamError(\"cov matrix mode not recognized, \"\\\n \"this is a bug !\")\n\n return x","def sample_from(space):\n distrs = {\n 'choice': choice,\n 'randint': randint,\n 'uniform': uniform,\n 'normal': normal,\n }\n s = space[0]\n\n np.random.seed(int(time.time() + np.random.randint(0, 300)))\n\n log = s.startswith('log_')\n s = s[len('log_'):] if log else s\n\n quantized = s.startswith('q')\n s = s[1:] if quantized else s\n\n distr = distrs[s]\n if s == 'choice':\n return distr(space[1])\n samp = distr(space[1], space[2])\n if log:\n samp = np.exp(samp)\n if quantized:\n samp = round((samp / space[3]) * space[3])\n return samp","def sample(self,p0=None,nsamp=None): \r\n raise NotImplementedError('Need to implement sample function')","def sample(self):\r\n raise NotImplementedError","def signalroisample(filename,obs):\n from samplingdist import readworkspace,readfile\n #f,w,obsdict,modeldict,databkgdict,datasigdict = readworkspace(filename)\n f,obsdict,modeldict,databkgdict,datasigdict = readfile(filename)\n if not obsdict.has_key(obs):\n raise RuntimeError(\"Observable '%s' not defined\" % obs)\n sd = ObservableSamplingProb(obsdict[obs])\n sd.setupmodel('bkg','negative_binomial_pdf')\n sd.setupmodel('sig','negative_binomial_sum_pdf')\n\n datasig = datasigdict['dvsig_'+obs]\n databkg = databkgdict['dvbkg_'+obs]\n sd.fitTo(datasig,'sig')\n sd.fitTo(databkg,'bkg')\n\n samplename = filename.split('_')[1]\n sd.plot(samplename,datasig,'sig',sample=samplename+'_sig')\n sd.plot(samplename,databkg,'bkg',sample=samplename+'_bkg')\n\n nfile = filename.split('_')[1]+'_bkgsig_'+obs+'_ws.root'\n sd.update('w',nfile,[datasig,databkg])","def sample(self, shape=(1,)):\n pass","def _sample(self, geometry: Geometry) -> math.Tensor:\n raise NotImplementedError(self)","def sample(self):\n return self(np.random.randn(self.num_xi)).reshape(self.X.shape)","def generate_sample(self):\n\n sample_one = np.zeros(self.n_dimensions)\n\n \"\"\"C: Huge gains here from using numpy functions at once instead of a Python loop\"\"\"\n \"\"\"S: How..?\"\"\"\n\n for i in range(self.n_dimensions):\n self.Y[i] ^= self.V[\n self.index_of_least_significant_zero_bit(self.current - 1), i\n ]\n sample_one[i] = float(self.Y[i] / math.pow(2, self.scale))\n self.current += 1\n return sample_one","def sample_box(self, dim0, dim1=None, bounds=None, lp_rule=None, verbose=False):\n\n # TODO: include in get_par\n\n import chaospy\n\n bnd = bounds or np.array(self.fdict['prior_bounds'])\n dim1 = dim1 or self.ndim\n rule = lp_rule or 'S'\n\n res = chaospy.Uniform(0, 1).sample(size=(dim0, dim1), rule=rule)\n res = (bnd[1] - bnd[0])*res + bnd[0]\n\n return res","def sample_utility(n, model, alpha, beta, bmax):\n A, b = matrix(0.0, (n,n)), matrix(ra.uniform(0,bmax,(n,1)))\n \n if model == 1: A = matrix(ra.uniform(0,beta,(n,n)))\n \n if model == 2:\n for i in range(n):\n for j in range(n/2):\n A[i, int(np.mod(i+j+1,n))] = beta**(j+1)\n A[i, int(np.mod(i-(j+1),n))] = beta**(j+1)\n \n if model == 3: A = 0.5*matrix(ra.binomial(1,beta,(n,n)))\n \n for i in range(n): A[i,i] = 1.0\n \n return Utility((alpha*A,b), 'sqrt')","def test_quadratic_trinomial_init(self):\n a, b, c = 2, 3, 4\n expected = Polynomial(a, b, c)\n\n qt = QuadraticTrinomial(a, b, c)\n\n self.assertEqual(expected, qt)","def sample(x,u):\n if ispoint(x):\n # return pointsample(x)\n return point(x)\n elif isline(x):\n return sampleline(x,u)\n elif isarc(x):\n return samplearc(x,u)\n elif ispoly(x):\n return samplepoly(x,u)\n elif isgeomlist(x):\n return samplegeomlist(x,u)\n else:\n raise ValueError(\"inappropriate type for sample(): \" + str(x))","def draw_bs_sample(data):\n return np.random.choice(data, size=len(data))","def sample(self):\n M = np.random.normal(self._mu.reshape(-1), self._sig).reshape(self.shape)\n return M","def sampling_latent(self):\n \n self.z = gaussian_sample(self.qz_m, self.qz_v)\n if self.scalings:\n self.library = gaussian_sample(self.ql_m, self.ql_v)","def test_proof_model():\n m = build_proof_model()\n with m:\n trace = pm.sample(50)\n assert trace.report.ok","def test_simpSample(self):\n\n #uniform dist\n ulim = [0,1]\n ufun = lambda x: 1.0/np.diff(ulim)\n\n n = int(1e5)\n usample = statsFun.simpSample(ufun,n,ulim[0],ulim[1])\n self.assertGreaterEqual(usample.min(), ulim[0])\n self.assertLessEqual(usample.max(), ulim[1])\n\n nlim = [-10,10]\n nfun = lambda x: np.exp(-x**2./2.0)/np.sqrt(2.0*np.pi)\n nsample = statsFun.simpSample(nfun,n,nlim[0],nlim[1])\n self.assertGreaterEqual(nsample.min(), nlim[0])\n self.assertLessEqual(nsample.min(), nlim[1])\n\n self.assertGreaterEqual(scipy.stats.kstest(usample,'uniform')[1],0.01,'Uniform sample does not look uniform.')\n self.assertGreaterEqual(scipy.stats.kstest(nsample,'norm')[1],0.01,'Normal sample does not look normal.')\n self.assertLessEqual(scipy.stats.kstest(nsample,'uniform')[1],0.01,'Normal sample looks too uniform.')\n self.assertLessEqual(scipy.stats.kstest(usample,'norm')[1],0.01,'Uniform sample looks too normal.')","def in_square():\n return np.random.random_sample(size=2)","def sample(self, seg_logit, seg_label):","def estimate_sample_beta(sample):\n x_s, y_s = zip(*sample)\n reg.fit(x_s, y_s)\n betas = reg.weights_\n return betas","def _construct_sample_from_prior(self):\n z_sym = T.matrix()\n x_sym = T.matrix()\n irs = self.ir_steps\n oputs = [self.obs_transform(self.s0)]\n oputs.extend([self.obs_transform(self.si[i]) for i in range(irs)])\n _, hi_zmuv = self._construct_zmuv_samples(x_sym, 1)\n sample_func = theano.function(inputs=[z_sym, x_sym], outputs=oputs, \\\n givens={ self.z: z_sym, \\\n self.x_in: T.zeros_like(x_sym), \\\n self.x_out: T.zeros_like(x_sym), \\\n self.hi_zmuv: hi_zmuv }, \\\n updates=self.scan_updates)\n def prior_sampler(samp_count):\n x_samps = to_fX( np.zeros((samp_count, self.obs_dim)) )\n old_switch = self.train_switch.get_value(borrow=False)\n # set model to generation mode\n self.set_train_switch(switch_val=0.0)\n z_samps = to_fX( npr.randn(samp_count, self.z_dim) )\n model_samps = sample_func(z_samps, x_samps)\n # set model back to either training or generation mode\n self.set_train_switch(switch_val=old_switch)\n return model_samps\n return prior_sampler","def eval_sampling_point(self, sampling_point):\n return Solution(self, sampling_point)","def sample_from(self):\n return numpy.random.normal(self.mu, math.sqrt(self.sigma))","def test_sample(self, normal_mock):\n # Setup\n instance = GaussianMultivariate(GaussianUnivariate)\n data = pd.DataFrame([\n {'A': 25, 'B': 75, 'C': 100},\n {'A': 30, 'B': 60, 'C': 250},\n {'A': 10, 'B': 65, 'C': 350},\n {'A': 20, 'B': 80, 'C': 150},\n {'A': 25, 'B': 70, 'C': 500}\n ])\n instance.fit(data)\n\n normal_mock.return_value = np.array([\n [0.1, 0.1, 0.1],\n [0.2, 0.2, 0.2],\n [0.4, 0.4, 0.4],\n [0.6, 0.6, 0.6],\n [0.8, 0.8, 0.8]\n ])\n\n expected_result = pd.DataFrame([\n {'A': 22.678232998312527, 'B': 70.70710678118655, 'C': 284.35270009440734},\n {'A': 23.356465996625055, 'B': 71.41421356237309, 'C': 298.7054001888146},\n {'A': 24.712931993250110, 'B': 72.82842712474618, 'C': 327.4108003776293},\n {'A': 26.069397989875164, 'B': 74.24264068711929, 'C': 356.116200566444},\n {'A': 27.425863986500215, 'B': 75.65685424949238, 'C': 384.8216007552586}\n ])\n\n # Run\n result = instance.sample(5)\n\n # Check\n assert result.equals(expected_result)\n\n assert normal_mock.called_once_with(\n np.zeros(instance.covariance.shape[0]),\n instance.covariance,\n 5\n )","def test_quadratic_features_random_state_invariance():\n transformer1 = QuadraticFeatures(random_state=0)\n transformer2 = QuadraticFeatures(random_state=0)\n X1 = transformer1.fit_transform(X_small)\n X2 = transformer2.fit_transform(X_small)\n assert np.all(X1 == X2)","def stocksolution(self):\n return Sample(self.solutes, self.quantities, self.volume, True)","def sample_posterior(self):\n \n# print (\"SAMPLING FROM LINEAR SIMILARITY VB\")\n if (self.posterior_mean == False):\n self.weight = Vil.sample_posterior(self.mu_weight, Vil.softplus(self.rho_weight))\n self.bias = Vil.sample_posterior(self.mu_bias, Vil.softplus(self.rho_bias))\n# print (self.bias)\n else:\n self.weight.data = self.mu_weight.data\n self.bias.data = self.mu_bias.data","def fit(sample):\r\n if not hasattr(sample, \"stddev\"):\r\n sample = Sample(sample)\r\n m = sample.mean\r\n d = sqrt(12*sample.variance)/2\r\n return Uniform(m-d, m+d)","def test_oss_sample_wt_fit():\n\n # Create the object\n oss = OneSidedSelection(random_state=RND_SEED)\n assert_raises(RuntimeError, oss.sample, X, Y)","def sample(problem, seed=None):\n if seed:\n np.random.seed(seed)\n contrast = generate_contrast(problem)\n sample = np.array((contrast + 1.0) / 2, dtype=float)\n problem = extend_bounds(problem)\n\n sample = scale_samples(sample, problem)\n return sample","def _get_sample(self):\n mu = self._get_mean()\n sample = self.random.normal(mu)\n return sample","def next_sample(self, z):\n xp = self.A @ self.x\n Pp = self.A @ self.P @ self.A.T + self.Q\n\n self.K = Pp @ self.H.T * inv(self.H @ Pp @ self.H.T + self.R)\n\n self.x = xp + self.K @ (z - self.H @ xp)\n self.P = Pp - self.K @ self.H @ Pp\n return self.x","def bqm_structured(f):\n @wraps(f)\n def structured_sample(sampler, bqm, **kwargs):\n adjacency = sampler.adjacency\n\n if not adjacency.keys() >= bqm.variables:\n raise BinaryQuadraticModelStructureError(\n f\"given bqm has at least one variable, {(list(bqm.variables) - adjacency.keys()).pop()!r}, \"\n \"not supported by the structured solver\")\n if any(u not in adjacency[v] for u, v, _ in bqm.iter_quadratic()):\n u, v = next((u, v) for u, v, _ in bqm.iter_quadratic() if u not in adjacency[v])\n raise BinaryQuadraticModelStructureError(\n f\"given bqm contains an interaction, {(u, v)!r}, \"\n \"not supported by the structured solver\")\n return f(sampler, bqm, **kwargs)\n return structured_sample","def sample_uniform():\n global samples_uniform, isample_uniform\n\n # sample of U(0, 1)\n u = samples_uniform[isample_uniform]\n\n # moving to next index of samples global array\n isample_uniform += 1\n if isample_uniform >= len(samples_uniform):\n # exhausted all samples -> re-drawing samples from U(0, 1)\n samples_uniform = np.random.uniform(size=SIZE_SAMPLES_UNIFORM)\n isample_uniform = 0\n\n return u","def sample(self, x: Union[np.ndarray, float, list], ):\n x = self._sample_test(x)\n if x.ndim <= 1:\n y = 0\n for i in range(self.mixture_count):\n if self.dimensions == 1:\n y += self.weights[i] * self.one_d_normal(x, self.means[i], self.covs[i])\n else:\n y += self.weights[i] * self.multi_d_gauss(x, self.means[i], self.covs[i])\n else:\n x = np.squeeze(x, axis=1)\n y = np.zeros((x.shape[0], ))\n for i in range(self.mixture_count):\n if self.dimensions == 1:\n y += self.weights[i] * self.one_d_normal(x, self.means[i], self.covs[i])\n else:\n y += self.weights[i] * self.multi_d_gauss(x, self.means[i], self.covs[i])\n return y","def sample_py3(self):\n print(self.weights_.shape)\n try:\n n_samples_comp = self.rng.multinomial(self.n_samples, self.weights_)\n except ValueError:\n self.weights_= np.reshape(self.weights_,len(self.weights_))\n n_samples_comp = self.rng.multinomial(self.n_samples, self.weights_)\n if self.covariance_type == 'full':\n X = np.vstack([\n self.rng.multivariate_normal(mean, covariance, int(sample))\n for (mean, covariance, sample) in zip(\n self.means_, self.covariances_, n_samples_comp)])\n elif self.covariance_type == \"tied\":\n X = np.vstack([\n self.rng.multivariate_normal(mean, self.covariances_, int(sample))\n for (mean, sample) in zip(\n self.means_, n_samples_comp)])\n else:\n X = np.vstack([\n mean + self.rng.randn(sample, n_features) * np.sqrt(covariance)\n for (mean, covariance, sample) in zip(\n self.means_, self.covariances_, n_samples_comp)])\n\n y = np.concatenate([j * np.ones(sample, dtype=int)\n for j, sample in enumerate(n_samples_comp)])\n\n return (X, y)","def quadratic_program_bnd(self, c, Q, lb, ub):\n if self.solver == solver_SCIPY:\n return scipy_quadratic_program_bnd(c, Q, lb, ub)\n elif self.solver == solver_GUROBI:\n return gurobi_quadratic_program_bnd(c, Q, lb, ub)\n else:\n raise ValueError('QP solver %s not available' % self.solver)","def binary_sample(x):\n return np.random.binomial(1, p=x)","def sample(self, i):\n\t\tif self.nsamp % 2 == 0:\n\t\t\ti0 = i-(self.nsamp/2-1)\n\t\t\ti1 = i+(self.nsamp/2)\n\t\telse:\n\t\t\ti0 = i-((self.nsamp-1)/2.)\n\t\t\ti1 = i+((self.nsamp-1)/2.)\n\t\treturn self.yval[i0:i1]","def test_simpSample_trivial(self):\n\n ulim = [0,1]\n ufun = lambda x: 1.0/np.diff(ulim)\n\n n = 10000\n sample = statsFun.simpSample(ufun,n,0.5,0.5)\n\n self.assertEqual(len(sample),n)\n self.assertTrue(np.all(sample == 0.5))","def test_quadratic_features_shape(include_bias, interaction_only, n_output_features):\n transformer = QuadraticFeatures(include_bias=include_bias, interaction_only=interaction_only,)\n XQ = transformer.fit_transform(X_small)\n assert XQ.shape == (X_small_n_rows, n_output_features)","def samplepoint(x,u):\n return point(x)","def sample(self):\n # return [v.sample() for v in self.variables]\n return self.domain[gc.rand_state.choice(len(self.domain))]","def test_quadratic_trinomial_default_init(self):\n expected = Polynomial(1, 1, 1)\n\n qt = QuadraticTrinomial()\n\n self.assertEqual(expected, qt)","def sample_mu(self, val) -> None:\n\n # get data\n data = self.data.reshape((1, -1))\n\n # get values\n gain = val.gain\n states = val.states\n mu_flor = val.mu_flor\n mu_flor_mean = val.mu_flor_mean\n mu_flor_shape = val.mu_flor_shape\n mu_back = val.mu_back\n mu_back_mean = val.mu_back_mean\n mu_back_shape = val.mu_back_shape\n num_data = val.num_data\n num_rois = val.num_rois\n num_states = val.num_states\n\n # initialze variables\n num_vars = num_states + num_rois\n idx = np.where(val.mu_flor_mean > 0)[0]\n # shape\n shape = np.zeros((num_vars, 1))\n shape[:num_states, 0] = mu_flor_shape[:]\n shape[num_states:, 0] = mu_back_shape\n # scale\n scale = np.zeros((num_vars, 1))\n scale[idx, 0] = mu_flor_mean[idx] / mu_flor_shape[idx]\n scale[num_states:, 0] = (mu_back_mean / mu_back_shape)[:]\n\n # initialize a mu vector containing the variables we wish to sample, mu_flor and mu_back\n q = np.zeros((num_vars, 1))\n q[:num_states, 0] = mu_flor[:]\n q[num_states:, 0] = mu_back[:]\n q_old = q.copy()\n idy = q > 0 # keep track of which states are dark (we only sample bright states)\n num_var = q.shape[0]\n\n # hmc dynamics variables\n h = np.random.exponential() / 100\n masses = (1 + np.random.pareto(1, size=q.shape))\n masses_inv = np.zeros(shape=masses.shape) # negative mass is interpretted as an unchanging variable\n masses_inv[masses > 0] = 1 / masses[masses > 0]\n num_steps = np.random.poisson(25)\n\n # create populations array\n pops = np.zeros((num_vars, num_rois * num_data))\n \"\"\"\n pops is an array such that each element i, j corresponds to the \n multiplicitive factor in front of q[i] for data point j in the \n likelihood. For example, if in ROI 1 at time level 17 there are two\n fluorophores in the bright state, then we find the element, j,\n corresponding to ROI 1 and time level 17, and we find the element,\n i, corresponding to the bright state, and we set q[i,j]=2 (because\n there are two bright fluorophores), then we would find the i\n corresponding to the background brightness of ROI 1, and we would\n set this q[i,j]=1 (the multiplicitive factor in front of the \n background brightness is 1 when it is the corresponding ROI and 0\n otherwise).\n \"\"\"\n for r in range(num_rois):\n idx = np.arange(r*num_data, (r+1)*num_data)\n pops[:num_states, idx] = states_to_pops(states[r, :, :], num_states)\n pops[num_states + r, idx] = 1\n\n # the conditional probability for the mu vector\n def probability(q_, p_):\n if np.sum(q_ < 0) > 0:\n prob = -np.inf\n else:\n prob = (\n np.sum(stats.gamma.logpdf(data, a=q_.T @ pops, scale=gain)) # likelihood\n + np.sum(stats.gamma.logpdf(q_[idy], a=shape[idy], scale=scale[idy])) # prior\n + np.sum(stats.norm.logpdf(p_[idy], loc=0, scale=np.sqrt(masses[idy]))) # momentum\n )\n return prob\n\n # the gradient of the Hamiltonian with respect to the mu_vector\n def dH_dq(q_):\n if np.any(q_ < 0):\n \"\"\"\n In the event that q_new becomes negative, fast_digamma becomes\n slow. Since q should never be negative anyway, there is no\n need for further computation and we can skip this step knowing\n that this value of q will be rejected anyway.\n \"\"\"\n return q_\n q_new = np.zeros(q_.shape)\n q_new[idy] = (\n (shape[idy] - 1) / q_[idy] - 1 / scale[idy]\n + (pops @ (np.log(data / gain) - fast_digamma(q_.T @ pops)).T)[idy]\n )\n return q_new\n\n # sample momentum\n p = np.random.randn(num_var, 1) * np.sqrt(masses)\n p_old = p.copy()\n\n # run the HMC\n for i in range(num_steps):\n p = p + .5 * h * dH_dq(q)\n q = q + h * p * masses_inv\n p = p + .5 * h * dH_dq(q)\n\n # find acceptance ratio\n P_new = probability(q, p)\n P_old = probability(q_old, p_old)\n if (P_new - P_old) < np.log(np.random.rand()):\n q = q_old\n\n # update the new mu values\n val.mu_flor[:] = q[:num_states, 0]\n val.mu_back[:] = q[num_states:, 0]\n\n return","def to_bqm(self, model):\n linear = ((v, float(model.get_py_value(bias)))\n for v, bias in self.linear.items())\n quadratic = ((u, v, float(model.get_py_value(bias)))\n for (u, v), bias in self.quadratic.items())\n offset = float(model.get_py_value(self.offset))\n\n return BQM(linear, quadratic, offset, dimod.SPIN)","def sample(self):\n\n # pick sample type according to probability\n samplers = [\"unif\", \"geo\", \"diverse\"]\n sample_idx = np.random.multinomial(\n 1, [self.unif_prob, self.geo_prob, self.diverse_prob])\n idx = np.argmax(sample_idx)\n sampler = samplers[idx]\n\n if sampler == \"unif\":\n return self.unif_sampler()\n if sampler == \"geo\":\n return self.geo_sampler()\n if sampler == \"diverse\":\n return self.diverse_sampler()","def sample(wave, factor):\n ys = np.zeros(len(wave))\n ys[::factor] = np.real(wave.ys[::factor])\n return Wave(ys, framerate=wave.framerate)","def _sample(self, points: Iterable[float]) -> np.array:\n pass","def sample(self, m):\n i = torch.multinomial(self.weights, m, replacement=True)\n return self.particles[i,:]","def _SampleInputMatrix(nrows, bl, bu, distname='randomUniform'):\n npars = len(bl)\n x = np.zeros((nrows,npars))\n bound = bu-bl\n for i in range(nrows):\n # x[i,:]= bl + DistSelector([0.0,1.0,npars],distname='randomUniform')*bound # only used in full Vhoeys-framework\n x[i,:]= bl + np.random.rand(1,npars)*bound\n return x","def samplepoly(a,u):\n \n if not ispoly(a):\n raise ValueError('non-poly passed to samplepoly')\n\n closed=False\n\n lines,lengths,length = __lineslength(a)\n if len(a) > 2 and dist(a[0],a[-1]) < epsilon:\n closed = True\n\n if closed:\n u=u%1.0\n \n dst = u * length;\n d = 0\n if u < 1.0:\n for i in range(len(lines)):\n l=lengths[i]\n if dst <= d+l:\n uu = 1.0 - (d+l-dst)/l\n return sampleline(lines[i],uu)\n else:\n d+=l\n else:\n uu = (dst-length+lengths[-1])/lengths[-1]\n return sampleline(lines[-1],uu)","def sample(self, sample_shape=torch.Size()):\n with torch.no_grad():\n return self.rsample(sample_shape=sample_shape)","def sample(self, point, n_samples=1):\n raise NotImplementedError(\"The sample method is not yet implemented.\")","def rational_quadratic(input_dim, variance=1., lengthscale=1., power=1.):\r\n part = parts.rational_quadratic.RationalQuadratic(input_dim, variance, lengthscale, power)\r\n return kern(input_dim, [part])","def get_uniform_subset(self, samples_per_label):\n raise NotImplementedError","def sample(self, s):\n rng = np.random.default_rng()\n return rng.choice(np.arange(self.n_actions), p=self.eval(s))","def sample_b(self):\n # don't sample b-factors with em\n if not self.options.sample_bfactors or self.options.em:\n return\n\n new_coor = []\n new_bfactor = []\n multiplication_factors = [1.0, 1.3, 1.5, 0.9, 0.5]\n coor_b_pairs = zip(self._coor_set, self._bs)\n for (coor, b), multi in itertools.product(coor_b_pairs, multiplication_factors):\n new_coor.append(coor)\n new_bfactor.append(b * multi)\n self._coor_set = new_coor\n self._bs = new_bfactor","def sample_from_simplex(rng, dim):\n alpha = [1] * dim\n return rng.dirichlet(alpha)","def get_sample(x, y):\n return noise[x][y]","def sample(self) -> np.ndarray:\n q_target = np.empty(self.d)\n for i in range(self.d):\n q_target[i] = self.lim_lo[i] + np.random.rand() * (self.lim_up[i] - self.lim_lo[i])\n return q_target","def sample_spherical(self):\n vec = np.random.randn(self.dims, self.arms)\n vec /= np.linalg.norm(vec, axis=0)\n self.contexts = vec.T","def initial_samples(lb, ub, method, numSamp):\r\n if not len(lb) == len(ub):\r\n raise AssertionError('Lower and upper bounds have different #s of design variables in initial_samples function.')\r\n assert method == 'random' or method == 'nolh' or method == 'nolh-rp' or method == 'nolh-cdr' or method == 'lhc' or method == 'rand-wor', 'An invalid method was specified for the initial_samples.'\r\n assert (method == 'nolh' or method == 'nolh-rp' or method == 'nolh-cdr') and len(ub) >= 2 and len(ub) <= 29, 'The Phase space dimensions are outside of the bounds for initial_samples.'\r\n for case in Switch(method):\r\n if case('random'):\r\n s = np.zeros((numSamp, len(lb)))\r\n for i in range(0, numSamp, 1):\r\n s[i, :] = lb + (ub - lb) * rand(len(lb))\r\n\r\n break\r\n if case('rand-wor'):\r\n s = np.zeros((numSamp, len(lb)))\r\n for i in range(0, numSamp, 1):\r\n s[i, :] = choice(len(ub), size=len(ub), replace=False)\r\n\r\n break\r\n if case('nolh'):\r\n dim = len(ub)\r\n m, q, r = params(dim)\r\n conf = range(q)\r\n if r != 0:\r\n remove = range(dim - r, dim)\r\n nolh = NOLH(conf, remove)\r\n else:\r\n nolh = NOLH(conf)\r\n s = np.array([ list(lb + (ub - lb) * nolh[i, :]) for i in range(len(nolh[:, 0]))\r\n ])\r\n break\r\n if case('nolh-rp'):\r\n dim = len(ub)\r\n m, q, r = params(dim)\r\n conf = random.sample(range(q), q)\r\n if r != 0:\r\n remove = random.sample(range(q - 1), r)\r\n nolh = NOLH(conf, remove)\r\n else:\r\n nolh = NOLH(conf)\r\n s = np.array([ list(lb + (ub - lb) * nolh[i, :]) for i in range(len(nolh[:, 0]))\r\n ])\r\n break\r\n if case('nolh-cdr'):\r\n dim = len(ub)\r\n m, q, r = params(dim)\r\n conf, remove = get_cdr_permutations(len(ub))\r\n if remove != []:\r\n nolh = NOLH(conf, remove)\r\n else:\r\n nolh = NOLH(conf)\r\n s = np.array([ list(lb + (ub - lb) * nolh[i, :]) for i in range(len(nolh[:, 0]))\r\n ])\r\n break\r\n if case('lhc'):\r\n tmp = lhs(len(lb), samples=numSamp, criterion='center')\r\n s = np.array([ list(lb + (ub - lb) * tmp[i, :]) for i in range(len(tmp[:, 0]))\r\n ])\r\n break\r\n if case():\r\n print 'Somehow you evaded my assert statement - good job!',\r\n print ' However, you still need to use a valid method string.'\r\n\r\n return s","def evalQuad(a,b,c,x):\n return a * x**2 + b*x + c","def sample(self, x):\n x_minus_mu = x - self.mu\n pwr = -(np.dot(np.dot (x_minus_mu.transpose(), self.cov_inv),\n x_minus_mu) / 2.0)\n return math.exp(pwr) #/ self.root_2pi_d_det","def sample_random_architecture(self, dataset_api):\n while True:\n matrix = np.random.choice(\n [0, 1], size=(NUM_VERTICES, NUM_VERTICES))\n matrix = np.triu(matrix, 1)\n ops = np.random.choice(OPS, size=NUM_VERTICES).tolist()\n ops[0] = INPUT\n ops[-1] = OUTPUT\n spec = dataset_api['api'].ModelSpec(matrix=matrix, ops=ops)\n if dataset_api['nb101_data'].is_valid(spec):\n break\n \n self.set_spec({'matrix':matrix, 'ops':ops})","def sample_survey(self, **kwargs):","def sampling_algorithm(self, X, y):\r\n n_to_sample = self.det_n_to_sample(self.proportion)\r\n\r\n if n_to_sample == 0:\r\n return self.return_copies(X, y, \"Sampling is not needed\")\r\n\r\n X_min = X[y == self.min_label]\r\n X_maj = X[y == self.maj_label]\r\n\r\n # fitting nearest neighbors model to find closest majority points to\r\n # minority samples\r\n nn_params = {**self.nn_params}\r\n nn_params['metric_tensor'] = \\\r\n self.metric_tensor_from_nn_params(nn_params, X, y)\r\n\r\n density = self.calculate_density(X_min, X_maj, nn_params)\r\n\r\n # fitting nearest neighbors model to minority samples to run\r\n # SMOTE-like sampling\r\n n_neighbors = min([len(X_min), self.n_neighbors+1])\r\n nnmt = NearestNeighborsWithMetricTensor(n_neighbors=n_neighbors,\r\n n_jobs=self.n_jobs,\r\n **nn_params)\r\n nnmt.fit(X_min)\r\n ind = nnmt.kneighbors(X_min, return_distance=False)\r\n\r\n samples = self.sample_simplex(X=X_min,\r\n indices=ind,\r\n n_to_sample=n_to_sample,\r\n base_weights=density)\r\n\r\n # do the sampling\r\n #samples = []\r\n #while len(samples) < n_to_sample:\r\n # idx = self.random_state.choice(np.arange(len(density)), p=density)\r\n # random_neighbor_idx = self.random_state.choice(ind[idx][1:])\r\n # X_a = X_min[idx]\r\n # X_b = X_min[random_neighbor_idx]\r\n # samples.append(self.sample_between_points(X_a, X_b))\r\n\r\n return (np.vstack([X, samples]),\r\n np.hstack([y, np.repeat(self.min_label, len(samples))]))","def test_gradient_exception_on_sample(self):\n dev = qml.device(\"default.qubit\", wires=2, shots=1000)\n\n @qml.qnode(dev, diff_method=\"parameter-shift\")\n def circuit(x):\n qml.RX(x, wires=[0])\n return qml.sample(qml.PauliZ(0)), qml.sample(qml.PauliX(1))\n\n with pytest.raises(\n qml.QuantumFunctionError,\n match=\"Circuits that include sampling can not be differentiated.\",\n ):\n grad_fn = autograd.jacobian(circuit)\n grad_fn(1.0)","def sample(self):","def varietySample(V, x, count_max, R2, eps_bound):\n \n #x = np.array(V.gens);\n N = len(x)\n t = sp.symbols(\"t\") #Parameter of line\n #count_max = 200\n count = 0\n #N = length(x)\n P = np.empty([N,0])\n while count < count_max:\n # Corrupt the variety with bounded noise \n epsilon = np.random.uniform(-eps_bound, eps_bound)\n Ve = V + epsilon \n \n # Get a line u + v t in space \n U = sp.Matrix(np.random.randn(2, N+1));\n Ur = np.array(U.rref()[0].transpose().tolist(), dtype=float)\n u = Ur[1:, 0]\n v = Ur[1:, 1]\n \n L = u + v * t \n \n #substitute in the line and find real roots\n VL = Ve.subs([i for i in zip(x, L)])\n cVL = sp.Poly(VL).coeffs()\n rVL = np.roots(cVL)\n r_real = np.real(rVL[np.isreal(rVL)])\n \n \n \n #recover points of intersection and append to array\n p = u[:, np.newaxis] + np.outer(v, r_real) \n pnorm = np.sum(p**2, 0)\n \n pcand= p[:, pnorm <= R2]\n\n # if pcand.shape[1] <= 1:\n # pcand0 = pcand\n # else:\n # #pcand0 = pcand[:, 0]\n # pcand0 = pcand[..., 0][:, np.newaxis] #this is dumb\n #\n # P = np.concatenate([P, pcand0], 1)\n P = np.concatenate([P, pcand], 1)\n \n #start new sampling iteration\n count = count + np.size(pcand, 1)\n \n return P"],"string":"[\n \"def sample(self,noise,s):\\n rhs=self.prior.sqrtM*noise\\n self.prior.Msolver.solve(s,rhs)\",\n \"def sample(self, bqm, fixed_variables=None, **parameters):\\n return super().sample(bqm, fixed_variables=fixed_variables, **parameters)\",\n \"def sample(self, bqm, **parameters):\\n return self.child.sample(bqm, **parameters)\",\n \"def _construct_sample_from_input(self):\\n xi = T.matrix()\\n xo = T.matrix()\\n irs = self.ir_steps\\n oputs = [self.obs_transform(self.s0)]\\n oputs.extend([self.obs_transform(self.si[i]) for i in range(irs)])\\n _, hi_zmuv = self._construct_zmuv_samples(xi, 1)\\n sample_func = theano.function(inputs=[xi, xo], outputs=oputs, \\\\\\n givens={ self.x_in: xi, \\\\\\n self.x_out: xo, \\\\\\n self.hi_zmuv: hi_zmuv }, \\\\\\n updates=self.scan_updates)\\n def conditional_sampler(XI, XO=None, guided_decoding=False):\\n XI = to_fX( XI )\\n if XO is None:\\n XO = XI\\n XO = to_fX( XO )\\n # set model to desired generation mode\\n old_switch = self.train_switch.get_value(borrow=False)\\n if guided_decoding:\\n # take samples from guide policies (i.e. variational q)\\n self.set_train_switch(switch_val=1.0)\\n else:\\n # take samples from model's generative policy\\n self.set_train_switch(switch_val=0.0)\\n # draw guided/unguided conditional samples\\n model_samps = sample_func(XI, XO)\\n # set model back to either training or generation mode\\n self.set_train_switch(switch_val=old_switch)\\n return model_samps\\n return conditional_sampler\",\n \"def qaoa_sample(\\n problem_instance: BinaryProblem,\\n beta: numpy.ndarray,\\n gamma: numpy.ndarray,\\n num_samples: int,\\n backend: str = \\\"qcware/cpu\\\",\\n):\\n pass\",\n \"def _sample(self, X, y):\\n self._validate_estimator()\\n X_res, y_res = self.tomek_.fit_sample(X, y)\\n\\n return self.smote_.fit_sample(X_res, y_res)\",\n \"def sample(self, observation):\\n raise NotImplementedError\",\n \"def sample_qubo(self, Q, **parameters):\\n return self.child.sample_qubo(Q, **parameters)\",\n \"def model_quadratic(train_x, train_y, test_x):\\n train_x = train_x.rename('x', axis=1)\\n train_x = sm.add_constant(train_x)\\n train_df = train_x.copy()\\n train_df['y'] = train_y\\n model_fit = sm.formula.ols('y ~ np.power(x, 2) + x + const', data=train_df).fit()\\n model_info = {'model': 'quadratic', 'R2': model_fit.rsquared, 'f_pvalue': model_fit.f_pvalue,\\n 'const': model_fit.params.const}\\n test_x = test_x.rename('x')\\n test_x = sm.add_constant(test_x)\\n predictions = model_fit.predict(test_x)\\n return predictions, model_info\",\n \"def sample(self, x):\",\n \"def sample(pi, sigma, mu):\\n # print(\\\"sample: pi:\\\", pi.size(), pi)\\n categorical = Categorical(pi)\\n pis = list(categorical.sample().data)\\n sample = Variable(sigma.data.new(sigma.size(0), sigma.size(2)).normal_())\\n for i, idx in enumerate(pis):\\n sample[i] = sample[i].mul(sigma[i,idx]).add(mu[i,idx])\\n return sample\",\n \"def test_quadratic_features_explicit():\\n X_observed = QuadraticFeatures().fit_transform(X_standardized)\\n X_expected = np.hstack(\\n [\\n X_standardized,\\n (X_standardized[:, 0] * X_standardized[:, 0]).reshape((-1, 1)),\\n (X_standardized[:, 1] * X_standardized[:, 1]).reshape((-1, 1)),\\n (X_standardized[:, 0] * X_standardized[:, 1]).reshape((-1, 1)),\\n ]\\n )\\n np.testing.assert_array_equal(X_observed, X_expected)\",\n \"def _get_sample(self):\\n mu = self._get_mean().reshape((1, self.out_dim))\\n sigma = self.variables[\\\"s\\\"]\\n sample = self.random.normal(mu, sigma)\\n sample = sample.reshape(self.out_dim)\\n return sample\",\n \"def sample(self, probs):\\n all_abstain = (self.label_matrix == -1).sum(axis=1) == self.label_matrix.shape[1]\\n self.is_in_pool = (self.ground_truth_labels == -1) & ~ all_abstain & (self.y_train != -1)\\n self.valid_buckets = np.unique(self.unique_inverse[self.is_in_pool])\\n self.is_valid_bucket = np.array([\\n True if i in self.valid_buckets else False for i in range(len(self.unique_idx))])\\n self.bucket_probs = probs.detach().numpy()[self.unique_idx]\\n\\n pick = random.uniform(0, 1)\\n if pick < self.randomness:\\n # Choose random bucket instead of following a specific query strategy\\n chosen_bucket = np.random.choice(self.valid_buckets)\\n else:\\n chosen_bucket = np.random.choice(self.query())\\n\\n return random.choice(np.where((self.unique_inverse == chosen_bucket) & self.is_in_pool)[0])\",\n \"def sample(self, shape):\\n\\t\\traise NotImplementedError()\",\n \"def quadratic_fit(self, xy, W):\\n\\t\\t# first construct the independent matrix\\n\\t\\ty = xy[:,1]\\n\\t\\tx = xy[:,0]\\n\\t\\tX = np.column_stack([np.ones(len(x)),\\n\\t\\t\\t\\t\\t\\t\\tx, np.power(x,2)])\\n\\n\\t\\twls_model = sm.WLS(y, X, weights = 1.0/W)\\t\\n\\t\\twls_model_results = wls_model.fit()\\n\\t\\t[c,b,a] = wls_model_results.params\\t\\n\\t\\treturn [a,b,c]\",\n \"def sample(self, state, model_args, model_kwargs):\\n raise NotImplementedError\",\n \"def subsample(self, dQ):\\n # Assumes self contains sorted Qo and associated T, L\\n # Note: calc_Qo is already sorted\\n Q = np.arange(self.Qo[0], self.Qo[-1], dQ)\\n idx = np.unique(np.searchsorted(self.Qo, Q))\\n #print len(idx), len(self.Qo)\\n\\n self.T, self.dT = self.T[idx], self.dT[idx]\\n self.L, self.dL = self.L[idx], self.dL[idx]\\n self.Qo, self.dQo = self.Qo[idx], self.dQo[idx]\\n if self.R is not None:\\n self.R = self.R[idx]\\n if self.dR is not None:\\n self.dR = self.dR[idx]\\n self._set_calc(self.T, self.L)\",\n \"def sample(self):\\n u = np.asarray(np.random.uniform())\\n return self.invert(u)\",\n \"def sample(self):\\n raise NotImplementedError\",\n \"def sample(self):\\n raise NotImplementedError\",\n \"def _sample_beta_and_sigma_y(self):\\n phi_X = self.phi(self.X, self.W, add_bias=True)\\n cov_j = self.B0 + phi_X.T @ phi_X\\n mu_j = np.tile((self.B0 @ self.b0), (self.J, 1)).T + \\\\\\n (phi_X.T @ self.Y)\\n # multi-output generalization of mvn sample code\\n L = np.linalg.cholesky(cov_j)\\n Z = self.rng.normal(size=self.beta.shape).T\\n LZ = solve_triangular(L, Z, lower=True, trans='T')\\n L_mu = dpotrs(L, mu_j, lower=True)[0]\\n self.beta[:] = (LZ + L_mu).T\\n # sample from inverse gamma\\n a_post = self.gamma_a0 + .5 * self.N\\n b_post = self.gamma_b0 + .5 * np.diag(\\n (self.Y.T @ self.Y) + \\\\\\n (self.b0 @ self.B0 @ self.b0.T) + \\\\\\n (mu_j.T @ np.linalg.solve(cov_j, mu_j))\\n )\\n self.sigma_y = 1. / self.rng.gamma(a_post, 1./b_post)\",\n \"def sample(self):\\n sampleIndices = self.random_state.choice(len(self.X), int(len(self.X)*self.sample_ratio), replace=False)\\n\\n return self.X[sampleIndices]\\n pass\",\n \"def test_quadratic_features_single_column_input_explicit():\\n X_observed = QuadraticFeatures().fit_transform(X_standardized[:, 0].reshape((-1, 1)))\\n X_expected = np.hstack([X_standardized[:, [0]], (X_standardized[:, 0] * X_standardized[:, 0]).reshape((-1, 1)),])\\n np.testing.assert_array_equal(X_observed, X_expected)\",\n \"def sample(self):\\n high = self.high.type(torch.float64) if self.dtype.is_floating_point else self.high.type(torch.int64) + 1\\n sample = torch.empty(self.shape, dtype=torch.float64)\\n\\n # Masking arrays which classify the coordinates according to interval\\n # type\\n unbounded = ~self.bounded_below & ~self.bounded_above\\n upp_bounded = ~self.bounded_below & self.bounded_above\\n low_bounded = self.bounded_below & ~self.bounded_above\\n bounded = self.bounded_below & self.bounded_above\\n\\n # Vectorized sampling by interval type\\n sample[unbounded] = torch.randn(unbounded[unbounded].shape, dtype=torch.float64)\\n\\n sample[low_bounded] = (-torch.rand(low_bounded[low_bounded].shape, dtype=torch.float64)).exponential_() + \\\\\\n self.low[low_bounded]\\n\\n sample[upp_bounded] = self.high[upp_bounded] - (\\n -torch.rand(upp_bounded[upp_bounded].shape, dtype=torch.float64)).exponential_()\\n\\n sample[bounded] = (self.low[bounded] - high[bounded]) * torch.rand(bounded[bounded].shape,\\n dtype=torch.float64) + high[bounded]\\n\\n if not self.dtype.is_floating_point: # integer\\n sample = torch.floor(sample)\\n\\n return sample.type(self.dtype)\",\n \"def draw_bs_sample(data):\\n return rg.choice(data, size=len(data))\",\n \"def next_sample(self, z):\\n xp = self.A @ self.x\\n Pp = self.A @ self.P @ self.A.T + self.Q\\n\\n self.K = Pp @ self.H.T * inv(self.H @ Pp @ self.H.T + self.R)\\n\\n self.x = xp + self.K @ (np.array(np.array([[z]]) - self.H @ xp))\\n self.P = Pp - self.K @ self.H @ Pp\\n\\n self.volt = self.x[0]\\n return self.volt\",\n \"def sample_from_unit_ball(rng, dim):\\n vec = rng.randn(dim)\\n return vec / np.sqrt(np.sum(vec**2))\",\n \"def sample(self, nframes):\\n if not self.__is_valid:\\n raise GmParamError(\\\"\\\"\\\"Parameters of the model has not been \\n set yet, please set them using self.set_param()\\\"\\\"\\\")\\n\\n # State index (ie hidden var)\\n sti = gen_rand_index(self.w, nframes)\\n # standard gaussian samples\\n x = randn(nframes, self.d) \\n\\n if self.mode == 'diag':\\n x = self.mu[sti, :] + x * N.sqrt(self.va[sti, :])\\n elif self.mode == 'full':\\n # Faster:\\n cho = N.zeros((self.k, self.va.shape[1], self.va.shape[1]))\\n for i in range(self.k):\\n # Using cholesky looks more stable than sqrtm; sqrtm is not\\n # available in numpy anyway, only in scipy...\\n cho[i] = lin.cholesky(self.va[i*self.d:i*self.d+self.d, :])\\n\\n for s in range(self.k):\\n tmpind = N.where(sti == s)[0]\\n x[tmpind] = N.dot(x[tmpind], cho[s].T) + self.mu[s]\\n else:\\n raise GmParamError(\\\"cov matrix mode not recognized, \\\"\\\\\\n \\\"this is a bug !\\\")\\n\\n return x\",\n \"def sample_from(space):\\n distrs = {\\n 'choice': choice,\\n 'randint': randint,\\n 'uniform': uniform,\\n 'normal': normal,\\n }\\n s = space[0]\\n\\n np.random.seed(int(time.time() + np.random.randint(0, 300)))\\n\\n log = s.startswith('log_')\\n s = s[len('log_'):] if log else s\\n\\n quantized = s.startswith('q')\\n s = s[1:] if quantized else s\\n\\n distr = distrs[s]\\n if s == 'choice':\\n return distr(space[1])\\n samp = distr(space[1], space[2])\\n if log:\\n samp = np.exp(samp)\\n if quantized:\\n samp = round((samp / space[3]) * space[3])\\n return samp\",\n \"def sample(self,p0=None,nsamp=None): \\r\\n raise NotImplementedError('Need to implement sample function')\",\n \"def sample(self):\\r\\n raise NotImplementedError\",\n \"def signalroisample(filename,obs):\\n from samplingdist import readworkspace,readfile\\n #f,w,obsdict,modeldict,databkgdict,datasigdict = readworkspace(filename)\\n f,obsdict,modeldict,databkgdict,datasigdict = readfile(filename)\\n if not obsdict.has_key(obs):\\n raise RuntimeError(\\\"Observable '%s' not defined\\\" % obs)\\n sd = ObservableSamplingProb(obsdict[obs])\\n sd.setupmodel('bkg','negative_binomial_pdf')\\n sd.setupmodel('sig','negative_binomial_sum_pdf')\\n\\n datasig = datasigdict['dvsig_'+obs]\\n databkg = databkgdict['dvbkg_'+obs]\\n sd.fitTo(datasig,'sig')\\n sd.fitTo(databkg,'bkg')\\n\\n samplename = filename.split('_')[1]\\n sd.plot(samplename,datasig,'sig',sample=samplename+'_sig')\\n sd.plot(samplename,databkg,'bkg',sample=samplename+'_bkg')\\n\\n nfile = filename.split('_')[1]+'_bkgsig_'+obs+'_ws.root'\\n sd.update('w',nfile,[datasig,databkg])\",\n \"def sample(self, shape=(1,)):\\n pass\",\n \"def _sample(self, geometry: Geometry) -> math.Tensor:\\n raise NotImplementedError(self)\",\n \"def sample(self):\\n return self(np.random.randn(self.num_xi)).reshape(self.X.shape)\",\n \"def generate_sample(self):\\n\\n sample_one = np.zeros(self.n_dimensions)\\n\\n \\\"\\\"\\\"C: Huge gains here from using numpy functions at once instead of a Python loop\\\"\\\"\\\"\\n \\\"\\\"\\\"S: How..?\\\"\\\"\\\"\\n\\n for i in range(self.n_dimensions):\\n self.Y[i] ^= self.V[\\n self.index_of_least_significant_zero_bit(self.current - 1), i\\n ]\\n sample_one[i] = float(self.Y[i] / math.pow(2, self.scale))\\n self.current += 1\\n return sample_one\",\n \"def sample_box(self, dim0, dim1=None, bounds=None, lp_rule=None, verbose=False):\\n\\n # TODO: include in get_par\\n\\n import chaospy\\n\\n bnd = bounds or np.array(self.fdict['prior_bounds'])\\n dim1 = dim1 or self.ndim\\n rule = lp_rule or 'S'\\n\\n res = chaospy.Uniform(0, 1).sample(size=(dim0, dim1), rule=rule)\\n res = (bnd[1] - bnd[0])*res + bnd[0]\\n\\n return res\",\n \"def sample_utility(n, model, alpha, beta, bmax):\\n A, b = matrix(0.0, (n,n)), matrix(ra.uniform(0,bmax,(n,1)))\\n \\n if model == 1: A = matrix(ra.uniform(0,beta,(n,n)))\\n \\n if model == 2:\\n for i in range(n):\\n for j in range(n/2):\\n A[i, int(np.mod(i+j+1,n))] = beta**(j+1)\\n A[i, int(np.mod(i-(j+1),n))] = beta**(j+1)\\n \\n if model == 3: A = 0.5*matrix(ra.binomial(1,beta,(n,n)))\\n \\n for i in range(n): A[i,i] = 1.0\\n \\n return Utility((alpha*A,b), 'sqrt')\",\n \"def test_quadratic_trinomial_init(self):\\n a, b, c = 2, 3, 4\\n expected = Polynomial(a, b, c)\\n\\n qt = QuadraticTrinomial(a, b, c)\\n\\n self.assertEqual(expected, qt)\",\n \"def sample(x,u):\\n if ispoint(x):\\n # return pointsample(x)\\n return point(x)\\n elif isline(x):\\n return sampleline(x,u)\\n elif isarc(x):\\n return samplearc(x,u)\\n elif ispoly(x):\\n return samplepoly(x,u)\\n elif isgeomlist(x):\\n return samplegeomlist(x,u)\\n else:\\n raise ValueError(\\\"inappropriate type for sample(): \\\" + str(x))\",\n \"def draw_bs_sample(data):\\n return np.random.choice(data, size=len(data))\",\n \"def sample(self):\\n M = np.random.normal(self._mu.reshape(-1), self._sig).reshape(self.shape)\\n return M\",\n \"def sampling_latent(self):\\n \\n self.z = gaussian_sample(self.qz_m, self.qz_v)\\n if self.scalings:\\n self.library = gaussian_sample(self.ql_m, self.ql_v)\",\n \"def test_proof_model():\\n m = build_proof_model()\\n with m:\\n trace = pm.sample(50)\\n assert trace.report.ok\",\n \"def test_simpSample(self):\\n\\n #uniform dist\\n ulim = [0,1]\\n ufun = lambda x: 1.0/np.diff(ulim)\\n\\n n = int(1e5)\\n usample = statsFun.simpSample(ufun,n,ulim[0],ulim[1])\\n self.assertGreaterEqual(usample.min(), ulim[0])\\n self.assertLessEqual(usample.max(), ulim[1])\\n\\n nlim = [-10,10]\\n nfun = lambda x: np.exp(-x**2./2.0)/np.sqrt(2.0*np.pi)\\n nsample = statsFun.simpSample(nfun,n,nlim[0],nlim[1])\\n self.assertGreaterEqual(nsample.min(), nlim[0])\\n self.assertLessEqual(nsample.min(), nlim[1])\\n\\n self.assertGreaterEqual(scipy.stats.kstest(usample,'uniform')[1],0.01,'Uniform sample does not look uniform.')\\n self.assertGreaterEqual(scipy.stats.kstest(nsample,'norm')[1],0.01,'Normal sample does not look normal.')\\n self.assertLessEqual(scipy.stats.kstest(nsample,'uniform')[1],0.01,'Normal sample looks too uniform.')\\n self.assertLessEqual(scipy.stats.kstest(usample,'norm')[1],0.01,'Uniform sample looks too normal.')\",\n \"def in_square():\\n return np.random.random_sample(size=2)\",\n \"def sample(self, seg_logit, seg_label):\",\n \"def estimate_sample_beta(sample):\\n x_s, y_s = zip(*sample)\\n reg.fit(x_s, y_s)\\n betas = reg.weights_\\n return betas\",\n \"def _construct_sample_from_prior(self):\\n z_sym = T.matrix()\\n x_sym = T.matrix()\\n irs = self.ir_steps\\n oputs = [self.obs_transform(self.s0)]\\n oputs.extend([self.obs_transform(self.si[i]) for i in range(irs)])\\n _, hi_zmuv = self._construct_zmuv_samples(x_sym, 1)\\n sample_func = theano.function(inputs=[z_sym, x_sym], outputs=oputs, \\\\\\n givens={ self.z: z_sym, \\\\\\n self.x_in: T.zeros_like(x_sym), \\\\\\n self.x_out: T.zeros_like(x_sym), \\\\\\n self.hi_zmuv: hi_zmuv }, \\\\\\n updates=self.scan_updates)\\n def prior_sampler(samp_count):\\n x_samps = to_fX( np.zeros((samp_count, self.obs_dim)) )\\n old_switch = self.train_switch.get_value(borrow=False)\\n # set model to generation mode\\n self.set_train_switch(switch_val=0.0)\\n z_samps = to_fX( npr.randn(samp_count, self.z_dim) )\\n model_samps = sample_func(z_samps, x_samps)\\n # set model back to either training or generation mode\\n self.set_train_switch(switch_val=old_switch)\\n return model_samps\\n return prior_sampler\",\n \"def eval_sampling_point(self, sampling_point):\\n return Solution(self, sampling_point)\",\n \"def sample_from(self):\\n return numpy.random.normal(self.mu, math.sqrt(self.sigma))\",\n \"def test_sample(self, normal_mock):\\n # Setup\\n instance = GaussianMultivariate(GaussianUnivariate)\\n data = pd.DataFrame([\\n {'A': 25, 'B': 75, 'C': 100},\\n {'A': 30, 'B': 60, 'C': 250},\\n {'A': 10, 'B': 65, 'C': 350},\\n {'A': 20, 'B': 80, 'C': 150},\\n {'A': 25, 'B': 70, 'C': 500}\\n ])\\n instance.fit(data)\\n\\n normal_mock.return_value = np.array([\\n [0.1, 0.1, 0.1],\\n [0.2, 0.2, 0.2],\\n [0.4, 0.4, 0.4],\\n [0.6, 0.6, 0.6],\\n [0.8, 0.8, 0.8]\\n ])\\n\\n expected_result = pd.DataFrame([\\n {'A': 22.678232998312527, 'B': 70.70710678118655, 'C': 284.35270009440734},\\n {'A': 23.356465996625055, 'B': 71.41421356237309, 'C': 298.7054001888146},\\n {'A': 24.712931993250110, 'B': 72.82842712474618, 'C': 327.4108003776293},\\n {'A': 26.069397989875164, 'B': 74.24264068711929, 'C': 356.116200566444},\\n {'A': 27.425863986500215, 'B': 75.65685424949238, 'C': 384.8216007552586}\\n ])\\n\\n # Run\\n result = instance.sample(5)\\n\\n # Check\\n assert result.equals(expected_result)\\n\\n assert normal_mock.called_once_with(\\n np.zeros(instance.covariance.shape[0]),\\n instance.covariance,\\n 5\\n )\",\n \"def test_quadratic_features_random_state_invariance():\\n transformer1 = QuadraticFeatures(random_state=0)\\n transformer2 = QuadraticFeatures(random_state=0)\\n X1 = transformer1.fit_transform(X_small)\\n X2 = transformer2.fit_transform(X_small)\\n assert np.all(X1 == X2)\",\n \"def stocksolution(self):\\n return Sample(self.solutes, self.quantities, self.volume, True)\",\n \"def sample_posterior(self):\\n \\n# print (\\\"SAMPLING FROM LINEAR SIMILARITY VB\\\")\\n if (self.posterior_mean == False):\\n self.weight = Vil.sample_posterior(self.mu_weight, Vil.softplus(self.rho_weight))\\n self.bias = Vil.sample_posterior(self.mu_bias, Vil.softplus(self.rho_bias))\\n# print (self.bias)\\n else:\\n self.weight.data = self.mu_weight.data\\n self.bias.data = self.mu_bias.data\",\n \"def fit(sample):\\r\\n if not hasattr(sample, \\\"stddev\\\"):\\r\\n sample = Sample(sample)\\r\\n m = sample.mean\\r\\n d = sqrt(12*sample.variance)/2\\r\\n return Uniform(m-d, m+d)\",\n \"def test_oss_sample_wt_fit():\\n\\n # Create the object\\n oss = OneSidedSelection(random_state=RND_SEED)\\n assert_raises(RuntimeError, oss.sample, X, Y)\",\n \"def sample(problem, seed=None):\\n if seed:\\n np.random.seed(seed)\\n contrast = generate_contrast(problem)\\n sample = np.array((contrast + 1.0) / 2, dtype=float)\\n problem = extend_bounds(problem)\\n\\n sample = scale_samples(sample, problem)\\n return sample\",\n \"def _get_sample(self):\\n mu = self._get_mean()\\n sample = self.random.normal(mu)\\n return sample\",\n \"def next_sample(self, z):\\n xp = self.A @ self.x\\n Pp = self.A @ self.P @ self.A.T + self.Q\\n\\n self.K = Pp @ self.H.T * inv(self.H @ Pp @ self.H.T + self.R)\\n\\n self.x = xp + self.K @ (z - self.H @ xp)\\n self.P = Pp - self.K @ self.H @ Pp\\n return self.x\",\n \"def bqm_structured(f):\\n @wraps(f)\\n def structured_sample(sampler, bqm, **kwargs):\\n adjacency = sampler.adjacency\\n\\n if not adjacency.keys() >= bqm.variables:\\n raise BinaryQuadraticModelStructureError(\\n f\\\"given bqm has at least one variable, {(list(bqm.variables) - adjacency.keys()).pop()!r}, \\\"\\n \\\"not supported by the structured solver\\\")\\n if any(u not in adjacency[v] for u, v, _ in bqm.iter_quadratic()):\\n u, v = next((u, v) for u, v, _ in bqm.iter_quadratic() if u not in adjacency[v])\\n raise BinaryQuadraticModelStructureError(\\n f\\\"given bqm contains an interaction, {(u, v)!r}, \\\"\\n \\\"not supported by the structured solver\\\")\\n return f(sampler, bqm, **kwargs)\\n return structured_sample\",\n \"def sample_uniform():\\n global samples_uniform, isample_uniform\\n\\n # sample of U(0, 1)\\n u = samples_uniform[isample_uniform]\\n\\n # moving to next index of samples global array\\n isample_uniform += 1\\n if isample_uniform >= len(samples_uniform):\\n # exhausted all samples -> re-drawing samples from U(0, 1)\\n samples_uniform = np.random.uniform(size=SIZE_SAMPLES_UNIFORM)\\n isample_uniform = 0\\n\\n return u\",\n \"def sample(self, x: Union[np.ndarray, float, list], ):\\n x = self._sample_test(x)\\n if x.ndim <= 1:\\n y = 0\\n for i in range(self.mixture_count):\\n if self.dimensions == 1:\\n y += self.weights[i] * self.one_d_normal(x, self.means[i], self.covs[i])\\n else:\\n y += self.weights[i] * self.multi_d_gauss(x, self.means[i], self.covs[i])\\n else:\\n x = np.squeeze(x, axis=1)\\n y = np.zeros((x.shape[0], ))\\n for i in range(self.mixture_count):\\n if self.dimensions == 1:\\n y += self.weights[i] * self.one_d_normal(x, self.means[i], self.covs[i])\\n else:\\n y += self.weights[i] * self.multi_d_gauss(x, self.means[i], self.covs[i])\\n return y\",\n \"def sample_py3(self):\\n print(self.weights_.shape)\\n try:\\n n_samples_comp = self.rng.multinomial(self.n_samples, self.weights_)\\n except ValueError:\\n self.weights_= np.reshape(self.weights_,len(self.weights_))\\n n_samples_comp = self.rng.multinomial(self.n_samples, self.weights_)\\n if self.covariance_type == 'full':\\n X = np.vstack([\\n self.rng.multivariate_normal(mean, covariance, int(sample))\\n for (mean, covariance, sample) in zip(\\n self.means_, self.covariances_, n_samples_comp)])\\n elif self.covariance_type == \\\"tied\\\":\\n X = np.vstack([\\n self.rng.multivariate_normal(mean, self.covariances_, int(sample))\\n for (mean, sample) in zip(\\n self.means_, n_samples_comp)])\\n else:\\n X = np.vstack([\\n mean + self.rng.randn(sample, n_features) * np.sqrt(covariance)\\n for (mean, covariance, sample) in zip(\\n self.means_, self.covariances_, n_samples_comp)])\\n\\n y = np.concatenate([j * np.ones(sample, dtype=int)\\n for j, sample in enumerate(n_samples_comp)])\\n\\n return (X, y)\",\n \"def quadratic_program_bnd(self, c, Q, lb, ub):\\n if self.solver == solver_SCIPY:\\n return scipy_quadratic_program_bnd(c, Q, lb, ub)\\n elif self.solver == solver_GUROBI:\\n return gurobi_quadratic_program_bnd(c, Q, lb, ub)\\n else:\\n raise ValueError('QP solver %s not available' % self.solver)\",\n \"def binary_sample(x):\\n return np.random.binomial(1, p=x)\",\n \"def sample(self, i):\\n\\t\\tif self.nsamp % 2 == 0:\\n\\t\\t\\ti0 = i-(self.nsamp/2-1)\\n\\t\\t\\ti1 = i+(self.nsamp/2)\\n\\t\\telse:\\n\\t\\t\\ti0 = i-((self.nsamp-1)/2.)\\n\\t\\t\\ti1 = i+((self.nsamp-1)/2.)\\n\\t\\treturn self.yval[i0:i1]\",\n \"def test_simpSample_trivial(self):\\n\\n ulim = [0,1]\\n ufun = lambda x: 1.0/np.diff(ulim)\\n\\n n = 10000\\n sample = statsFun.simpSample(ufun,n,0.5,0.5)\\n\\n self.assertEqual(len(sample),n)\\n self.assertTrue(np.all(sample == 0.5))\",\n \"def test_quadratic_features_shape(include_bias, interaction_only, n_output_features):\\n transformer = QuadraticFeatures(include_bias=include_bias, interaction_only=interaction_only,)\\n XQ = transformer.fit_transform(X_small)\\n assert XQ.shape == (X_small_n_rows, n_output_features)\",\n \"def samplepoint(x,u):\\n return point(x)\",\n \"def sample(self):\\n # return [v.sample() for v in self.variables]\\n return self.domain[gc.rand_state.choice(len(self.domain))]\",\n \"def test_quadratic_trinomial_default_init(self):\\n expected = Polynomial(1, 1, 1)\\n\\n qt = QuadraticTrinomial()\\n\\n self.assertEqual(expected, qt)\",\n \"def sample_mu(self, val) -> None:\\n\\n # get data\\n data = self.data.reshape((1, -1))\\n\\n # get values\\n gain = val.gain\\n states = val.states\\n mu_flor = val.mu_flor\\n mu_flor_mean = val.mu_flor_mean\\n mu_flor_shape = val.mu_flor_shape\\n mu_back = val.mu_back\\n mu_back_mean = val.mu_back_mean\\n mu_back_shape = val.mu_back_shape\\n num_data = val.num_data\\n num_rois = val.num_rois\\n num_states = val.num_states\\n\\n # initialze variables\\n num_vars = num_states + num_rois\\n idx = np.where(val.mu_flor_mean > 0)[0]\\n # shape\\n shape = np.zeros((num_vars, 1))\\n shape[:num_states, 0] = mu_flor_shape[:]\\n shape[num_states:, 0] = mu_back_shape\\n # scale\\n scale = np.zeros((num_vars, 1))\\n scale[idx, 0] = mu_flor_mean[idx] / mu_flor_shape[idx]\\n scale[num_states:, 0] = (mu_back_mean / mu_back_shape)[:]\\n\\n # initialize a mu vector containing the variables we wish to sample, mu_flor and mu_back\\n q = np.zeros((num_vars, 1))\\n q[:num_states, 0] = mu_flor[:]\\n q[num_states:, 0] = mu_back[:]\\n q_old = q.copy()\\n idy = q > 0 # keep track of which states are dark (we only sample bright states)\\n num_var = q.shape[0]\\n\\n # hmc dynamics variables\\n h = np.random.exponential() / 100\\n masses = (1 + np.random.pareto(1, size=q.shape))\\n masses_inv = np.zeros(shape=masses.shape) # negative mass is interpretted as an unchanging variable\\n masses_inv[masses > 0] = 1 / masses[masses > 0]\\n num_steps = np.random.poisson(25)\\n\\n # create populations array\\n pops = np.zeros((num_vars, num_rois * num_data))\\n \\\"\\\"\\\"\\n pops is an array such that each element i, j corresponds to the \\n multiplicitive factor in front of q[i] for data point j in the \\n likelihood. For example, if in ROI 1 at time level 17 there are two\\n fluorophores in the bright state, then we find the element, j,\\n corresponding to ROI 1 and time level 17, and we find the element,\\n i, corresponding to the bright state, and we set q[i,j]=2 (because\\n there are two bright fluorophores), then we would find the i\\n corresponding to the background brightness of ROI 1, and we would\\n set this q[i,j]=1 (the multiplicitive factor in front of the \\n background brightness is 1 when it is the corresponding ROI and 0\\n otherwise).\\n \\\"\\\"\\\"\\n for r in range(num_rois):\\n idx = np.arange(r*num_data, (r+1)*num_data)\\n pops[:num_states, idx] = states_to_pops(states[r, :, :], num_states)\\n pops[num_states + r, idx] = 1\\n\\n # the conditional probability for the mu vector\\n def probability(q_, p_):\\n if np.sum(q_ < 0) > 0:\\n prob = -np.inf\\n else:\\n prob = (\\n np.sum(stats.gamma.logpdf(data, a=q_.T @ pops, scale=gain)) # likelihood\\n + np.sum(stats.gamma.logpdf(q_[idy], a=shape[idy], scale=scale[idy])) # prior\\n + np.sum(stats.norm.logpdf(p_[idy], loc=0, scale=np.sqrt(masses[idy]))) # momentum\\n )\\n return prob\\n\\n # the gradient of the Hamiltonian with respect to the mu_vector\\n def dH_dq(q_):\\n if np.any(q_ < 0):\\n \\\"\\\"\\\"\\n In the event that q_new becomes negative, fast_digamma becomes\\n slow. Since q should never be negative anyway, there is no\\n need for further computation and we can skip this step knowing\\n that this value of q will be rejected anyway.\\n \\\"\\\"\\\"\\n return q_\\n q_new = np.zeros(q_.shape)\\n q_new[idy] = (\\n (shape[idy] - 1) / q_[idy] - 1 / scale[idy]\\n + (pops @ (np.log(data / gain) - fast_digamma(q_.T @ pops)).T)[idy]\\n )\\n return q_new\\n\\n # sample momentum\\n p = np.random.randn(num_var, 1) * np.sqrt(masses)\\n p_old = p.copy()\\n\\n # run the HMC\\n for i in range(num_steps):\\n p = p + .5 * h * dH_dq(q)\\n q = q + h * p * masses_inv\\n p = p + .5 * h * dH_dq(q)\\n\\n # find acceptance ratio\\n P_new = probability(q, p)\\n P_old = probability(q_old, p_old)\\n if (P_new - P_old) < np.log(np.random.rand()):\\n q = q_old\\n\\n # update the new mu values\\n val.mu_flor[:] = q[:num_states, 0]\\n val.mu_back[:] = q[num_states:, 0]\\n\\n return\",\n \"def to_bqm(self, model):\\n linear = ((v, float(model.get_py_value(bias)))\\n for v, bias in self.linear.items())\\n quadratic = ((u, v, float(model.get_py_value(bias)))\\n for (u, v), bias in self.quadratic.items())\\n offset = float(model.get_py_value(self.offset))\\n\\n return BQM(linear, quadratic, offset, dimod.SPIN)\",\n \"def sample(self):\\n\\n # pick sample type according to probability\\n samplers = [\\\"unif\\\", \\\"geo\\\", \\\"diverse\\\"]\\n sample_idx = np.random.multinomial(\\n 1, [self.unif_prob, self.geo_prob, self.diverse_prob])\\n idx = np.argmax(sample_idx)\\n sampler = samplers[idx]\\n\\n if sampler == \\\"unif\\\":\\n return self.unif_sampler()\\n if sampler == \\\"geo\\\":\\n return self.geo_sampler()\\n if sampler == \\\"diverse\\\":\\n return self.diverse_sampler()\",\n \"def sample(wave, factor):\\n ys = np.zeros(len(wave))\\n ys[::factor] = np.real(wave.ys[::factor])\\n return Wave(ys, framerate=wave.framerate)\",\n \"def _sample(self, points: Iterable[float]) -> np.array:\\n pass\",\n \"def sample(self, m):\\n i = torch.multinomial(self.weights, m, replacement=True)\\n return self.particles[i,:]\",\n \"def _SampleInputMatrix(nrows, bl, bu, distname='randomUniform'):\\n npars = len(bl)\\n x = np.zeros((nrows,npars))\\n bound = bu-bl\\n for i in range(nrows):\\n # x[i,:]= bl + DistSelector([0.0,1.0,npars],distname='randomUniform')*bound # only used in full Vhoeys-framework\\n x[i,:]= bl + np.random.rand(1,npars)*bound\\n return x\",\n \"def samplepoly(a,u):\\n \\n if not ispoly(a):\\n raise ValueError('non-poly passed to samplepoly')\\n\\n closed=False\\n\\n lines,lengths,length = __lineslength(a)\\n if len(a) > 2 and dist(a[0],a[-1]) < epsilon:\\n closed = True\\n\\n if closed:\\n u=u%1.0\\n \\n dst = u * length;\\n d = 0\\n if u < 1.0:\\n for i in range(len(lines)):\\n l=lengths[i]\\n if dst <= d+l:\\n uu = 1.0 - (d+l-dst)/l\\n return sampleline(lines[i],uu)\\n else:\\n d+=l\\n else:\\n uu = (dst-length+lengths[-1])/lengths[-1]\\n return sampleline(lines[-1],uu)\",\n \"def sample(self, sample_shape=torch.Size()):\\n with torch.no_grad():\\n return self.rsample(sample_shape=sample_shape)\",\n \"def sample(self, point, n_samples=1):\\n raise NotImplementedError(\\\"The sample method is not yet implemented.\\\")\",\n \"def rational_quadratic(input_dim, variance=1., lengthscale=1., power=1.):\\r\\n part = parts.rational_quadratic.RationalQuadratic(input_dim, variance, lengthscale, power)\\r\\n return kern(input_dim, [part])\",\n \"def get_uniform_subset(self, samples_per_label):\\n raise NotImplementedError\",\n \"def sample(self, s):\\n rng = np.random.default_rng()\\n return rng.choice(np.arange(self.n_actions), p=self.eval(s))\",\n \"def sample_b(self):\\n # don't sample b-factors with em\\n if not self.options.sample_bfactors or self.options.em:\\n return\\n\\n new_coor = []\\n new_bfactor = []\\n multiplication_factors = [1.0, 1.3, 1.5, 0.9, 0.5]\\n coor_b_pairs = zip(self._coor_set, self._bs)\\n for (coor, b), multi in itertools.product(coor_b_pairs, multiplication_factors):\\n new_coor.append(coor)\\n new_bfactor.append(b * multi)\\n self._coor_set = new_coor\\n self._bs = new_bfactor\",\n \"def sample_from_simplex(rng, dim):\\n alpha = [1] * dim\\n return rng.dirichlet(alpha)\",\n \"def get_sample(x, y):\\n return noise[x][y]\",\n \"def sample(self) -> np.ndarray:\\n q_target = np.empty(self.d)\\n for i in range(self.d):\\n q_target[i] = self.lim_lo[i] + np.random.rand() * (self.lim_up[i] - self.lim_lo[i])\\n return q_target\",\n \"def sample_spherical(self):\\n vec = np.random.randn(self.dims, self.arms)\\n vec /= np.linalg.norm(vec, axis=0)\\n self.contexts = vec.T\",\n \"def initial_samples(lb, ub, method, numSamp):\\r\\n if not len(lb) == len(ub):\\r\\n raise AssertionError('Lower and upper bounds have different #s of design variables in initial_samples function.')\\r\\n assert method == 'random' or method == 'nolh' or method == 'nolh-rp' or method == 'nolh-cdr' or method == 'lhc' or method == 'rand-wor', 'An invalid method was specified for the initial_samples.'\\r\\n assert (method == 'nolh' or method == 'nolh-rp' or method == 'nolh-cdr') and len(ub) >= 2 and len(ub) <= 29, 'The Phase space dimensions are outside of the bounds for initial_samples.'\\r\\n for case in Switch(method):\\r\\n if case('random'):\\r\\n s = np.zeros((numSamp, len(lb)))\\r\\n for i in range(0, numSamp, 1):\\r\\n s[i, :] = lb + (ub - lb) * rand(len(lb))\\r\\n\\r\\n break\\r\\n if case('rand-wor'):\\r\\n s = np.zeros((numSamp, len(lb)))\\r\\n for i in range(0, numSamp, 1):\\r\\n s[i, :] = choice(len(ub), size=len(ub), replace=False)\\r\\n\\r\\n break\\r\\n if case('nolh'):\\r\\n dim = len(ub)\\r\\n m, q, r = params(dim)\\r\\n conf = range(q)\\r\\n if r != 0:\\r\\n remove = range(dim - r, dim)\\r\\n nolh = NOLH(conf, remove)\\r\\n else:\\r\\n nolh = NOLH(conf)\\r\\n s = np.array([ list(lb + (ub - lb) * nolh[i, :]) for i in range(len(nolh[:, 0]))\\r\\n ])\\r\\n break\\r\\n if case('nolh-rp'):\\r\\n dim = len(ub)\\r\\n m, q, r = params(dim)\\r\\n conf = random.sample(range(q), q)\\r\\n if r != 0:\\r\\n remove = random.sample(range(q - 1), r)\\r\\n nolh = NOLH(conf, remove)\\r\\n else:\\r\\n nolh = NOLH(conf)\\r\\n s = np.array([ list(lb + (ub - lb) * nolh[i, :]) for i in range(len(nolh[:, 0]))\\r\\n ])\\r\\n break\\r\\n if case('nolh-cdr'):\\r\\n dim = len(ub)\\r\\n m, q, r = params(dim)\\r\\n conf, remove = get_cdr_permutations(len(ub))\\r\\n if remove != []:\\r\\n nolh = NOLH(conf, remove)\\r\\n else:\\r\\n nolh = NOLH(conf)\\r\\n s = np.array([ list(lb + (ub - lb) * nolh[i, :]) for i in range(len(nolh[:, 0]))\\r\\n ])\\r\\n break\\r\\n if case('lhc'):\\r\\n tmp = lhs(len(lb), samples=numSamp, criterion='center')\\r\\n s = np.array([ list(lb + (ub - lb) * tmp[i, :]) for i in range(len(tmp[:, 0]))\\r\\n ])\\r\\n break\\r\\n if case():\\r\\n print 'Somehow you evaded my assert statement - good job!',\\r\\n print ' However, you still need to use a valid method string.'\\r\\n\\r\\n return s\",\n \"def evalQuad(a,b,c,x):\\n return a * x**2 + b*x + c\",\n \"def sample(self, x):\\n x_minus_mu = x - self.mu\\n pwr = -(np.dot(np.dot (x_minus_mu.transpose(), self.cov_inv),\\n x_minus_mu) / 2.0)\\n return math.exp(pwr) #/ self.root_2pi_d_det\",\n \"def sample_random_architecture(self, dataset_api):\\n while True:\\n matrix = np.random.choice(\\n [0, 1], size=(NUM_VERTICES, NUM_VERTICES))\\n matrix = np.triu(matrix, 1)\\n ops = np.random.choice(OPS, size=NUM_VERTICES).tolist()\\n ops[0] = INPUT\\n ops[-1] = OUTPUT\\n spec = dataset_api['api'].ModelSpec(matrix=matrix, ops=ops)\\n if dataset_api['nb101_data'].is_valid(spec):\\n break\\n \\n self.set_spec({'matrix':matrix, 'ops':ops})\",\n \"def sample_survey(self, **kwargs):\",\n \"def sampling_algorithm(self, X, y):\\r\\n n_to_sample = self.det_n_to_sample(self.proportion)\\r\\n\\r\\n if n_to_sample == 0:\\r\\n return self.return_copies(X, y, \\\"Sampling is not needed\\\")\\r\\n\\r\\n X_min = X[y == self.min_label]\\r\\n X_maj = X[y == self.maj_label]\\r\\n\\r\\n # fitting nearest neighbors model to find closest majority points to\\r\\n # minority samples\\r\\n nn_params = {**self.nn_params}\\r\\n nn_params['metric_tensor'] = \\\\\\r\\n self.metric_tensor_from_nn_params(nn_params, X, y)\\r\\n\\r\\n density = self.calculate_density(X_min, X_maj, nn_params)\\r\\n\\r\\n # fitting nearest neighbors model to minority samples to run\\r\\n # SMOTE-like sampling\\r\\n n_neighbors = min([len(X_min), self.n_neighbors+1])\\r\\n nnmt = NearestNeighborsWithMetricTensor(n_neighbors=n_neighbors,\\r\\n n_jobs=self.n_jobs,\\r\\n **nn_params)\\r\\n nnmt.fit(X_min)\\r\\n ind = nnmt.kneighbors(X_min, return_distance=False)\\r\\n\\r\\n samples = self.sample_simplex(X=X_min,\\r\\n indices=ind,\\r\\n n_to_sample=n_to_sample,\\r\\n base_weights=density)\\r\\n\\r\\n # do the sampling\\r\\n #samples = []\\r\\n #while len(samples) < n_to_sample:\\r\\n # idx = self.random_state.choice(np.arange(len(density)), p=density)\\r\\n # random_neighbor_idx = self.random_state.choice(ind[idx][1:])\\r\\n # X_a = X_min[idx]\\r\\n # X_b = X_min[random_neighbor_idx]\\r\\n # samples.append(self.sample_between_points(X_a, X_b))\\r\\n\\r\\n return (np.vstack([X, samples]),\\r\\n np.hstack([y, np.repeat(self.min_label, len(samples))]))\",\n \"def test_gradient_exception_on_sample(self):\\n dev = qml.device(\\\"default.qubit\\\", wires=2, shots=1000)\\n\\n @qml.qnode(dev, diff_method=\\\"parameter-shift\\\")\\n def circuit(x):\\n qml.RX(x, wires=[0])\\n return qml.sample(qml.PauliZ(0)), qml.sample(qml.PauliX(1))\\n\\n with pytest.raises(\\n qml.QuantumFunctionError,\\n match=\\\"Circuits that include sampling can not be differentiated.\\\",\\n ):\\n grad_fn = autograd.jacobian(circuit)\\n grad_fn(1.0)\",\n \"def sample(self):\",\n \"def varietySample(V, x, count_max, R2, eps_bound):\\n \\n #x = np.array(V.gens);\\n N = len(x)\\n t = sp.symbols(\\\"t\\\") #Parameter of line\\n #count_max = 200\\n count = 0\\n #N = length(x)\\n P = np.empty([N,0])\\n while count < count_max:\\n # Corrupt the variety with bounded noise \\n epsilon = np.random.uniform(-eps_bound, eps_bound)\\n Ve = V + epsilon \\n \\n # Get a line u + v t in space \\n U = sp.Matrix(np.random.randn(2, N+1));\\n Ur = np.array(U.rref()[0].transpose().tolist(), dtype=float)\\n u = Ur[1:, 0]\\n v = Ur[1:, 1]\\n \\n L = u + v * t \\n \\n #substitute in the line and find real roots\\n VL = Ve.subs([i for i in zip(x, L)])\\n cVL = sp.Poly(VL).coeffs()\\n rVL = np.roots(cVL)\\n r_real = np.real(rVL[np.isreal(rVL)])\\n \\n \\n \\n #recover points of intersection and append to array\\n p = u[:, np.newaxis] + np.outer(v, r_real) \\n pnorm = np.sum(p**2, 0)\\n \\n pcand= p[:, pnorm <= R2]\\n\\n # if pcand.shape[1] <= 1:\\n # pcand0 = pcand\\n # else:\\n # #pcand0 = pcand[:, 0]\\n # pcand0 = pcand[..., 0][:, np.newaxis] #this is dumb\\n #\\n # P = np.concatenate([P, pcand0], 1)\\n P = np.concatenate([P, pcand], 1)\\n \\n #start new sampling iteration\\n count = count + np.size(pcand, 1)\\n \\n return P\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.5944321","0.58827317","0.57604975","0.56414646","0.5592896","0.5581259","0.55090886","0.54022413","0.5325893","0.5319684","0.53083277","0.53047055","0.5290728","0.52858907","0.5271392","0.5254466","0.52531403","0.52415967","0.52349377","0.5205364","0.5205364","0.5199425","0.51842093","0.5176185","0.51726454","0.51712173","0.515758","0.5152947","0.51358306","0.5133928","0.5124854","0.511913","0.50822085","0.5072199","0.5056643","0.5055369","0.50511503","0.5049002","0.5045257","0.5043229","0.5016383","0.50083894","0.4994151","0.4992991","0.49841487","0.4979531","0.49790454","0.4975377","0.4966808","0.49661237","0.49554235","0.49530268","0.4952751","0.4948786","0.49437016","0.49400643","0.49390027","0.49363205","0.49350917","0.4931782","0.49312016","0.49289736","0.49218094","0.49204746","0.49180242","0.49134803","0.49118084","0.4911674","0.49062628","0.49036816","0.49036437","0.489489","0.48924637","0.48882884","0.4884532","0.4872612","0.48646408","0.4856766","0.48506472","0.48493817","0.48356277","0.48352975","0.48338464","0.48309493","0.48258153","0.48244852","0.48223567","0.48106217","0.48074403","0.48050305","0.4804369","0.48039567","0.4799464","0.4796592","0.47937623","0.47927168","0.47886637","0.47752497","0.47740617","0.4768682"],"string":"[\n \"0.5944321\",\n \"0.58827317\",\n \"0.57604975\",\n \"0.56414646\",\n \"0.5592896\",\n \"0.5581259\",\n \"0.55090886\",\n \"0.54022413\",\n \"0.5325893\",\n \"0.5319684\",\n \"0.53083277\",\n \"0.53047055\",\n \"0.5290728\",\n \"0.52858907\",\n \"0.5271392\",\n \"0.5254466\",\n \"0.52531403\",\n \"0.52415967\",\n \"0.52349377\",\n \"0.5205364\",\n \"0.5205364\",\n \"0.5199425\",\n \"0.51842093\",\n \"0.5176185\",\n \"0.51726454\",\n \"0.51712173\",\n \"0.515758\",\n \"0.5152947\",\n \"0.51358306\",\n \"0.5133928\",\n \"0.5124854\",\n \"0.511913\",\n \"0.50822085\",\n \"0.5072199\",\n \"0.5056643\",\n \"0.5055369\",\n \"0.50511503\",\n \"0.5049002\",\n \"0.5045257\",\n \"0.5043229\",\n \"0.5016383\",\n \"0.50083894\",\n \"0.4994151\",\n \"0.4992991\",\n \"0.49841487\",\n \"0.4979531\",\n \"0.49790454\",\n \"0.4975377\",\n \"0.4966808\",\n \"0.49661237\",\n \"0.49554235\",\n \"0.49530268\",\n \"0.4952751\",\n \"0.4948786\",\n \"0.49437016\",\n \"0.49400643\",\n \"0.49390027\",\n \"0.49363205\",\n \"0.49350917\",\n \"0.4931782\",\n \"0.49312016\",\n \"0.49289736\",\n \"0.49218094\",\n \"0.49204746\",\n \"0.49180242\",\n \"0.49134803\",\n \"0.49118084\",\n \"0.4911674\",\n \"0.49062628\",\n \"0.49036816\",\n \"0.49036437\",\n \"0.489489\",\n \"0.48924637\",\n \"0.48882884\",\n \"0.4884532\",\n \"0.4872612\",\n \"0.48646408\",\n \"0.4856766\",\n \"0.48506472\",\n \"0.48493817\",\n \"0.48356277\",\n \"0.48352975\",\n \"0.48338464\",\n \"0.48309493\",\n \"0.48258153\",\n \"0.48244852\",\n \"0.48223567\",\n \"0.48106217\",\n \"0.48074403\",\n \"0.48050305\",\n \"0.4804369\",\n \"0.48039567\",\n \"0.4799464\",\n \"0.4796592\",\n \"0.47937623\",\n \"0.47927168\",\n \"0.47886637\",\n \"0.47752497\",\n \"0.47740617\",\n \"0.4768682\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.4778152"},"document_rank":{"kind":"string","value":"97"}}},{"rowIdx":24996,"cells":{"query":{"kind":"string","value":"Sample from the provided binary quadratic model."},"document":{"kind":"string","value":"def sample(self, bqm, chain_strength=1.0, **parameters):\n\n # solve the problem on the child system\n child = self.child\n\n # apply the embedding to the given problem to map it to the child sampler\n __, __, target_adjacency = child.structure\n\n # get the embedding\n embedding = self._embedding\n\n bqm_embedded = dimod.embed_bqm(bqm, embedding, target_adjacency, chain_strength=chain_strength)\n\n response = child.sample(bqm_embedded, **parameters)\n\n return dimod.unembed_response(response, embedding, source_bqm=bqm)"},"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 sample(self,noise,s):\n rhs=self.prior.sqrtM*noise\n self.prior.Msolver.solve(s,rhs)","def sample(self, bqm, fixed_variables=None, **parameters):\n return super().sample(bqm, fixed_variables=fixed_variables, **parameters)","def sample(self, bqm, **parameters):\n return self.child.sample(bqm, **parameters)","def _construct_sample_from_input(self):\n xi = T.matrix()\n xo = T.matrix()\n irs = self.ir_steps\n oputs = [self.obs_transform(self.s0)]\n oputs.extend([self.obs_transform(self.si[i]) for i in range(irs)])\n _, hi_zmuv = self._construct_zmuv_samples(xi, 1)\n sample_func = theano.function(inputs=[xi, xo], outputs=oputs, \\\n givens={ self.x_in: xi, \\\n self.x_out: xo, \\\n self.hi_zmuv: hi_zmuv }, \\\n updates=self.scan_updates)\n def conditional_sampler(XI, XO=None, guided_decoding=False):\n XI = to_fX( XI )\n if XO is None:\n XO = XI\n XO = to_fX( XO )\n # set model to desired generation mode\n old_switch = self.train_switch.get_value(borrow=False)\n if guided_decoding:\n # take samples from guide policies (i.e. variational q)\n self.set_train_switch(switch_val=1.0)\n else:\n # take samples from model's generative policy\n self.set_train_switch(switch_val=0.0)\n # draw guided/unguided conditional samples\n model_samps = sample_func(XI, XO)\n # set model back to either training or generation mode\n self.set_train_switch(switch_val=old_switch)\n return model_samps\n return conditional_sampler","def qaoa_sample(\n problem_instance: BinaryProblem,\n beta: numpy.ndarray,\n gamma: numpy.ndarray,\n num_samples: int,\n backend: str = \"qcware/cpu\",\n):\n pass","def _sample(self, X, y):\n self._validate_estimator()\n X_res, y_res = self.tomek_.fit_sample(X, y)\n\n return self.smote_.fit_sample(X_res, y_res)","def sample(self, observation):\n raise NotImplementedError","def sample_qubo(self, Q, **parameters):\n return self.child.sample_qubo(Q, **parameters)","def model_quadratic(train_x, train_y, test_x):\n train_x = train_x.rename('x', axis=1)\n train_x = sm.add_constant(train_x)\n train_df = train_x.copy()\n train_df['y'] = train_y\n model_fit = sm.formula.ols('y ~ np.power(x, 2) + x + const', data=train_df).fit()\n model_info = {'model': 'quadratic', 'R2': model_fit.rsquared, 'f_pvalue': model_fit.f_pvalue,\n 'const': model_fit.params.const}\n test_x = test_x.rename('x')\n test_x = sm.add_constant(test_x)\n predictions = model_fit.predict(test_x)\n return predictions, model_info","def sample(self, x):","def sample(pi, sigma, mu):\n # print(\"sample: pi:\", pi.size(), pi)\n categorical = Categorical(pi)\n pis = list(categorical.sample().data)\n sample = Variable(sigma.data.new(sigma.size(0), sigma.size(2)).normal_())\n for i, idx in enumerate(pis):\n sample[i] = sample[i].mul(sigma[i,idx]).add(mu[i,idx])\n return sample","def test_quadratic_features_explicit():\n X_observed = QuadraticFeatures().fit_transform(X_standardized)\n X_expected = np.hstack(\n [\n X_standardized,\n (X_standardized[:, 0] * X_standardized[:, 0]).reshape((-1, 1)),\n (X_standardized[:, 1] * X_standardized[:, 1]).reshape((-1, 1)),\n (X_standardized[:, 0] * X_standardized[:, 1]).reshape((-1, 1)),\n ]\n )\n np.testing.assert_array_equal(X_observed, X_expected)","def _get_sample(self):\n mu = self._get_mean().reshape((1, self.out_dim))\n sigma = self.variables[\"s\"]\n sample = self.random.normal(mu, sigma)\n sample = sample.reshape(self.out_dim)\n return sample","def sample(self, probs):\n all_abstain = (self.label_matrix == -1).sum(axis=1) == self.label_matrix.shape[1]\n self.is_in_pool = (self.ground_truth_labels == -1) & ~ all_abstain & (self.y_train != -1)\n self.valid_buckets = np.unique(self.unique_inverse[self.is_in_pool])\n self.is_valid_bucket = np.array([\n True if i in self.valid_buckets else False for i in range(len(self.unique_idx))])\n self.bucket_probs = probs.detach().numpy()[self.unique_idx]\n\n pick = random.uniform(0, 1)\n if pick < self.randomness:\n # Choose random bucket instead of following a specific query strategy\n chosen_bucket = np.random.choice(self.valid_buckets)\n else:\n chosen_bucket = np.random.choice(self.query())\n\n return random.choice(np.where((self.unique_inverse == chosen_bucket) & self.is_in_pool)[0])","def sample(self, shape):\n\t\traise NotImplementedError()","def quadratic_fit(self, xy, W):\n\t\t# first construct the independent matrix\n\t\ty = xy[:,1]\n\t\tx = xy[:,0]\n\t\tX = np.column_stack([np.ones(len(x)),\n\t\t\t\t\t\t\tx, np.power(x,2)])\n\n\t\twls_model = sm.WLS(y, X, weights = 1.0/W)\t\n\t\twls_model_results = wls_model.fit()\n\t\t[c,b,a] = wls_model_results.params\t\n\t\treturn [a,b,c]","def sample(self, state, model_args, model_kwargs):\n raise NotImplementedError","def subsample(self, dQ):\n # Assumes self contains sorted Qo and associated T, L\n # Note: calc_Qo is already sorted\n Q = np.arange(self.Qo[0], self.Qo[-1], dQ)\n idx = np.unique(np.searchsorted(self.Qo, Q))\n #print len(idx), len(self.Qo)\n\n self.T, self.dT = self.T[idx], self.dT[idx]\n self.L, self.dL = self.L[idx], self.dL[idx]\n self.Qo, self.dQo = self.Qo[idx], self.dQo[idx]\n if self.R is not None:\n self.R = self.R[idx]\n if self.dR is not None:\n self.dR = self.dR[idx]\n self._set_calc(self.T, self.L)","def sample(self):\n u = np.asarray(np.random.uniform())\n return self.invert(u)","def sample(self):\n raise NotImplementedError","def sample(self):\n raise NotImplementedError","def _sample_beta_and_sigma_y(self):\n phi_X = self.phi(self.X, self.W, add_bias=True)\n cov_j = self.B0 + phi_X.T @ phi_X\n mu_j = np.tile((self.B0 @ self.b0), (self.J, 1)).T + \\\n (phi_X.T @ self.Y)\n # multi-output generalization of mvn sample code\n L = np.linalg.cholesky(cov_j)\n Z = self.rng.normal(size=self.beta.shape).T\n LZ = solve_triangular(L, Z, lower=True, trans='T')\n L_mu = dpotrs(L, mu_j, lower=True)[0]\n self.beta[:] = (LZ + L_mu).T\n # sample from inverse gamma\n a_post = self.gamma_a0 + .5 * self.N\n b_post = self.gamma_b0 + .5 * np.diag(\n (self.Y.T @ self.Y) + \\\n (self.b0 @ self.B0 @ self.b0.T) + \\\n (mu_j.T @ np.linalg.solve(cov_j, mu_j))\n )\n self.sigma_y = 1. / self.rng.gamma(a_post, 1./b_post)","def sample(self):\n sampleIndices = self.random_state.choice(len(self.X), int(len(self.X)*self.sample_ratio), replace=False)\n\n return self.X[sampleIndices]\n pass","def test_quadratic_features_single_column_input_explicit():\n X_observed = QuadraticFeatures().fit_transform(X_standardized[:, 0].reshape((-1, 1)))\n X_expected = np.hstack([X_standardized[:, [0]], (X_standardized[:, 0] * X_standardized[:, 0]).reshape((-1, 1)),])\n np.testing.assert_array_equal(X_observed, X_expected)","def sample(self):\n high = self.high.type(torch.float64) if self.dtype.is_floating_point else self.high.type(torch.int64) + 1\n sample = torch.empty(self.shape, dtype=torch.float64)\n\n # Masking arrays which classify the coordinates according to interval\n # type\n unbounded = ~self.bounded_below & ~self.bounded_above\n upp_bounded = ~self.bounded_below & self.bounded_above\n low_bounded = self.bounded_below & ~self.bounded_above\n bounded = self.bounded_below & self.bounded_above\n\n # Vectorized sampling by interval type\n sample[unbounded] = torch.randn(unbounded[unbounded].shape, dtype=torch.float64)\n\n sample[low_bounded] = (-torch.rand(low_bounded[low_bounded].shape, dtype=torch.float64)).exponential_() + \\\n self.low[low_bounded]\n\n sample[upp_bounded] = self.high[upp_bounded] - (\n -torch.rand(upp_bounded[upp_bounded].shape, dtype=torch.float64)).exponential_()\n\n sample[bounded] = (self.low[bounded] - high[bounded]) * torch.rand(bounded[bounded].shape,\n dtype=torch.float64) + high[bounded]\n\n if not self.dtype.is_floating_point: # integer\n sample = torch.floor(sample)\n\n return sample.type(self.dtype)","def draw_bs_sample(data):\n return rg.choice(data, size=len(data))","def next_sample(self, z):\n xp = self.A @ self.x\n Pp = self.A @ self.P @ self.A.T + self.Q\n\n self.K = Pp @ self.H.T * inv(self.H @ Pp @ self.H.T + self.R)\n\n self.x = xp + self.K @ (np.array(np.array([[z]]) - self.H @ xp))\n self.P = Pp - self.K @ self.H @ Pp\n\n self.volt = self.x[0]\n return self.volt","def sample_from_unit_ball(rng, dim):\n vec = rng.randn(dim)\n return vec / np.sqrt(np.sum(vec**2))","def sample(self, nframes):\n if not self.__is_valid:\n raise GmParamError(\"\"\"Parameters of the model has not been \n set yet, please set them using self.set_param()\"\"\")\n\n # State index (ie hidden var)\n sti = gen_rand_index(self.w, nframes)\n # standard gaussian samples\n x = randn(nframes, self.d) \n\n if self.mode == 'diag':\n x = self.mu[sti, :] + x * N.sqrt(self.va[sti, :])\n elif self.mode == 'full':\n # Faster:\n cho = N.zeros((self.k, self.va.shape[1], self.va.shape[1]))\n for i in range(self.k):\n # Using cholesky looks more stable than sqrtm; sqrtm is not\n # available in numpy anyway, only in scipy...\n cho[i] = lin.cholesky(self.va[i*self.d:i*self.d+self.d, :])\n\n for s in range(self.k):\n tmpind = N.where(sti == s)[0]\n x[tmpind] = N.dot(x[tmpind], cho[s].T) + self.mu[s]\n else:\n raise GmParamError(\"cov matrix mode not recognized, \"\\\n \"this is a bug !\")\n\n return x","def sample_from(space):\n distrs = {\n 'choice': choice,\n 'randint': randint,\n 'uniform': uniform,\n 'normal': normal,\n }\n s = space[0]\n\n np.random.seed(int(time.time() + np.random.randint(0, 300)))\n\n log = s.startswith('log_')\n s = s[len('log_'):] if log else s\n\n quantized = s.startswith('q')\n s = s[1:] if quantized else s\n\n distr = distrs[s]\n if s == 'choice':\n return distr(space[1])\n samp = distr(space[1], space[2])\n if log:\n samp = np.exp(samp)\n if quantized:\n samp = round((samp / space[3]) * space[3])\n return samp","def sample(self,p0=None,nsamp=None): \r\n raise NotImplementedError('Need to implement sample function')","def sample(self):\r\n raise NotImplementedError","def signalroisample(filename,obs):\n from samplingdist import readworkspace,readfile\n #f,w,obsdict,modeldict,databkgdict,datasigdict = readworkspace(filename)\n f,obsdict,modeldict,databkgdict,datasigdict = readfile(filename)\n if not obsdict.has_key(obs):\n raise RuntimeError(\"Observable '%s' not defined\" % obs)\n sd = ObservableSamplingProb(obsdict[obs])\n sd.setupmodel('bkg','negative_binomial_pdf')\n sd.setupmodel('sig','negative_binomial_sum_pdf')\n\n datasig = datasigdict['dvsig_'+obs]\n databkg = databkgdict['dvbkg_'+obs]\n sd.fitTo(datasig,'sig')\n sd.fitTo(databkg,'bkg')\n\n samplename = filename.split('_')[1]\n sd.plot(samplename,datasig,'sig',sample=samplename+'_sig')\n sd.plot(samplename,databkg,'bkg',sample=samplename+'_bkg')\n\n nfile = filename.split('_')[1]+'_bkgsig_'+obs+'_ws.root'\n sd.update('w',nfile,[datasig,databkg])","def sample(self, shape=(1,)):\n pass","def _sample(self, geometry: Geometry) -> math.Tensor:\n raise NotImplementedError(self)","def sample(self):\n return self(np.random.randn(self.num_xi)).reshape(self.X.shape)","def generate_sample(self):\n\n sample_one = np.zeros(self.n_dimensions)\n\n \"\"\"C: Huge gains here from using numpy functions at once instead of a Python loop\"\"\"\n \"\"\"S: How..?\"\"\"\n\n for i in range(self.n_dimensions):\n self.Y[i] ^= self.V[\n self.index_of_least_significant_zero_bit(self.current - 1), i\n ]\n sample_one[i] = float(self.Y[i] / math.pow(2, self.scale))\n self.current += 1\n return sample_one","def sample_box(self, dim0, dim1=None, bounds=None, lp_rule=None, verbose=False):\n\n # TODO: include in get_par\n\n import chaospy\n\n bnd = bounds or np.array(self.fdict['prior_bounds'])\n dim1 = dim1 or self.ndim\n rule = lp_rule or 'S'\n\n res = chaospy.Uniform(0, 1).sample(size=(dim0, dim1), rule=rule)\n res = (bnd[1] - bnd[0])*res + bnd[0]\n\n return res","def sample_utility(n, model, alpha, beta, bmax):\n A, b = matrix(0.0, (n,n)), matrix(ra.uniform(0,bmax,(n,1)))\n \n if model == 1: A = matrix(ra.uniform(0,beta,(n,n)))\n \n if model == 2:\n for i in range(n):\n for j in range(n/2):\n A[i, int(np.mod(i+j+1,n))] = beta**(j+1)\n A[i, int(np.mod(i-(j+1),n))] = beta**(j+1)\n \n if model == 3: A = 0.5*matrix(ra.binomial(1,beta,(n,n)))\n \n for i in range(n): A[i,i] = 1.0\n \n return Utility((alpha*A,b), 'sqrt')","def test_quadratic_trinomial_init(self):\n a, b, c = 2, 3, 4\n expected = Polynomial(a, b, c)\n\n qt = QuadraticTrinomial(a, b, c)\n\n self.assertEqual(expected, qt)","def sample(x,u):\n if ispoint(x):\n # return pointsample(x)\n return point(x)\n elif isline(x):\n return sampleline(x,u)\n elif isarc(x):\n return samplearc(x,u)\n elif ispoly(x):\n return samplepoly(x,u)\n elif isgeomlist(x):\n return samplegeomlist(x,u)\n else:\n raise ValueError(\"inappropriate type for sample(): \" + str(x))","def draw_bs_sample(data):\n return np.random.choice(data, size=len(data))","def sample(self):\n M = np.random.normal(self._mu.reshape(-1), self._sig).reshape(self.shape)\n return M","def sampling_latent(self):\n \n self.z = gaussian_sample(self.qz_m, self.qz_v)\n if self.scalings:\n self.library = gaussian_sample(self.ql_m, self.ql_v)","def test_proof_model():\n m = build_proof_model()\n with m:\n trace = pm.sample(50)\n assert trace.report.ok","def test_simpSample(self):\n\n #uniform dist\n ulim = [0,1]\n ufun = lambda x: 1.0/np.diff(ulim)\n\n n = int(1e5)\n usample = statsFun.simpSample(ufun,n,ulim[0],ulim[1])\n self.assertGreaterEqual(usample.min(), ulim[0])\n self.assertLessEqual(usample.max(), ulim[1])\n\n nlim = [-10,10]\n nfun = lambda x: np.exp(-x**2./2.0)/np.sqrt(2.0*np.pi)\n nsample = statsFun.simpSample(nfun,n,nlim[0],nlim[1])\n self.assertGreaterEqual(nsample.min(), nlim[0])\n self.assertLessEqual(nsample.min(), nlim[1])\n\n self.assertGreaterEqual(scipy.stats.kstest(usample,'uniform')[1],0.01,'Uniform sample does not look uniform.')\n self.assertGreaterEqual(scipy.stats.kstest(nsample,'norm')[1],0.01,'Normal sample does not look normal.')\n self.assertLessEqual(scipy.stats.kstest(nsample,'uniform')[1],0.01,'Normal sample looks too uniform.')\n self.assertLessEqual(scipy.stats.kstest(usample,'norm')[1],0.01,'Uniform sample looks too normal.')","def in_square():\n return np.random.random_sample(size=2)","def sample(self, seg_logit, seg_label):","def estimate_sample_beta(sample):\n x_s, y_s = zip(*sample)\n reg.fit(x_s, y_s)\n betas = reg.weights_\n return betas","def _construct_sample_from_prior(self):\n z_sym = T.matrix()\n x_sym = T.matrix()\n irs = self.ir_steps\n oputs = [self.obs_transform(self.s0)]\n oputs.extend([self.obs_transform(self.si[i]) for i in range(irs)])\n _, hi_zmuv = self._construct_zmuv_samples(x_sym, 1)\n sample_func = theano.function(inputs=[z_sym, x_sym], outputs=oputs, \\\n givens={ self.z: z_sym, \\\n self.x_in: T.zeros_like(x_sym), \\\n self.x_out: T.zeros_like(x_sym), \\\n self.hi_zmuv: hi_zmuv }, \\\n updates=self.scan_updates)\n def prior_sampler(samp_count):\n x_samps = to_fX( np.zeros((samp_count, self.obs_dim)) )\n old_switch = self.train_switch.get_value(borrow=False)\n # set model to generation mode\n self.set_train_switch(switch_val=0.0)\n z_samps = to_fX( npr.randn(samp_count, self.z_dim) )\n model_samps = sample_func(z_samps, x_samps)\n # set model back to either training or generation mode\n self.set_train_switch(switch_val=old_switch)\n return model_samps\n return prior_sampler","def eval_sampling_point(self, sampling_point):\n return Solution(self, sampling_point)","def sample_from(self):\n return numpy.random.normal(self.mu, math.sqrt(self.sigma))","def test_sample(self, normal_mock):\n # Setup\n instance = GaussianMultivariate(GaussianUnivariate)\n data = pd.DataFrame([\n {'A': 25, 'B': 75, 'C': 100},\n {'A': 30, 'B': 60, 'C': 250},\n {'A': 10, 'B': 65, 'C': 350},\n {'A': 20, 'B': 80, 'C': 150},\n {'A': 25, 'B': 70, 'C': 500}\n ])\n instance.fit(data)\n\n normal_mock.return_value = np.array([\n [0.1, 0.1, 0.1],\n [0.2, 0.2, 0.2],\n [0.4, 0.4, 0.4],\n [0.6, 0.6, 0.6],\n [0.8, 0.8, 0.8]\n ])\n\n expected_result = pd.DataFrame([\n {'A': 22.678232998312527, 'B': 70.70710678118655, 'C': 284.35270009440734},\n {'A': 23.356465996625055, 'B': 71.41421356237309, 'C': 298.7054001888146},\n {'A': 24.712931993250110, 'B': 72.82842712474618, 'C': 327.4108003776293},\n {'A': 26.069397989875164, 'B': 74.24264068711929, 'C': 356.116200566444},\n {'A': 27.425863986500215, 'B': 75.65685424949238, 'C': 384.8216007552586}\n ])\n\n # Run\n result = instance.sample(5)\n\n # Check\n assert result.equals(expected_result)\n\n assert normal_mock.called_once_with(\n np.zeros(instance.covariance.shape[0]),\n instance.covariance,\n 5\n )","def test_quadratic_features_random_state_invariance():\n transformer1 = QuadraticFeatures(random_state=0)\n transformer2 = QuadraticFeatures(random_state=0)\n X1 = transformer1.fit_transform(X_small)\n X2 = transformer2.fit_transform(X_small)\n assert np.all(X1 == X2)","def stocksolution(self):\n return Sample(self.solutes, self.quantities, self.volume, True)","def sample_posterior(self):\n \n# print (\"SAMPLING FROM LINEAR SIMILARITY VB\")\n if (self.posterior_mean == False):\n self.weight = Vil.sample_posterior(self.mu_weight, Vil.softplus(self.rho_weight))\n self.bias = Vil.sample_posterior(self.mu_bias, Vil.softplus(self.rho_bias))\n# print (self.bias)\n else:\n self.weight.data = self.mu_weight.data\n self.bias.data = self.mu_bias.data","def fit(sample):\r\n if not hasattr(sample, \"stddev\"):\r\n sample = Sample(sample)\r\n m = sample.mean\r\n d = sqrt(12*sample.variance)/2\r\n return Uniform(m-d, m+d)","def test_oss_sample_wt_fit():\n\n # Create the object\n oss = OneSidedSelection(random_state=RND_SEED)\n assert_raises(RuntimeError, oss.sample, X, Y)","def sample(problem, seed=None):\n if seed:\n np.random.seed(seed)\n contrast = generate_contrast(problem)\n sample = np.array((contrast + 1.0) / 2, dtype=float)\n problem = extend_bounds(problem)\n\n sample = scale_samples(sample, problem)\n return sample","def _get_sample(self):\n mu = self._get_mean()\n sample = self.random.normal(mu)\n return sample","def next_sample(self, z):\n xp = self.A @ self.x\n Pp = self.A @ self.P @ self.A.T + self.Q\n\n self.K = Pp @ self.H.T * inv(self.H @ Pp @ self.H.T + self.R)\n\n self.x = xp + self.K @ (z - self.H @ xp)\n self.P = Pp - self.K @ self.H @ Pp\n return self.x","def bqm_structured(f):\n @wraps(f)\n def structured_sample(sampler, bqm, **kwargs):\n adjacency = sampler.adjacency\n\n if not adjacency.keys() >= bqm.variables:\n raise BinaryQuadraticModelStructureError(\n f\"given bqm has at least one variable, {(list(bqm.variables) - adjacency.keys()).pop()!r}, \"\n \"not supported by the structured solver\")\n if any(u not in adjacency[v] for u, v, _ in bqm.iter_quadratic()):\n u, v = next((u, v) for u, v, _ in bqm.iter_quadratic() if u not in adjacency[v])\n raise BinaryQuadraticModelStructureError(\n f\"given bqm contains an interaction, {(u, v)!r}, \"\n \"not supported by the structured solver\")\n return f(sampler, bqm, **kwargs)\n return structured_sample","def sample_uniform():\n global samples_uniform, isample_uniform\n\n # sample of U(0, 1)\n u = samples_uniform[isample_uniform]\n\n # moving to next index of samples global array\n isample_uniform += 1\n if isample_uniform >= len(samples_uniform):\n # exhausted all samples -> re-drawing samples from U(0, 1)\n samples_uniform = np.random.uniform(size=SIZE_SAMPLES_UNIFORM)\n isample_uniform = 0\n\n return u","def sample(self, x: Union[np.ndarray, float, list], ):\n x = self._sample_test(x)\n if x.ndim <= 1:\n y = 0\n for i in range(self.mixture_count):\n if self.dimensions == 1:\n y += self.weights[i] * self.one_d_normal(x, self.means[i], self.covs[i])\n else:\n y += self.weights[i] * self.multi_d_gauss(x, self.means[i], self.covs[i])\n else:\n x = np.squeeze(x, axis=1)\n y = np.zeros((x.shape[0], ))\n for i in range(self.mixture_count):\n if self.dimensions == 1:\n y += self.weights[i] * self.one_d_normal(x, self.means[i], self.covs[i])\n else:\n y += self.weights[i] * self.multi_d_gauss(x, self.means[i], self.covs[i])\n return y","def sample_py3(self):\n print(self.weights_.shape)\n try:\n n_samples_comp = self.rng.multinomial(self.n_samples, self.weights_)\n except ValueError:\n self.weights_= np.reshape(self.weights_,len(self.weights_))\n n_samples_comp = self.rng.multinomial(self.n_samples, self.weights_)\n if self.covariance_type == 'full':\n X = np.vstack([\n self.rng.multivariate_normal(mean, covariance, int(sample))\n for (mean, covariance, sample) in zip(\n self.means_, self.covariances_, n_samples_comp)])\n elif self.covariance_type == \"tied\":\n X = np.vstack([\n self.rng.multivariate_normal(mean, self.covariances_, int(sample))\n for (mean, sample) in zip(\n self.means_, n_samples_comp)])\n else:\n X = np.vstack([\n mean + self.rng.randn(sample, n_features) * np.sqrt(covariance)\n for (mean, covariance, sample) in zip(\n self.means_, self.covariances_, n_samples_comp)])\n\n y = np.concatenate([j * np.ones(sample, dtype=int)\n for j, sample in enumerate(n_samples_comp)])\n\n return (X, y)","def quadratic_program_bnd(self, c, Q, lb, ub):\n if self.solver == solver_SCIPY:\n return scipy_quadratic_program_bnd(c, Q, lb, ub)\n elif self.solver == solver_GUROBI:\n return gurobi_quadratic_program_bnd(c, Q, lb, ub)\n else:\n raise ValueError('QP solver %s not available' % self.solver)","def binary_sample(x):\n return np.random.binomial(1, p=x)","def sample(self, i):\n\t\tif self.nsamp % 2 == 0:\n\t\t\ti0 = i-(self.nsamp/2-1)\n\t\t\ti1 = i+(self.nsamp/2)\n\t\telse:\n\t\t\ti0 = i-((self.nsamp-1)/2.)\n\t\t\ti1 = i+((self.nsamp-1)/2.)\n\t\treturn self.yval[i0:i1]","def test_simpSample_trivial(self):\n\n ulim = [0,1]\n ufun = lambda x: 1.0/np.diff(ulim)\n\n n = 10000\n sample = statsFun.simpSample(ufun,n,0.5,0.5)\n\n self.assertEqual(len(sample),n)\n self.assertTrue(np.all(sample == 0.5))","def test_quadratic_features_shape(include_bias, interaction_only, n_output_features):\n transformer = QuadraticFeatures(include_bias=include_bias, interaction_only=interaction_only,)\n XQ = transformer.fit_transform(X_small)\n assert XQ.shape == (X_small_n_rows, n_output_features)","def samplepoint(x,u):\n return point(x)","def sample(self):\n # return [v.sample() for v in self.variables]\n return self.domain[gc.rand_state.choice(len(self.domain))]","def test_quadratic_trinomial_default_init(self):\n expected = Polynomial(1, 1, 1)\n\n qt = QuadraticTrinomial()\n\n self.assertEqual(expected, qt)","def sample_mu(self, val) -> None:\n\n # get data\n data = self.data.reshape((1, -1))\n\n # get values\n gain = val.gain\n states = val.states\n mu_flor = val.mu_flor\n mu_flor_mean = val.mu_flor_mean\n mu_flor_shape = val.mu_flor_shape\n mu_back = val.mu_back\n mu_back_mean = val.mu_back_mean\n mu_back_shape = val.mu_back_shape\n num_data = val.num_data\n num_rois = val.num_rois\n num_states = val.num_states\n\n # initialze variables\n num_vars = num_states + num_rois\n idx = np.where(val.mu_flor_mean > 0)[0]\n # shape\n shape = np.zeros((num_vars, 1))\n shape[:num_states, 0] = mu_flor_shape[:]\n shape[num_states:, 0] = mu_back_shape\n # scale\n scale = np.zeros((num_vars, 1))\n scale[idx, 0] = mu_flor_mean[idx] / mu_flor_shape[idx]\n scale[num_states:, 0] = (mu_back_mean / mu_back_shape)[:]\n\n # initialize a mu vector containing the variables we wish to sample, mu_flor and mu_back\n q = np.zeros((num_vars, 1))\n q[:num_states, 0] = mu_flor[:]\n q[num_states:, 0] = mu_back[:]\n q_old = q.copy()\n idy = q > 0 # keep track of which states are dark (we only sample bright states)\n num_var = q.shape[0]\n\n # hmc dynamics variables\n h = np.random.exponential() / 100\n masses = (1 + np.random.pareto(1, size=q.shape))\n masses_inv = np.zeros(shape=masses.shape) # negative mass is interpretted as an unchanging variable\n masses_inv[masses > 0] = 1 / masses[masses > 0]\n num_steps = np.random.poisson(25)\n\n # create populations array\n pops = np.zeros((num_vars, num_rois * num_data))\n \"\"\"\n pops is an array such that each element i, j corresponds to the \n multiplicitive factor in front of q[i] for data point j in the \n likelihood. For example, if in ROI 1 at time level 17 there are two\n fluorophores in the bright state, then we find the element, j,\n corresponding to ROI 1 and time level 17, and we find the element,\n i, corresponding to the bright state, and we set q[i,j]=2 (because\n there are two bright fluorophores), then we would find the i\n corresponding to the background brightness of ROI 1, and we would\n set this q[i,j]=1 (the multiplicitive factor in front of the \n background brightness is 1 when it is the corresponding ROI and 0\n otherwise).\n \"\"\"\n for r in range(num_rois):\n idx = np.arange(r*num_data, (r+1)*num_data)\n pops[:num_states, idx] = states_to_pops(states[r, :, :], num_states)\n pops[num_states + r, idx] = 1\n\n # the conditional probability for the mu vector\n def probability(q_, p_):\n if np.sum(q_ < 0) > 0:\n prob = -np.inf\n else:\n prob = (\n np.sum(stats.gamma.logpdf(data, a=q_.T @ pops, scale=gain)) # likelihood\n + np.sum(stats.gamma.logpdf(q_[idy], a=shape[idy], scale=scale[idy])) # prior\n + np.sum(stats.norm.logpdf(p_[idy], loc=0, scale=np.sqrt(masses[idy]))) # momentum\n )\n return prob\n\n # the gradient of the Hamiltonian with respect to the mu_vector\n def dH_dq(q_):\n if np.any(q_ < 0):\n \"\"\"\n In the event that q_new becomes negative, fast_digamma becomes\n slow. Since q should never be negative anyway, there is no\n need for further computation and we can skip this step knowing\n that this value of q will be rejected anyway.\n \"\"\"\n return q_\n q_new = np.zeros(q_.shape)\n q_new[idy] = (\n (shape[idy] - 1) / q_[idy] - 1 / scale[idy]\n + (pops @ (np.log(data / gain) - fast_digamma(q_.T @ pops)).T)[idy]\n )\n return q_new\n\n # sample momentum\n p = np.random.randn(num_var, 1) * np.sqrt(masses)\n p_old = p.copy()\n\n # run the HMC\n for i in range(num_steps):\n p = p + .5 * h * dH_dq(q)\n q = q + h * p * masses_inv\n p = p + .5 * h * dH_dq(q)\n\n # find acceptance ratio\n P_new = probability(q, p)\n P_old = probability(q_old, p_old)\n if (P_new - P_old) < np.log(np.random.rand()):\n q = q_old\n\n # update the new mu values\n val.mu_flor[:] = q[:num_states, 0]\n val.mu_back[:] = q[num_states:, 0]\n\n return","def to_bqm(self, model):\n linear = ((v, float(model.get_py_value(bias)))\n for v, bias in self.linear.items())\n quadratic = ((u, v, float(model.get_py_value(bias)))\n for (u, v), bias in self.quadratic.items())\n offset = float(model.get_py_value(self.offset))\n\n return BQM(linear, quadratic, offset, dimod.SPIN)","def sample(self):\n\n # pick sample type according to probability\n samplers = [\"unif\", \"geo\", \"diverse\"]\n sample_idx = np.random.multinomial(\n 1, [self.unif_prob, self.geo_prob, self.diverse_prob])\n idx = np.argmax(sample_idx)\n sampler = samplers[idx]\n\n if sampler == \"unif\":\n return self.unif_sampler()\n if sampler == \"geo\":\n return self.geo_sampler()\n if sampler == \"diverse\":\n return self.diverse_sampler()","def sample(wave, factor):\n ys = np.zeros(len(wave))\n ys[::factor] = np.real(wave.ys[::factor])\n return Wave(ys, framerate=wave.framerate)","def _sample(self, points: Iterable[float]) -> np.array:\n pass","def sample(self, m):\n i = torch.multinomial(self.weights, m, replacement=True)\n return self.particles[i,:]","def _SampleInputMatrix(nrows, bl, bu, distname='randomUniform'):\n npars = len(bl)\n x = np.zeros((nrows,npars))\n bound = bu-bl\n for i in range(nrows):\n # x[i,:]= bl + DistSelector([0.0,1.0,npars],distname='randomUniform')*bound # only used in full Vhoeys-framework\n x[i,:]= bl + np.random.rand(1,npars)*bound\n return x","def samplepoly(a,u):\n \n if not ispoly(a):\n raise ValueError('non-poly passed to samplepoly')\n\n closed=False\n\n lines,lengths,length = __lineslength(a)\n if len(a) > 2 and dist(a[0],a[-1]) < epsilon:\n closed = True\n\n if closed:\n u=u%1.0\n \n dst = u * length;\n d = 0\n if u < 1.0:\n for i in range(len(lines)):\n l=lengths[i]\n if dst <= d+l:\n uu = 1.0 - (d+l-dst)/l\n return sampleline(lines[i],uu)\n else:\n d+=l\n else:\n uu = (dst-length+lengths[-1])/lengths[-1]\n return sampleline(lines[-1],uu)","def sample(self, sample_shape=torch.Size()):\n with torch.no_grad():\n return self.rsample(sample_shape=sample_shape)","def sample(self, point, n_samples=1):\n raise NotImplementedError(\"The sample method is not yet implemented.\")","def rational_quadratic(input_dim, variance=1., lengthscale=1., power=1.):\r\n part = parts.rational_quadratic.RationalQuadratic(input_dim, variance, lengthscale, power)\r\n return kern(input_dim, [part])","def get_uniform_subset(self, samples_per_label):\n raise NotImplementedError","def sample(self, s):\n rng = np.random.default_rng()\n return rng.choice(np.arange(self.n_actions), p=self.eval(s))","def sample_b(self):\n # don't sample b-factors with em\n if not self.options.sample_bfactors or self.options.em:\n return\n\n new_coor = []\n new_bfactor = []\n multiplication_factors = [1.0, 1.3, 1.5, 0.9, 0.5]\n coor_b_pairs = zip(self._coor_set, self._bs)\n for (coor, b), multi in itertools.product(coor_b_pairs, multiplication_factors):\n new_coor.append(coor)\n new_bfactor.append(b * multi)\n self._coor_set = new_coor\n self._bs = new_bfactor","def sample_from_simplex(rng, dim):\n alpha = [1] * dim\n return rng.dirichlet(alpha)","def get_sample(x, y):\n return noise[x][y]","def sample(self) -> np.ndarray:\n q_target = np.empty(self.d)\n for i in range(self.d):\n q_target[i] = self.lim_lo[i] + np.random.rand() * (self.lim_up[i] - self.lim_lo[i])\n return q_target","def sample_spherical(self):\n vec = np.random.randn(self.dims, self.arms)\n vec /= np.linalg.norm(vec, axis=0)\n self.contexts = vec.T","def initial_samples(lb, ub, method, numSamp):\r\n if not len(lb) == len(ub):\r\n raise AssertionError('Lower and upper bounds have different #s of design variables in initial_samples function.')\r\n assert method == 'random' or method == 'nolh' or method == 'nolh-rp' or method == 'nolh-cdr' or method == 'lhc' or method == 'rand-wor', 'An invalid method was specified for the initial_samples.'\r\n assert (method == 'nolh' or method == 'nolh-rp' or method == 'nolh-cdr') and len(ub) >= 2 and len(ub) <= 29, 'The Phase space dimensions are outside of the bounds for initial_samples.'\r\n for case in Switch(method):\r\n if case('random'):\r\n s = np.zeros((numSamp, len(lb)))\r\n for i in range(0, numSamp, 1):\r\n s[i, :] = lb + (ub - lb) * rand(len(lb))\r\n\r\n break\r\n if case('rand-wor'):\r\n s = np.zeros((numSamp, len(lb)))\r\n for i in range(0, numSamp, 1):\r\n s[i, :] = choice(len(ub), size=len(ub), replace=False)\r\n\r\n break\r\n if case('nolh'):\r\n dim = len(ub)\r\n m, q, r = params(dim)\r\n conf = range(q)\r\n if r != 0:\r\n remove = range(dim - r, dim)\r\n nolh = NOLH(conf, remove)\r\n else:\r\n nolh = NOLH(conf)\r\n s = np.array([ list(lb + (ub - lb) * nolh[i, :]) for i in range(len(nolh[:, 0]))\r\n ])\r\n break\r\n if case('nolh-rp'):\r\n dim = len(ub)\r\n m, q, r = params(dim)\r\n conf = random.sample(range(q), q)\r\n if r != 0:\r\n remove = random.sample(range(q - 1), r)\r\n nolh = NOLH(conf, remove)\r\n else:\r\n nolh = NOLH(conf)\r\n s = np.array([ list(lb + (ub - lb) * nolh[i, :]) for i in range(len(nolh[:, 0]))\r\n ])\r\n break\r\n if case('nolh-cdr'):\r\n dim = len(ub)\r\n m, q, r = params(dim)\r\n conf, remove = get_cdr_permutations(len(ub))\r\n if remove != []:\r\n nolh = NOLH(conf, remove)\r\n else:\r\n nolh = NOLH(conf)\r\n s = np.array([ list(lb + (ub - lb) * nolh[i, :]) for i in range(len(nolh[:, 0]))\r\n ])\r\n break\r\n if case('lhc'):\r\n tmp = lhs(len(lb), samples=numSamp, criterion='center')\r\n s = np.array([ list(lb + (ub - lb) * tmp[i, :]) for i in range(len(tmp[:, 0]))\r\n ])\r\n break\r\n if case():\r\n print 'Somehow you evaded my assert statement - good job!',\r\n print ' However, you still need to use a valid method string.'\r\n\r\n return s","def evalQuad(a,b,c,x):\n return a * x**2 + b*x + c","def sample(self, x):\n x_minus_mu = x - self.mu\n pwr = -(np.dot(np.dot (x_minus_mu.transpose(), self.cov_inv),\n x_minus_mu) / 2.0)\n return math.exp(pwr) #/ self.root_2pi_d_det","def sample_random_architecture(self, dataset_api):\n while True:\n matrix = np.random.choice(\n [0, 1], size=(NUM_VERTICES, NUM_VERTICES))\n matrix = np.triu(matrix, 1)\n ops = np.random.choice(OPS, size=NUM_VERTICES).tolist()\n ops[0] = INPUT\n ops[-1] = OUTPUT\n spec = dataset_api['api'].ModelSpec(matrix=matrix, ops=ops)\n if dataset_api['nb101_data'].is_valid(spec):\n break\n \n self.set_spec({'matrix':matrix, 'ops':ops})","def sample_survey(self, **kwargs):","def sampling_algorithm(self, X, y):\r\n n_to_sample = self.det_n_to_sample(self.proportion)\r\n\r\n if n_to_sample == 0:\r\n return self.return_copies(X, y, \"Sampling is not needed\")\r\n\r\n X_min = X[y == self.min_label]\r\n X_maj = X[y == self.maj_label]\r\n\r\n # fitting nearest neighbors model to find closest majority points to\r\n # minority samples\r\n nn_params = {**self.nn_params}\r\n nn_params['metric_tensor'] = \\\r\n self.metric_tensor_from_nn_params(nn_params, X, y)\r\n\r\n density = self.calculate_density(X_min, X_maj, nn_params)\r\n\r\n # fitting nearest neighbors model to minority samples to run\r\n # SMOTE-like sampling\r\n n_neighbors = min([len(X_min), self.n_neighbors+1])\r\n nnmt = NearestNeighborsWithMetricTensor(n_neighbors=n_neighbors,\r\n n_jobs=self.n_jobs,\r\n **nn_params)\r\n nnmt.fit(X_min)\r\n ind = nnmt.kneighbors(X_min, return_distance=False)\r\n\r\n samples = self.sample_simplex(X=X_min,\r\n indices=ind,\r\n n_to_sample=n_to_sample,\r\n base_weights=density)\r\n\r\n # do the sampling\r\n #samples = []\r\n #while len(samples) < n_to_sample:\r\n # idx = self.random_state.choice(np.arange(len(density)), p=density)\r\n # random_neighbor_idx = self.random_state.choice(ind[idx][1:])\r\n # X_a = X_min[idx]\r\n # X_b = X_min[random_neighbor_idx]\r\n # samples.append(self.sample_between_points(X_a, X_b))\r\n\r\n return (np.vstack([X, samples]),\r\n np.hstack([y, np.repeat(self.min_label, len(samples))]))","def sample(self, bqm, chain_strength=1.0, **parameters):\n\n # solve the problem on the child system\n child = self.child\n\n # apply the embedding to the given problem to map it to the child sampler\n __, target_edgelist, target_adjacency = child.structure\n\n # add self-loops to edgelist to handle singleton variables\n source_edgelist = list(bqm.quadratic) + [(v, v) for v in bqm.linear]\n\n # get the embedding\n embedding = minorminer.find_embedding(source_edgelist, target_edgelist)\n\n if bqm and not embedding:\n raise ValueError(\"no embedding found\")\n\n bqm_embedded = dimod.embed_bqm(bqm, embedding, target_adjacency, chain_strength=chain_strength)\n\n response = child.sample(bqm_embedded, **parameters)\n\n return dimod.unembed_response(response, embedding, source_bqm=bqm)","def test_gradient_exception_on_sample(self):\n dev = qml.device(\"default.qubit\", wires=2, shots=1000)\n\n @qml.qnode(dev, diff_method=\"parameter-shift\")\n def circuit(x):\n qml.RX(x, wires=[0])\n return qml.sample(qml.PauliZ(0)), qml.sample(qml.PauliX(1))\n\n with pytest.raises(\n qml.QuantumFunctionError,\n match=\"Circuits that include sampling can not be differentiated.\",\n ):\n grad_fn = autograd.jacobian(circuit)\n grad_fn(1.0)","def sample(self):","def varietySample(V, x, count_max, R2, eps_bound):\n \n #x = np.array(V.gens);\n N = len(x)\n t = sp.symbols(\"t\") #Parameter of line\n #count_max = 200\n count = 0\n #N = length(x)\n P = np.empty([N,0])\n while count < count_max:\n # Corrupt the variety with bounded noise \n epsilon = np.random.uniform(-eps_bound, eps_bound)\n Ve = V + epsilon \n \n # Get a line u + v t in space \n U = sp.Matrix(np.random.randn(2, N+1));\n Ur = np.array(U.rref()[0].transpose().tolist(), dtype=float)\n u = Ur[1:, 0]\n v = Ur[1:, 1]\n \n L = u + v * t \n \n #substitute in the line and find real roots\n VL = Ve.subs([i for i in zip(x, L)])\n cVL = sp.Poly(VL).coeffs()\n rVL = np.roots(cVL)\n r_real = np.real(rVL[np.isreal(rVL)])\n \n \n \n #recover points of intersection and append to array\n p = u[:, np.newaxis] + np.outer(v, r_real) \n pnorm = np.sum(p**2, 0)\n \n pcand= p[:, pnorm <= R2]\n\n # if pcand.shape[1] <= 1:\n # pcand0 = pcand\n # else:\n # #pcand0 = pcand[:, 0]\n # pcand0 = pcand[..., 0][:, np.newaxis] #this is dumb\n #\n # P = np.concatenate([P, pcand0], 1)\n P = np.concatenate([P, pcand], 1)\n \n #start new sampling iteration\n count = count + np.size(pcand, 1)\n \n return P"],"string":"[\n \"def sample(self,noise,s):\\n rhs=self.prior.sqrtM*noise\\n self.prior.Msolver.solve(s,rhs)\",\n \"def sample(self, bqm, fixed_variables=None, **parameters):\\n return super().sample(bqm, fixed_variables=fixed_variables, **parameters)\",\n \"def sample(self, bqm, **parameters):\\n return self.child.sample(bqm, **parameters)\",\n \"def _construct_sample_from_input(self):\\n xi = T.matrix()\\n xo = T.matrix()\\n irs = self.ir_steps\\n oputs = [self.obs_transform(self.s0)]\\n oputs.extend([self.obs_transform(self.si[i]) for i in range(irs)])\\n _, hi_zmuv = self._construct_zmuv_samples(xi, 1)\\n sample_func = theano.function(inputs=[xi, xo], outputs=oputs, \\\\\\n givens={ self.x_in: xi, \\\\\\n self.x_out: xo, \\\\\\n self.hi_zmuv: hi_zmuv }, \\\\\\n updates=self.scan_updates)\\n def conditional_sampler(XI, XO=None, guided_decoding=False):\\n XI = to_fX( XI )\\n if XO is None:\\n XO = XI\\n XO = to_fX( XO )\\n # set model to desired generation mode\\n old_switch = self.train_switch.get_value(borrow=False)\\n if guided_decoding:\\n # take samples from guide policies (i.e. variational q)\\n self.set_train_switch(switch_val=1.0)\\n else:\\n # take samples from model's generative policy\\n self.set_train_switch(switch_val=0.0)\\n # draw guided/unguided conditional samples\\n model_samps = sample_func(XI, XO)\\n # set model back to either training or generation mode\\n self.set_train_switch(switch_val=old_switch)\\n return model_samps\\n return conditional_sampler\",\n \"def qaoa_sample(\\n problem_instance: BinaryProblem,\\n beta: numpy.ndarray,\\n gamma: numpy.ndarray,\\n num_samples: int,\\n backend: str = \\\"qcware/cpu\\\",\\n):\\n pass\",\n \"def _sample(self, X, y):\\n self._validate_estimator()\\n X_res, y_res = self.tomek_.fit_sample(X, y)\\n\\n return self.smote_.fit_sample(X_res, y_res)\",\n \"def sample(self, observation):\\n raise NotImplementedError\",\n \"def sample_qubo(self, Q, **parameters):\\n return self.child.sample_qubo(Q, **parameters)\",\n \"def model_quadratic(train_x, train_y, test_x):\\n train_x = train_x.rename('x', axis=1)\\n train_x = sm.add_constant(train_x)\\n train_df = train_x.copy()\\n train_df['y'] = train_y\\n model_fit = sm.formula.ols('y ~ np.power(x, 2) + x + const', data=train_df).fit()\\n model_info = {'model': 'quadratic', 'R2': model_fit.rsquared, 'f_pvalue': model_fit.f_pvalue,\\n 'const': model_fit.params.const}\\n test_x = test_x.rename('x')\\n test_x = sm.add_constant(test_x)\\n predictions = model_fit.predict(test_x)\\n return predictions, model_info\",\n \"def sample(self, x):\",\n \"def sample(pi, sigma, mu):\\n # print(\\\"sample: pi:\\\", pi.size(), pi)\\n categorical = Categorical(pi)\\n pis = list(categorical.sample().data)\\n sample = Variable(sigma.data.new(sigma.size(0), sigma.size(2)).normal_())\\n for i, idx in enumerate(pis):\\n sample[i] = sample[i].mul(sigma[i,idx]).add(mu[i,idx])\\n return sample\",\n \"def test_quadratic_features_explicit():\\n X_observed = QuadraticFeatures().fit_transform(X_standardized)\\n X_expected = np.hstack(\\n [\\n X_standardized,\\n (X_standardized[:, 0] * X_standardized[:, 0]).reshape((-1, 1)),\\n (X_standardized[:, 1] * X_standardized[:, 1]).reshape((-1, 1)),\\n (X_standardized[:, 0] * X_standardized[:, 1]).reshape((-1, 1)),\\n ]\\n )\\n np.testing.assert_array_equal(X_observed, X_expected)\",\n \"def _get_sample(self):\\n mu = self._get_mean().reshape((1, self.out_dim))\\n sigma = self.variables[\\\"s\\\"]\\n sample = self.random.normal(mu, sigma)\\n sample = sample.reshape(self.out_dim)\\n return sample\",\n \"def sample(self, probs):\\n all_abstain = (self.label_matrix == -1).sum(axis=1) == self.label_matrix.shape[1]\\n self.is_in_pool = (self.ground_truth_labels == -1) & ~ all_abstain & (self.y_train != -1)\\n self.valid_buckets = np.unique(self.unique_inverse[self.is_in_pool])\\n self.is_valid_bucket = np.array([\\n True if i in self.valid_buckets else False for i in range(len(self.unique_idx))])\\n self.bucket_probs = probs.detach().numpy()[self.unique_idx]\\n\\n pick = random.uniform(0, 1)\\n if pick < self.randomness:\\n # Choose random bucket instead of following a specific query strategy\\n chosen_bucket = np.random.choice(self.valid_buckets)\\n else:\\n chosen_bucket = np.random.choice(self.query())\\n\\n return random.choice(np.where((self.unique_inverse == chosen_bucket) & self.is_in_pool)[0])\",\n \"def sample(self, shape):\\n\\t\\traise NotImplementedError()\",\n \"def quadratic_fit(self, xy, W):\\n\\t\\t# first construct the independent matrix\\n\\t\\ty = xy[:,1]\\n\\t\\tx = xy[:,0]\\n\\t\\tX = np.column_stack([np.ones(len(x)),\\n\\t\\t\\t\\t\\t\\t\\tx, np.power(x,2)])\\n\\n\\t\\twls_model = sm.WLS(y, X, weights = 1.0/W)\\t\\n\\t\\twls_model_results = wls_model.fit()\\n\\t\\t[c,b,a] = wls_model_results.params\\t\\n\\t\\treturn [a,b,c]\",\n \"def sample(self, state, model_args, model_kwargs):\\n raise NotImplementedError\",\n \"def subsample(self, dQ):\\n # Assumes self contains sorted Qo and associated T, L\\n # Note: calc_Qo is already sorted\\n Q = np.arange(self.Qo[0], self.Qo[-1], dQ)\\n idx = np.unique(np.searchsorted(self.Qo, Q))\\n #print len(idx), len(self.Qo)\\n\\n self.T, self.dT = self.T[idx], self.dT[idx]\\n self.L, self.dL = self.L[idx], self.dL[idx]\\n self.Qo, self.dQo = self.Qo[idx], self.dQo[idx]\\n if self.R is not None:\\n self.R = self.R[idx]\\n if self.dR is not None:\\n self.dR = self.dR[idx]\\n self._set_calc(self.T, self.L)\",\n \"def sample(self):\\n u = np.asarray(np.random.uniform())\\n return self.invert(u)\",\n \"def sample(self):\\n raise NotImplementedError\",\n \"def sample(self):\\n raise NotImplementedError\",\n \"def _sample_beta_and_sigma_y(self):\\n phi_X = self.phi(self.X, self.W, add_bias=True)\\n cov_j = self.B0 + phi_X.T @ phi_X\\n mu_j = np.tile((self.B0 @ self.b0), (self.J, 1)).T + \\\\\\n (phi_X.T @ self.Y)\\n # multi-output generalization of mvn sample code\\n L = np.linalg.cholesky(cov_j)\\n Z = self.rng.normal(size=self.beta.shape).T\\n LZ = solve_triangular(L, Z, lower=True, trans='T')\\n L_mu = dpotrs(L, mu_j, lower=True)[0]\\n self.beta[:] = (LZ + L_mu).T\\n # sample from inverse gamma\\n a_post = self.gamma_a0 + .5 * self.N\\n b_post = self.gamma_b0 + .5 * np.diag(\\n (self.Y.T @ self.Y) + \\\\\\n (self.b0 @ self.B0 @ self.b0.T) + \\\\\\n (mu_j.T @ np.linalg.solve(cov_j, mu_j))\\n )\\n self.sigma_y = 1. / self.rng.gamma(a_post, 1./b_post)\",\n \"def sample(self):\\n sampleIndices = self.random_state.choice(len(self.X), int(len(self.X)*self.sample_ratio), replace=False)\\n\\n return self.X[sampleIndices]\\n pass\",\n \"def test_quadratic_features_single_column_input_explicit():\\n X_observed = QuadraticFeatures().fit_transform(X_standardized[:, 0].reshape((-1, 1)))\\n X_expected = np.hstack([X_standardized[:, [0]], (X_standardized[:, 0] * X_standardized[:, 0]).reshape((-1, 1)),])\\n np.testing.assert_array_equal(X_observed, X_expected)\",\n \"def sample(self):\\n high = self.high.type(torch.float64) if self.dtype.is_floating_point else self.high.type(torch.int64) + 1\\n sample = torch.empty(self.shape, dtype=torch.float64)\\n\\n # Masking arrays which classify the coordinates according to interval\\n # type\\n unbounded = ~self.bounded_below & ~self.bounded_above\\n upp_bounded = ~self.bounded_below & self.bounded_above\\n low_bounded = self.bounded_below & ~self.bounded_above\\n bounded = self.bounded_below & self.bounded_above\\n\\n # Vectorized sampling by interval type\\n sample[unbounded] = torch.randn(unbounded[unbounded].shape, dtype=torch.float64)\\n\\n sample[low_bounded] = (-torch.rand(low_bounded[low_bounded].shape, dtype=torch.float64)).exponential_() + \\\\\\n self.low[low_bounded]\\n\\n sample[upp_bounded] = self.high[upp_bounded] - (\\n -torch.rand(upp_bounded[upp_bounded].shape, dtype=torch.float64)).exponential_()\\n\\n sample[bounded] = (self.low[bounded] - high[bounded]) * torch.rand(bounded[bounded].shape,\\n dtype=torch.float64) + high[bounded]\\n\\n if not self.dtype.is_floating_point: # integer\\n sample = torch.floor(sample)\\n\\n return sample.type(self.dtype)\",\n \"def draw_bs_sample(data):\\n return rg.choice(data, size=len(data))\",\n \"def next_sample(self, z):\\n xp = self.A @ self.x\\n Pp = self.A @ self.P @ self.A.T + self.Q\\n\\n self.K = Pp @ self.H.T * inv(self.H @ Pp @ self.H.T + self.R)\\n\\n self.x = xp + self.K @ (np.array(np.array([[z]]) - self.H @ xp))\\n self.P = Pp - self.K @ self.H @ Pp\\n\\n self.volt = self.x[0]\\n return self.volt\",\n \"def sample_from_unit_ball(rng, dim):\\n vec = rng.randn(dim)\\n return vec / np.sqrt(np.sum(vec**2))\",\n \"def sample(self, nframes):\\n if not self.__is_valid:\\n raise GmParamError(\\\"\\\"\\\"Parameters of the model has not been \\n set yet, please set them using self.set_param()\\\"\\\"\\\")\\n\\n # State index (ie hidden var)\\n sti = gen_rand_index(self.w, nframes)\\n # standard gaussian samples\\n x = randn(nframes, self.d) \\n\\n if self.mode == 'diag':\\n x = self.mu[sti, :] + x * N.sqrt(self.va[sti, :])\\n elif self.mode == 'full':\\n # Faster:\\n cho = N.zeros((self.k, self.va.shape[1], self.va.shape[1]))\\n for i in range(self.k):\\n # Using cholesky looks more stable than sqrtm; sqrtm is not\\n # available in numpy anyway, only in scipy...\\n cho[i] = lin.cholesky(self.va[i*self.d:i*self.d+self.d, :])\\n\\n for s in range(self.k):\\n tmpind = N.where(sti == s)[0]\\n x[tmpind] = N.dot(x[tmpind], cho[s].T) + self.mu[s]\\n else:\\n raise GmParamError(\\\"cov matrix mode not recognized, \\\"\\\\\\n \\\"this is a bug !\\\")\\n\\n return x\",\n \"def sample_from(space):\\n distrs = {\\n 'choice': choice,\\n 'randint': randint,\\n 'uniform': uniform,\\n 'normal': normal,\\n }\\n s = space[0]\\n\\n np.random.seed(int(time.time() + np.random.randint(0, 300)))\\n\\n log = s.startswith('log_')\\n s = s[len('log_'):] if log else s\\n\\n quantized = s.startswith('q')\\n s = s[1:] if quantized else s\\n\\n distr = distrs[s]\\n if s == 'choice':\\n return distr(space[1])\\n samp = distr(space[1], space[2])\\n if log:\\n samp = np.exp(samp)\\n if quantized:\\n samp = round((samp / space[3]) * space[3])\\n return samp\",\n \"def sample(self,p0=None,nsamp=None): \\r\\n raise NotImplementedError('Need to implement sample function')\",\n \"def sample(self):\\r\\n raise NotImplementedError\",\n \"def signalroisample(filename,obs):\\n from samplingdist import readworkspace,readfile\\n #f,w,obsdict,modeldict,databkgdict,datasigdict = readworkspace(filename)\\n f,obsdict,modeldict,databkgdict,datasigdict = readfile(filename)\\n if not obsdict.has_key(obs):\\n raise RuntimeError(\\\"Observable '%s' not defined\\\" % obs)\\n sd = ObservableSamplingProb(obsdict[obs])\\n sd.setupmodel('bkg','negative_binomial_pdf')\\n sd.setupmodel('sig','negative_binomial_sum_pdf')\\n\\n datasig = datasigdict['dvsig_'+obs]\\n databkg = databkgdict['dvbkg_'+obs]\\n sd.fitTo(datasig,'sig')\\n sd.fitTo(databkg,'bkg')\\n\\n samplename = filename.split('_')[1]\\n sd.plot(samplename,datasig,'sig',sample=samplename+'_sig')\\n sd.plot(samplename,databkg,'bkg',sample=samplename+'_bkg')\\n\\n nfile = filename.split('_')[1]+'_bkgsig_'+obs+'_ws.root'\\n sd.update('w',nfile,[datasig,databkg])\",\n \"def sample(self, shape=(1,)):\\n pass\",\n \"def _sample(self, geometry: Geometry) -> math.Tensor:\\n raise NotImplementedError(self)\",\n \"def sample(self):\\n return self(np.random.randn(self.num_xi)).reshape(self.X.shape)\",\n \"def generate_sample(self):\\n\\n sample_one = np.zeros(self.n_dimensions)\\n\\n \\\"\\\"\\\"C: Huge gains here from using numpy functions at once instead of a Python loop\\\"\\\"\\\"\\n \\\"\\\"\\\"S: How..?\\\"\\\"\\\"\\n\\n for i in range(self.n_dimensions):\\n self.Y[i] ^= self.V[\\n self.index_of_least_significant_zero_bit(self.current - 1), i\\n ]\\n sample_one[i] = float(self.Y[i] / math.pow(2, self.scale))\\n self.current += 1\\n return sample_one\",\n \"def sample_box(self, dim0, dim1=None, bounds=None, lp_rule=None, verbose=False):\\n\\n # TODO: include in get_par\\n\\n import chaospy\\n\\n bnd = bounds or np.array(self.fdict['prior_bounds'])\\n dim1 = dim1 or self.ndim\\n rule = lp_rule or 'S'\\n\\n res = chaospy.Uniform(0, 1).sample(size=(dim0, dim1), rule=rule)\\n res = (bnd[1] - bnd[0])*res + bnd[0]\\n\\n return res\",\n \"def sample_utility(n, model, alpha, beta, bmax):\\n A, b = matrix(0.0, (n,n)), matrix(ra.uniform(0,bmax,(n,1)))\\n \\n if model == 1: A = matrix(ra.uniform(0,beta,(n,n)))\\n \\n if model == 2:\\n for i in range(n):\\n for j in range(n/2):\\n A[i, int(np.mod(i+j+1,n))] = beta**(j+1)\\n A[i, int(np.mod(i-(j+1),n))] = beta**(j+1)\\n \\n if model == 3: A = 0.5*matrix(ra.binomial(1,beta,(n,n)))\\n \\n for i in range(n): A[i,i] = 1.0\\n \\n return Utility((alpha*A,b), 'sqrt')\",\n \"def test_quadratic_trinomial_init(self):\\n a, b, c = 2, 3, 4\\n expected = Polynomial(a, b, c)\\n\\n qt = QuadraticTrinomial(a, b, c)\\n\\n self.assertEqual(expected, qt)\",\n \"def sample(x,u):\\n if ispoint(x):\\n # return pointsample(x)\\n return point(x)\\n elif isline(x):\\n return sampleline(x,u)\\n elif isarc(x):\\n return samplearc(x,u)\\n elif ispoly(x):\\n return samplepoly(x,u)\\n elif isgeomlist(x):\\n return samplegeomlist(x,u)\\n else:\\n raise ValueError(\\\"inappropriate type for sample(): \\\" + str(x))\",\n \"def draw_bs_sample(data):\\n return np.random.choice(data, size=len(data))\",\n \"def sample(self):\\n M = np.random.normal(self._mu.reshape(-1), self._sig).reshape(self.shape)\\n return M\",\n \"def sampling_latent(self):\\n \\n self.z = gaussian_sample(self.qz_m, self.qz_v)\\n if self.scalings:\\n self.library = gaussian_sample(self.ql_m, self.ql_v)\",\n \"def test_proof_model():\\n m = build_proof_model()\\n with m:\\n trace = pm.sample(50)\\n assert trace.report.ok\",\n \"def test_simpSample(self):\\n\\n #uniform dist\\n ulim = [0,1]\\n ufun = lambda x: 1.0/np.diff(ulim)\\n\\n n = int(1e5)\\n usample = statsFun.simpSample(ufun,n,ulim[0],ulim[1])\\n self.assertGreaterEqual(usample.min(), ulim[0])\\n self.assertLessEqual(usample.max(), ulim[1])\\n\\n nlim = [-10,10]\\n nfun = lambda x: np.exp(-x**2./2.0)/np.sqrt(2.0*np.pi)\\n nsample = statsFun.simpSample(nfun,n,nlim[0],nlim[1])\\n self.assertGreaterEqual(nsample.min(), nlim[0])\\n self.assertLessEqual(nsample.min(), nlim[1])\\n\\n self.assertGreaterEqual(scipy.stats.kstest(usample,'uniform')[1],0.01,'Uniform sample does not look uniform.')\\n self.assertGreaterEqual(scipy.stats.kstest(nsample,'norm')[1],0.01,'Normal sample does not look normal.')\\n self.assertLessEqual(scipy.stats.kstest(nsample,'uniform')[1],0.01,'Normal sample looks too uniform.')\\n self.assertLessEqual(scipy.stats.kstest(usample,'norm')[1],0.01,'Uniform sample looks too normal.')\",\n \"def in_square():\\n return np.random.random_sample(size=2)\",\n \"def sample(self, seg_logit, seg_label):\",\n \"def estimate_sample_beta(sample):\\n x_s, y_s = zip(*sample)\\n reg.fit(x_s, y_s)\\n betas = reg.weights_\\n return betas\",\n \"def _construct_sample_from_prior(self):\\n z_sym = T.matrix()\\n x_sym = T.matrix()\\n irs = self.ir_steps\\n oputs = [self.obs_transform(self.s0)]\\n oputs.extend([self.obs_transform(self.si[i]) for i in range(irs)])\\n _, hi_zmuv = self._construct_zmuv_samples(x_sym, 1)\\n sample_func = theano.function(inputs=[z_sym, x_sym], outputs=oputs, \\\\\\n givens={ self.z: z_sym, \\\\\\n self.x_in: T.zeros_like(x_sym), \\\\\\n self.x_out: T.zeros_like(x_sym), \\\\\\n self.hi_zmuv: hi_zmuv }, \\\\\\n updates=self.scan_updates)\\n def prior_sampler(samp_count):\\n x_samps = to_fX( np.zeros((samp_count, self.obs_dim)) )\\n old_switch = self.train_switch.get_value(borrow=False)\\n # set model to generation mode\\n self.set_train_switch(switch_val=0.0)\\n z_samps = to_fX( npr.randn(samp_count, self.z_dim) )\\n model_samps = sample_func(z_samps, x_samps)\\n # set model back to either training or generation mode\\n self.set_train_switch(switch_val=old_switch)\\n return model_samps\\n return prior_sampler\",\n \"def eval_sampling_point(self, sampling_point):\\n return Solution(self, sampling_point)\",\n \"def sample_from(self):\\n return numpy.random.normal(self.mu, math.sqrt(self.sigma))\",\n \"def test_sample(self, normal_mock):\\n # Setup\\n instance = GaussianMultivariate(GaussianUnivariate)\\n data = pd.DataFrame([\\n {'A': 25, 'B': 75, 'C': 100},\\n {'A': 30, 'B': 60, 'C': 250},\\n {'A': 10, 'B': 65, 'C': 350},\\n {'A': 20, 'B': 80, 'C': 150},\\n {'A': 25, 'B': 70, 'C': 500}\\n ])\\n instance.fit(data)\\n\\n normal_mock.return_value = np.array([\\n [0.1, 0.1, 0.1],\\n [0.2, 0.2, 0.2],\\n [0.4, 0.4, 0.4],\\n [0.6, 0.6, 0.6],\\n [0.8, 0.8, 0.8]\\n ])\\n\\n expected_result = pd.DataFrame([\\n {'A': 22.678232998312527, 'B': 70.70710678118655, 'C': 284.35270009440734},\\n {'A': 23.356465996625055, 'B': 71.41421356237309, 'C': 298.7054001888146},\\n {'A': 24.712931993250110, 'B': 72.82842712474618, 'C': 327.4108003776293},\\n {'A': 26.069397989875164, 'B': 74.24264068711929, 'C': 356.116200566444},\\n {'A': 27.425863986500215, 'B': 75.65685424949238, 'C': 384.8216007552586}\\n ])\\n\\n # Run\\n result = instance.sample(5)\\n\\n # Check\\n assert result.equals(expected_result)\\n\\n assert normal_mock.called_once_with(\\n np.zeros(instance.covariance.shape[0]),\\n instance.covariance,\\n 5\\n )\",\n \"def test_quadratic_features_random_state_invariance():\\n transformer1 = QuadraticFeatures(random_state=0)\\n transformer2 = QuadraticFeatures(random_state=0)\\n X1 = transformer1.fit_transform(X_small)\\n X2 = transformer2.fit_transform(X_small)\\n assert np.all(X1 == X2)\",\n \"def stocksolution(self):\\n return Sample(self.solutes, self.quantities, self.volume, True)\",\n \"def sample_posterior(self):\\n \\n# print (\\\"SAMPLING FROM LINEAR SIMILARITY VB\\\")\\n if (self.posterior_mean == False):\\n self.weight = Vil.sample_posterior(self.mu_weight, Vil.softplus(self.rho_weight))\\n self.bias = Vil.sample_posterior(self.mu_bias, Vil.softplus(self.rho_bias))\\n# print (self.bias)\\n else:\\n self.weight.data = self.mu_weight.data\\n self.bias.data = self.mu_bias.data\",\n \"def fit(sample):\\r\\n if not hasattr(sample, \\\"stddev\\\"):\\r\\n sample = Sample(sample)\\r\\n m = sample.mean\\r\\n d = sqrt(12*sample.variance)/2\\r\\n return Uniform(m-d, m+d)\",\n \"def test_oss_sample_wt_fit():\\n\\n # Create the object\\n oss = OneSidedSelection(random_state=RND_SEED)\\n assert_raises(RuntimeError, oss.sample, X, Y)\",\n \"def sample(problem, seed=None):\\n if seed:\\n np.random.seed(seed)\\n contrast = generate_contrast(problem)\\n sample = np.array((contrast + 1.0) / 2, dtype=float)\\n problem = extend_bounds(problem)\\n\\n sample = scale_samples(sample, problem)\\n return sample\",\n \"def _get_sample(self):\\n mu = self._get_mean()\\n sample = self.random.normal(mu)\\n return sample\",\n \"def next_sample(self, z):\\n xp = self.A @ self.x\\n Pp = self.A @ self.P @ self.A.T + self.Q\\n\\n self.K = Pp @ self.H.T * inv(self.H @ Pp @ self.H.T + self.R)\\n\\n self.x = xp + self.K @ (z - self.H @ xp)\\n self.P = Pp - self.K @ self.H @ Pp\\n return self.x\",\n \"def bqm_structured(f):\\n @wraps(f)\\n def structured_sample(sampler, bqm, **kwargs):\\n adjacency = sampler.adjacency\\n\\n if not adjacency.keys() >= bqm.variables:\\n raise BinaryQuadraticModelStructureError(\\n f\\\"given bqm has at least one variable, {(list(bqm.variables) - adjacency.keys()).pop()!r}, \\\"\\n \\\"not supported by the structured solver\\\")\\n if any(u not in adjacency[v] for u, v, _ in bqm.iter_quadratic()):\\n u, v = next((u, v) for u, v, _ in bqm.iter_quadratic() if u not in adjacency[v])\\n raise BinaryQuadraticModelStructureError(\\n f\\\"given bqm contains an interaction, {(u, v)!r}, \\\"\\n \\\"not supported by the structured solver\\\")\\n return f(sampler, bqm, **kwargs)\\n return structured_sample\",\n \"def sample_uniform():\\n global samples_uniform, isample_uniform\\n\\n # sample of U(0, 1)\\n u = samples_uniform[isample_uniform]\\n\\n # moving to next index of samples global array\\n isample_uniform += 1\\n if isample_uniform >= len(samples_uniform):\\n # exhausted all samples -> re-drawing samples from U(0, 1)\\n samples_uniform = np.random.uniform(size=SIZE_SAMPLES_UNIFORM)\\n isample_uniform = 0\\n\\n return u\",\n \"def sample(self, x: Union[np.ndarray, float, list], ):\\n x = self._sample_test(x)\\n if x.ndim <= 1:\\n y = 0\\n for i in range(self.mixture_count):\\n if self.dimensions == 1:\\n y += self.weights[i] * self.one_d_normal(x, self.means[i], self.covs[i])\\n else:\\n y += self.weights[i] * self.multi_d_gauss(x, self.means[i], self.covs[i])\\n else:\\n x = np.squeeze(x, axis=1)\\n y = np.zeros((x.shape[0], ))\\n for i in range(self.mixture_count):\\n if self.dimensions == 1:\\n y += self.weights[i] * self.one_d_normal(x, self.means[i], self.covs[i])\\n else:\\n y += self.weights[i] * self.multi_d_gauss(x, self.means[i], self.covs[i])\\n return y\",\n \"def sample_py3(self):\\n print(self.weights_.shape)\\n try:\\n n_samples_comp = self.rng.multinomial(self.n_samples, self.weights_)\\n except ValueError:\\n self.weights_= np.reshape(self.weights_,len(self.weights_))\\n n_samples_comp = self.rng.multinomial(self.n_samples, self.weights_)\\n if self.covariance_type == 'full':\\n X = np.vstack([\\n self.rng.multivariate_normal(mean, covariance, int(sample))\\n for (mean, covariance, sample) in zip(\\n self.means_, self.covariances_, n_samples_comp)])\\n elif self.covariance_type == \\\"tied\\\":\\n X = np.vstack([\\n self.rng.multivariate_normal(mean, self.covariances_, int(sample))\\n for (mean, sample) in zip(\\n self.means_, n_samples_comp)])\\n else:\\n X = np.vstack([\\n mean + self.rng.randn(sample, n_features) * np.sqrt(covariance)\\n for (mean, covariance, sample) in zip(\\n self.means_, self.covariances_, n_samples_comp)])\\n\\n y = np.concatenate([j * np.ones(sample, dtype=int)\\n for j, sample in enumerate(n_samples_comp)])\\n\\n return (X, y)\",\n \"def quadratic_program_bnd(self, c, Q, lb, ub):\\n if self.solver == solver_SCIPY:\\n return scipy_quadratic_program_bnd(c, Q, lb, ub)\\n elif self.solver == solver_GUROBI:\\n return gurobi_quadratic_program_bnd(c, Q, lb, ub)\\n else:\\n raise ValueError('QP solver %s not available' % self.solver)\",\n \"def binary_sample(x):\\n return np.random.binomial(1, p=x)\",\n \"def sample(self, i):\\n\\t\\tif self.nsamp % 2 == 0:\\n\\t\\t\\ti0 = i-(self.nsamp/2-1)\\n\\t\\t\\ti1 = i+(self.nsamp/2)\\n\\t\\telse:\\n\\t\\t\\ti0 = i-((self.nsamp-1)/2.)\\n\\t\\t\\ti1 = i+((self.nsamp-1)/2.)\\n\\t\\treturn self.yval[i0:i1]\",\n \"def test_simpSample_trivial(self):\\n\\n ulim = [0,1]\\n ufun = lambda x: 1.0/np.diff(ulim)\\n\\n n = 10000\\n sample = statsFun.simpSample(ufun,n,0.5,0.5)\\n\\n self.assertEqual(len(sample),n)\\n self.assertTrue(np.all(sample == 0.5))\",\n \"def test_quadratic_features_shape(include_bias, interaction_only, n_output_features):\\n transformer = QuadraticFeatures(include_bias=include_bias, interaction_only=interaction_only,)\\n XQ = transformer.fit_transform(X_small)\\n assert XQ.shape == (X_small_n_rows, n_output_features)\",\n \"def samplepoint(x,u):\\n return point(x)\",\n \"def sample(self):\\n # return [v.sample() for v in self.variables]\\n return self.domain[gc.rand_state.choice(len(self.domain))]\",\n \"def test_quadratic_trinomial_default_init(self):\\n expected = Polynomial(1, 1, 1)\\n\\n qt = QuadraticTrinomial()\\n\\n self.assertEqual(expected, qt)\",\n \"def sample_mu(self, val) -> None:\\n\\n # get data\\n data = self.data.reshape((1, -1))\\n\\n # get values\\n gain = val.gain\\n states = val.states\\n mu_flor = val.mu_flor\\n mu_flor_mean = val.mu_flor_mean\\n mu_flor_shape = val.mu_flor_shape\\n mu_back = val.mu_back\\n mu_back_mean = val.mu_back_mean\\n mu_back_shape = val.mu_back_shape\\n num_data = val.num_data\\n num_rois = val.num_rois\\n num_states = val.num_states\\n\\n # initialze variables\\n num_vars = num_states + num_rois\\n idx = np.where(val.mu_flor_mean > 0)[0]\\n # shape\\n shape = np.zeros((num_vars, 1))\\n shape[:num_states, 0] = mu_flor_shape[:]\\n shape[num_states:, 0] = mu_back_shape\\n # scale\\n scale = np.zeros((num_vars, 1))\\n scale[idx, 0] = mu_flor_mean[idx] / mu_flor_shape[idx]\\n scale[num_states:, 0] = (mu_back_mean / mu_back_shape)[:]\\n\\n # initialize a mu vector containing the variables we wish to sample, mu_flor and mu_back\\n q = np.zeros((num_vars, 1))\\n q[:num_states, 0] = mu_flor[:]\\n q[num_states:, 0] = mu_back[:]\\n q_old = q.copy()\\n idy = q > 0 # keep track of which states are dark (we only sample bright states)\\n num_var = q.shape[0]\\n\\n # hmc dynamics variables\\n h = np.random.exponential() / 100\\n masses = (1 + np.random.pareto(1, size=q.shape))\\n masses_inv = np.zeros(shape=masses.shape) # negative mass is interpretted as an unchanging variable\\n masses_inv[masses > 0] = 1 / masses[masses > 0]\\n num_steps = np.random.poisson(25)\\n\\n # create populations array\\n pops = np.zeros((num_vars, num_rois * num_data))\\n \\\"\\\"\\\"\\n pops is an array such that each element i, j corresponds to the \\n multiplicitive factor in front of q[i] for data point j in the \\n likelihood. For example, if in ROI 1 at time level 17 there are two\\n fluorophores in the bright state, then we find the element, j,\\n corresponding to ROI 1 and time level 17, and we find the element,\\n i, corresponding to the bright state, and we set q[i,j]=2 (because\\n there are two bright fluorophores), then we would find the i\\n corresponding to the background brightness of ROI 1, and we would\\n set this q[i,j]=1 (the multiplicitive factor in front of the \\n background brightness is 1 when it is the corresponding ROI and 0\\n otherwise).\\n \\\"\\\"\\\"\\n for r in range(num_rois):\\n idx = np.arange(r*num_data, (r+1)*num_data)\\n pops[:num_states, idx] = states_to_pops(states[r, :, :], num_states)\\n pops[num_states + r, idx] = 1\\n\\n # the conditional probability for the mu vector\\n def probability(q_, p_):\\n if np.sum(q_ < 0) > 0:\\n prob = -np.inf\\n else:\\n prob = (\\n np.sum(stats.gamma.logpdf(data, a=q_.T @ pops, scale=gain)) # likelihood\\n + np.sum(stats.gamma.logpdf(q_[idy], a=shape[idy], scale=scale[idy])) # prior\\n + np.sum(stats.norm.logpdf(p_[idy], loc=0, scale=np.sqrt(masses[idy]))) # momentum\\n )\\n return prob\\n\\n # the gradient of the Hamiltonian with respect to the mu_vector\\n def dH_dq(q_):\\n if np.any(q_ < 0):\\n \\\"\\\"\\\"\\n In the event that q_new becomes negative, fast_digamma becomes\\n slow. Since q should never be negative anyway, there is no\\n need for further computation and we can skip this step knowing\\n that this value of q will be rejected anyway.\\n \\\"\\\"\\\"\\n return q_\\n q_new = np.zeros(q_.shape)\\n q_new[idy] = (\\n (shape[idy] - 1) / q_[idy] - 1 / scale[idy]\\n + (pops @ (np.log(data / gain) - fast_digamma(q_.T @ pops)).T)[idy]\\n )\\n return q_new\\n\\n # sample momentum\\n p = np.random.randn(num_var, 1) * np.sqrt(masses)\\n p_old = p.copy()\\n\\n # run the HMC\\n for i in range(num_steps):\\n p = p + .5 * h * dH_dq(q)\\n q = q + h * p * masses_inv\\n p = p + .5 * h * dH_dq(q)\\n\\n # find acceptance ratio\\n P_new = probability(q, p)\\n P_old = probability(q_old, p_old)\\n if (P_new - P_old) < np.log(np.random.rand()):\\n q = q_old\\n\\n # update the new mu values\\n val.mu_flor[:] = q[:num_states, 0]\\n val.mu_back[:] = q[num_states:, 0]\\n\\n return\",\n \"def to_bqm(self, model):\\n linear = ((v, float(model.get_py_value(bias)))\\n for v, bias in self.linear.items())\\n quadratic = ((u, v, float(model.get_py_value(bias)))\\n for (u, v), bias in self.quadratic.items())\\n offset = float(model.get_py_value(self.offset))\\n\\n return BQM(linear, quadratic, offset, dimod.SPIN)\",\n \"def sample(self):\\n\\n # pick sample type according to probability\\n samplers = [\\\"unif\\\", \\\"geo\\\", \\\"diverse\\\"]\\n sample_idx = np.random.multinomial(\\n 1, [self.unif_prob, self.geo_prob, self.diverse_prob])\\n idx = np.argmax(sample_idx)\\n sampler = samplers[idx]\\n\\n if sampler == \\\"unif\\\":\\n return self.unif_sampler()\\n if sampler == \\\"geo\\\":\\n return self.geo_sampler()\\n if sampler == \\\"diverse\\\":\\n return self.diverse_sampler()\",\n \"def sample(wave, factor):\\n ys = np.zeros(len(wave))\\n ys[::factor] = np.real(wave.ys[::factor])\\n return Wave(ys, framerate=wave.framerate)\",\n \"def _sample(self, points: Iterable[float]) -> np.array:\\n pass\",\n \"def sample(self, m):\\n i = torch.multinomial(self.weights, m, replacement=True)\\n return self.particles[i,:]\",\n \"def _SampleInputMatrix(nrows, bl, bu, distname='randomUniform'):\\n npars = len(bl)\\n x = np.zeros((nrows,npars))\\n bound = bu-bl\\n for i in range(nrows):\\n # x[i,:]= bl + DistSelector([0.0,1.0,npars],distname='randomUniform')*bound # only used in full Vhoeys-framework\\n x[i,:]= bl + np.random.rand(1,npars)*bound\\n return x\",\n \"def samplepoly(a,u):\\n \\n if not ispoly(a):\\n raise ValueError('non-poly passed to samplepoly')\\n\\n closed=False\\n\\n lines,lengths,length = __lineslength(a)\\n if len(a) > 2 and dist(a[0],a[-1]) < epsilon:\\n closed = True\\n\\n if closed:\\n u=u%1.0\\n \\n dst = u * length;\\n d = 0\\n if u < 1.0:\\n for i in range(len(lines)):\\n l=lengths[i]\\n if dst <= d+l:\\n uu = 1.0 - (d+l-dst)/l\\n return sampleline(lines[i],uu)\\n else:\\n d+=l\\n else:\\n uu = (dst-length+lengths[-1])/lengths[-1]\\n return sampleline(lines[-1],uu)\",\n \"def sample(self, sample_shape=torch.Size()):\\n with torch.no_grad():\\n return self.rsample(sample_shape=sample_shape)\",\n \"def sample(self, point, n_samples=1):\\n raise NotImplementedError(\\\"The sample method is not yet implemented.\\\")\",\n \"def rational_quadratic(input_dim, variance=1., lengthscale=1., power=1.):\\r\\n part = parts.rational_quadratic.RationalQuadratic(input_dim, variance, lengthscale, power)\\r\\n return kern(input_dim, [part])\",\n \"def get_uniform_subset(self, samples_per_label):\\n raise NotImplementedError\",\n \"def sample(self, s):\\n rng = np.random.default_rng()\\n return rng.choice(np.arange(self.n_actions), p=self.eval(s))\",\n \"def sample_b(self):\\n # don't sample b-factors with em\\n if not self.options.sample_bfactors or self.options.em:\\n return\\n\\n new_coor = []\\n new_bfactor = []\\n multiplication_factors = [1.0, 1.3, 1.5, 0.9, 0.5]\\n coor_b_pairs = zip(self._coor_set, self._bs)\\n for (coor, b), multi in itertools.product(coor_b_pairs, multiplication_factors):\\n new_coor.append(coor)\\n new_bfactor.append(b * multi)\\n self._coor_set = new_coor\\n self._bs = new_bfactor\",\n \"def sample_from_simplex(rng, dim):\\n alpha = [1] * dim\\n return rng.dirichlet(alpha)\",\n \"def get_sample(x, y):\\n return noise[x][y]\",\n \"def sample(self) -> np.ndarray:\\n q_target = np.empty(self.d)\\n for i in range(self.d):\\n q_target[i] = self.lim_lo[i] + np.random.rand() * (self.lim_up[i] - self.lim_lo[i])\\n return q_target\",\n \"def sample_spherical(self):\\n vec = np.random.randn(self.dims, self.arms)\\n vec /= np.linalg.norm(vec, axis=0)\\n self.contexts = vec.T\",\n \"def initial_samples(lb, ub, method, numSamp):\\r\\n if not len(lb) == len(ub):\\r\\n raise AssertionError('Lower and upper bounds have different #s of design variables in initial_samples function.')\\r\\n assert method == 'random' or method == 'nolh' or method == 'nolh-rp' or method == 'nolh-cdr' or method == 'lhc' or method == 'rand-wor', 'An invalid method was specified for the initial_samples.'\\r\\n assert (method == 'nolh' or method == 'nolh-rp' or method == 'nolh-cdr') and len(ub) >= 2 and len(ub) <= 29, 'The Phase space dimensions are outside of the bounds for initial_samples.'\\r\\n for case in Switch(method):\\r\\n if case('random'):\\r\\n s = np.zeros((numSamp, len(lb)))\\r\\n for i in range(0, numSamp, 1):\\r\\n s[i, :] = lb + (ub - lb) * rand(len(lb))\\r\\n\\r\\n break\\r\\n if case('rand-wor'):\\r\\n s = np.zeros((numSamp, len(lb)))\\r\\n for i in range(0, numSamp, 1):\\r\\n s[i, :] = choice(len(ub), size=len(ub), replace=False)\\r\\n\\r\\n break\\r\\n if case('nolh'):\\r\\n dim = len(ub)\\r\\n m, q, r = params(dim)\\r\\n conf = range(q)\\r\\n if r != 0:\\r\\n remove = range(dim - r, dim)\\r\\n nolh = NOLH(conf, remove)\\r\\n else:\\r\\n nolh = NOLH(conf)\\r\\n s = np.array([ list(lb + (ub - lb) * nolh[i, :]) for i in range(len(nolh[:, 0]))\\r\\n ])\\r\\n break\\r\\n if case('nolh-rp'):\\r\\n dim = len(ub)\\r\\n m, q, r = params(dim)\\r\\n conf = random.sample(range(q), q)\\r\\n if r != 0:\\r\\n remove = random.sample(range(q - 1), r)\\r\\n nolh = NOLH(conf, remove)\\r\\n else:\\r\\n nolh = NOLH(conf)\\r\\n s = np.array([ list(lb + (ub - lb) * nolh[i, :]) for i in range(len(nolh[:, 0]))\\r\\n ])\\r\\n break\\r\\n if case('nolh-cdr'):\\r\\n dim = len(ub)\\r\\n m, q, r = params(dim)\\r\\n conf, remove = get_cdr_permutations(len(ub))\\r\\n if remove != []:\\r\\n nolh = NOLH(conf, remove)\\r\\n else:\\r\\n nolh = NOLH(conf)\\r\\n s = np.array([ list(lb + (ub - lb) * nolh[i, :]) for i in range(len(nolh[:, 0]))\\r\\n ])\\r\\n break\\r\\n if case('lhc'):\\r\\n tmp = lhs(len(lb), samples=numSamp, criterion='center')\\r\\n s = np.array([ list(lb + (ub - lb) * tmp[i, :]) for i in range(len(tmp[:, 0]))\\r\\n ])\\r\\n break\\r\\n if case():\\r\\n print 'Somehow you evaded my assert statement - good job!',\\r\\n print ' However, you still need to use a valid method string.'\\r\\n\\r\\n return s\",\n \"def evalQuad(a,b,c,x):\\n return a * x**2 + b*x + c\",\n \"def sample(self, x):\\n x_minus_mu = x - self.mu\\n pwr = -(np.dot(np.dot (x_minus_mu.transpose(), self.cov_inv),\\n x_minus_mu) / 2.0)\\n return math.exp(pwr) #/ self.root_2pi_d_det\",\n \"def sample_random_architecture(self, dataset_api):\\n while True:\\n matrix = np.random.choice(\\n [0, 1], size=(NUM_VERTICES, NUM_VERTICES))\\n matrix = np.triu(matrix, 1)\\n ops = np.random.choice(OPS, size=NUM_VERTICES).tolist()\\n ops[0] = INPUT\\n ops[-1] = OUTPUT\\n spec = dataset_api['api'].ModelSpec(matrix=matrix, ops=ops)\\n if dataset_api['nb101_data'].is_valid(spec):\\n break\\n \\n self.set_spec({'matrix':matrix, 'ops':ops})\",\n \"def sample_survey(self, **kwargs):\",\n \"def sampling_algorithm(self, X, y):\\r\\n n_to_sample = self.det_n_to_sample(self.proportion)\\r\\n\\r\\n if n_to_sample == 0:\\r\\n return self.return_copies(X, y, \\\"Sampling is not needed\\\")\\r\\n\\r\\n X_min = X[y == self.min_label]\\r\\n X_maj = X[y == self.maj_label]\\r\\n\\r\\n # fitting nearest neighbors model to find closest majority points to\\r\\n # minority samples\\r\\n nn_params = {**self.nn_params}\\r\\n nn_params['metric_tensor'] = \\\\\\r\\n self.metric_tensor_from_nn_params(nn_params, X, y)\\r\\n\\r\\n density = self.calculate_density(X_min, X_maj, nn_params)\\r\\n\\r\\n # fitting nearest neighbors model to minority samples to run\\r\\n # SMOTE-like sampling\\r\\n n_neighbors = min([len(X_min), self.n_neighbors+1])\\r\\n nnmt = NearestNeighborsWithMetricTensor(n_neighbors=n_neighbors,\\r\\n n_jobs=self.n_jobs,\\r\\n **nn_params)\\r\\n nnmt.fit(X_min)\\r\\n ind = nnmt.kneighbors(X_min, return_distance=False)\\r\\n\\r\\n samples = self.sample_simplex(X=X_min,\\r\\n indices=ind,\\r\\n n_to_sample=n_to_sample,\\r\\n base_weights=density)\\r\\n\\r\\n # do the sampling\\r\\n #samples = []\\r\\n #while len(samples) < n_to_sample:\\r\\n # idx = self.random_state.choice(np.arange(len(density)), p=density)\\r\\n # random_neighbor_idx = self.random_state.choice(ind[idx][1:])\\r\\n # X_a = X_min[idx]\\r\\n # X_b = X_min[random_neighbor_idx]\\r\\n # samples.append(self.sample_between_points(X_a, X_b))\\r\\n\\r\\n return (np.vstack([X, samples]),\\r\\n np.hstack([y, np.repeat(self.min_label, len(samples))]))\",\n \"def sample(self, bqm, chain_strength=1.0, **parameters):\\n\\n # solve the problem on the child system\\n child = self.child\\n\\n # apply the embedding to the given problem to map it to the child sampler\\n __, target_edgelist, target_adjacency = child.structure\\n\\n # add self-loops to edgelist to handle singleton variables\\n source_edgelist = list(bqm.quadratic) + [(v, v) for v in bqm.linear]\\n\\n # get the embedding\\n embedding = minorminer.find_embedding(source_edgelist, target_edgelist)\\n\\n if bqm and not embedding:\\n raise ValueError(\\\"no embedding found\\\")\\n\\n bqm_embedded = dimod.embed_bqm(bqm, embedding, target_adjacency, chain_strength=chain_strength)\\n\\n response = child.sample(bqm_embedded, **parameters)\\n\\n return dimod.unembed_response(response, embedding, source_bqm=bqm)\",\n \"def test_gradient_exception_on_sample(self):\\n dev = qml.device(\\\"default.qubit\\\", wires=2, shots=1000)\\n\\n @qml.qnode(dev, diff_method=\\\"parameter-shift\\\")\\n def circuit(x):\\n qml.RX(x, wires=[0])\\n return qml.sample(qml.PauliZ(0)), qml.sample(qml.PauliX(1))\\n\\n with pytest.raises(\\n qml.QuantumFunctionError,\\n match=\\\"Circuits that include sampling can not be differentiated.\\\",\\n ):\\n grad_fn = autograd.jacobian(circuit)\\n grad_fn(1.0)\",\n \"def sample(self):\",\n \"def varietySample(V, x, count_max, R2, eps_bound):\\n \\n #x = np.array(V.gens);\\n N = len(x)\\n t = sp.symbols(\\\"t\\\") #Parameter of line\\n #count_max = 200\\n count = 0\\n #N = length(x)\\n P = np.empty([N,0])\\n while count < count_max:\\n # Corrupt the variety with bounded noise \\n epsilon = np.random.uniform(-eps_bound, eps_bound)\\n Ve = V + epsilon \\n \\n # Get a line u + v t in space \\n U = sp.Matrix(np.random.randn(2, N+1));\\n Ur = np.array(U.rref()[0].transpose().tolist(), dtype=float)\\n u = Ur[1:, 0]\\n v = Ur[1:, 1]\\n \\n L = u + v * t \\n \\n #substitute in the line and find real roots\\n VL = Ve.subs([i for i in zip(x, L)])\\n cVL = sp.Poly(VL).coeffs()\\n rVL = np.roots(cVL)\\n r_real = np.real(rVL[np.isreal(rVL)])\\n \\n \\n \\n #recover points of intersection and append to array\\n p = u[:, np.newaxis] + np.outer(v, r_real) \\n pnorm = np.sum(p**2, 0)\\n \\n pcand= p[:, pnorm <= R2]\\n\\n # if pcand.shape[1] <= 1:\\n # pcand0 = pcand\\n # else:\\n # #pcand0 = pcand[:, 0]\\n # pcand0 = pcand[..., 0][:, np.newaxis] #this is dumb\\n #\\n # P = np.concatenate([P, pcand0], 1)\\n P = np.concatenate([P, pcand], 1)\\n \\n #start new sampling iteration\\n count = count + np.size(pcand, 1)\\n \\n return P\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.5944321","0.58827317","0.57604975","0.56414646","0.5592896","0.5581259","0.55090886","0.54022413","0.5325893","0.5319684","0.53083277","0.53047055","0.5290728","0.52858907","0.5271392","0.5254466","0.52531403","0.52415967","0.52349377","0.5205364","0.5205364","0.5199425","0.51842093","0.5176185","0.51726454","0.51712173","0.515758","0.5152947","0.51358306","0.5133928","0.5124854","0.511913","0.50822085","0.5072199","0.5056643","0.5055369","0.50511503","0.5049002","0.5045257","0.5043229","0.5016383","0.50083894","0.4994151","0.4992991","0.49841487","0.4979531","0.49790454","0.4975377","0.4966808","0.49661237","0.49554235","0.49530268","0.4952751","0.4948786","0.49437016","0.49400643","0.49390027","0.49363205","0.49350917","0.4931782","0.49312016","0.49289736","0.49218094","0.49204746","0.49180242","0.49134803","0.49118084","0.4911674","0.49062628","0.49036816","0.49036437","0.489489","0.48924637","0.48882884","0.4884532","0.4872612","0.48646408","0.4856766","0.48506472","0.48493817","0.48356277","0.48352975","0.48338464","0.48309493","0.48258153","0.48244852","0.48223567","0.48106217","0.48074403","0.48050305","0.4804369","0.48039567","0.4799464","0.4796592","0.47937623","0.47927168","0.47886637","0.4778152","0.47752497","0.47740617","0.4768682"],"string":"[\n \"0.5944321\",\n \"0.58827317\",\n \"0.57604975\",\n \"0.56414646\",\n \"0.5592896\",\n \"0.5581259\",\n \"0.55090886\",\n \"0.54022413\",\n \"0.5325893\",\n \"0.5319684\",\n \"0.53083277\",\n \"0.53047055\",\n \"0.5290728\",\n \"0.52858907\",\n \"0.5271392\",\n \"0.5254466\",\n \"0.52531403\",\n \"0.52415967\",\n \"0.52349377\",\n \"0.5205364\",\n \"0.5205364\",\n \"0.5199425\",\n \"0.51842093\",\n \"0.5176185\",\n \"0.51726454\",\n \"0.51712173\",\n \"0.515758\",\n \"0.5152947\",\n \"0.51358306\",\n \"0.5133928\",\n \"0.5124854\",\n \"0.511913\",\n \"0.50822085\",\n \"0.5072199\",\n \"0.5056643\",\n \"0.5055369\",\n \"0.50511503\",\n \"0.5049002\",\n \"0.5045257\",\n \"0.5043229\",\n \"0.5016383\",\n \"0.50083894\",\n \"0.4994151\",\n \"0.4992991\",\n \"0.49841487\",\n \"0.4979531\",\n \"0.49790454\",\n \"0.4975377\",\n \"0.4966808\",\n \"0.49661237\",\n \"0.49554235\",\n \"0.49530268\",\n \"0.4952751\",\n \"0.4948786\",\n \"0.49437016\",\n \"0.49400643\",\n \"0.49390027\",\n \"0.49363205\",\n \"0.49350917\",\n \"0.4931782\",\n \"0.49312016\",\n \"0.49289736\",\n \"0.49218094\",\n \"0.49204746\",\n \"0.49180242\",\n \"0.49134803\",\n \"0.49118084\",\n \"0.4911674\",\n \"0.49062628\",\n \"0.49036816\",\n \"0.49036437\",\n \"0.489489\",\n \"0.48924637\",\n \"0.48882884\",\n \"0.4884532\",\n \"0.4872612\",\n \"0.48646408\",\n \"0.4856766\",\n \"0.48506472\",\n \"0.48493817\",\n \"0.48356277\",\n \"0.48352975\",\n \"0.48338464\",\n \"0.48309493\",\n \"0.48258153\",\n \"0.48244852\",\n \"0.48223567\",\n \"0.48106217\",\n \"0.48074403\",\n \"0.48050305\",\n \"0.4804369\",\n \"0.48039567\",\n \"0.4799464\",\n \"0.4796592\",\n \"0.47937623\",\n \"0.47927168\",\n \"0.47886637\",\n \"0.4778152\",\n \"0.47752497\",\n \"0.47740617\",\n \"0.4768682\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":24997,"cells":{"query":{"kind":"string","value":"determine from an adjacency the list of edges if (u, v) in edges, then (v, u) should not be"},"document":{"kind":"string","value":"def _adjacency_to_edges(adjacency):\n edges = set()\n for u in adjacency:\n for v in adjacency[u]:\n try:\n edge = (u, v) if u <= v else (v, u)\n except TypeError:\n # Py3 does not allow sorting of unlike types\n if (v, u) in edges:\n continue\n edge = (u, v)\n\n edges.add(edge)\n return edges"},"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 isUndirected(G):\n for v in G:\n if v in G[v]:\n return False\n for w in G[v]:\n if v not in G[w]:\n return False\n return True","def de2ue(edges):\n return set(de for de in edges if tuple(reversed(de)) in edges)","def test_adjacent_none(graph_with_edges):\n assert graph_with_edges.adjacent('B', 'A') is False","def check_undirected(graph):\n for node in graph:\n for neighbor in graph[node]:\n if node not in graph[neighbor]:\n return False\n return True","def get_inconsistent_edges(graph: BELGraph) -> Iterable[Tuple[BaseEntity]]:\n for u, v in graph.edges():\n if not pair_is_consistent(graph, u, v):\n yield u, v","def get_inconsistent_edges(graph):\n for u, v in _iter_pairs(graph):\n if not pair_is_consistent(graph, u, v):\n yield u, v","def contract_edge(graph, u, v):\n graph[v] = (graph[v] | graph[u]) - {u, v}\n del graph[u]\n for w in graph:\n if u in graph[w]:\n graph[w] = (graph[w] | {v}) - {u, w}","def test_edges(self):\n\n edge_list = self.g.edges()\n self.assertEqual(42, len(edge_list))\n\n # p1 p3 and p3 p1 are valid edges\n t1 = ('p1', 'p3')\n self.assertTrue(t1 in edge_list)\n\n t2 = ('p3', 'p1')\n self.assertTrue(t2 in edge_list)\n\n made_up = ('z1', 'q123')\n self.assertFalse(made_up in edge_list)\n\n return None","def make_undir_graph(V,E):\n\tUD = []\n\tfor (u,v) in E:\n\t\tif (v,u) not in E:\n\t\t\tUD.append((u,v))\n\t\t\tUD.append((v,u))\n\treturn UD","def is_edge(graph, u, v):\n return graph.matrix[u][v]","def edges(adj_mat, vertices):\n return [(i,j) for i,j in\n vertices if (i < j and adj_mat[i][j] == 1)]","def is_bipartite(adj_list):\n A, B = -123, +123\n colors = {}\n v = next(iter(adj_list))\n stack = [(A, v)]\n while stack:\n color, v = stack.pop()\n if v in colors:\n continue\n colors[v] = color\n for w in adj_list[v]:\n if w not in colors:\n stack += [(-color, w)]\n elif colors[w] == color:\n return False\n assert colors.keys() == adj_list.keys(), \"must be connected\"\n return True","def remove_inconsistent_edges(graph: BELGraph) -> None:\n for u, v in get_inconsistent_edges(graph):\n edges = [(u, v, k) for k in graph[u][v]]\n graph.remove_edges_from(edges)","def no_non_adjacent_vertices(self):\n clauses = []\n for v in range(0,self.graph.num_vertices):\n non_neighbours = sorted(list(set(range(0,self.graph.num_vertices))\n - set([v])\n - set(self.graph.edges[v])))\n for nv in non_neighbours:\n for position in range(0,self.graph.num_vertices-1):\n clause = [ ClauseVariable(True,v,position),\n ClauseVariable(True,nv,position+1)]\n clauses.append(clause)\n return clauses","def remove_edges(g, edgelist):\n for edge in edgelist:\n (u, v) = tuple(edge)\n g[u].remove(v)\n g[v].remove(u)","def _edge(u, v):\n return (u, v) if u < v else (v, u)","def adjacent(self):\n result = set([v for e in self.edges for v in [e.v1, e.v2]])\n result.remove(self)\n return result","def pair_has_contradiction(graph, u, v):\n relations = get_all_relations(graph, u, v)\n return relation_set_has_contradictions(relations)","def edgeAdjacency( gen ):\n if gen == 0:\n return []\n elif gen == 1:\n return [(0,5), (1,8), (2,11)]\n else:\n raise ValueError, \"Hasn't been programmed yet!\"","def test_graph_lists_adds_and_lists_edges(graph_no_edges):\n graph_no_edges.add_edge(82, 34, 4)\n graph_no_edges.add_edge(99, 'AA', 6)\n assert (82, 34, 4) in graph_no_edges.edges()\n assert (99, 'AA', 6) in graph_no_edges.edges()","def shareNoEdges(segment,neighbours,segmentsMeta):\n return np.fromiter(map(lambda x : haveNoSameEdges(segment,x,segmentsMeta),neighbours),np.bool)","def is_nonprojective_edge(g,h,d):\n rang = get_range(g,h,d)\n roots = set()\n for i in rang[1:-1]:\n roots.add(get_root(g,rang[1:-1],i)) \n for i in roots:\n if not is_dominated(g,i,h):\n return True\n return False","def mst(v, e):\n vold = set(v)\n vnew = set([v[0]])\n result = set()\n edges = sorted(e)\n \n while vnew != vold:\n for uv in edges:\n old = (uv.v1 in vnew) + (uv.v2 in vnew)\n if old == 1:\n vnew.add(uv.v1)\n vnew.add(uv.v2)\n result.add(uv)\n #edges.remove(uv)\n break\n \n return result","def eligible_edges(self):\n if len(self.edges) == 4:\n return [self.edges[0], self.edges[2]]\n return []","def adjacent(self, u, v):\n return u in self.e[v]","def graph_has_self_loops(edges):\n\n for a, b in edges:\n if a == b:\n return True\n\n return False","def test_adjacent_unpresent(graph_with_edges):\n with pytest.raises(ValueError):\n graph_with_edges.adjacent('Captain Picard', 'Star Wars')","def F(graph):\n return [p for p in graph if set(graph.neighbors(p)) in triads(p)]","def run_removing_edges(self):\n indices = np.where(self.X==1)\n idx=[]\n for i in range(len(indices[0])):\n idx.append((indices[0][i],indices[1][i]))\n idx = np.array(idx)\n return self.node_equivalent(idx)","def adj_to(self, v):\n\n neighbours = set()\n\n for (x, y) in self._edges:\n if x == v: neighbours.add(y)\n if y == v: neighbours.add(x)\n\n return neighbours","def edges_without_adjacencies(self):\n edges = dict(self.eligible_edges_with_indexes)\n for adj in self.adjacencies.values():\n for edge_info in adj:\n if edge_info.self_edge_index in edges:\n edges[edge_info.self_edge_index] = None\n return list(filter(lambda x: x is not None, edges.values()))","def opposite_vertex(t, tri, edge):\n tn = neighbour(t, tri, edge)\n if tn is None:\n return None\n\n for i in range(3):\n if not has_vertex(t, tri, t[tn][i]):\n return t[tn][i]\n\n return None","def check_edge_list(src_nodes, dst_nodes, edge_weights):\n\n if len(src_nodes) != len(dst_nodes):\n raise EdgeListError(\"src_nodes and dst_nodes must be of same length.\")\n\n if edge_weights is None:\n return\n\n if len(edge_weights) != len(src_nodes):\n raise EdgeListError(\"src_nodes and edge_weights must be of same length.\")","def is_vert(e) :\n f = e[0][0]\n for t in e :\n if f != t[0] :\n return False\n return True","def neighbours(self):\n seen = set()\n return [l.other(self) for l in self.dovetails \\\n if id(l) not in seen and not seen.add(id(l))]","def contains_edge(self, u: str, v: str) -> bool:\n if v in self.adj_list[u]:\n return True\n else:\n return False","def find_boundary(edges):\n\n inputs = set([x[0] for x in edges])\n outputs = set([x[1] for x in edges])\n for e in edges:\n inputs.discard(e[1])\n outputs.discard(e[0])\n return inputs, outputs","def is_edge(self, v, w):\n return self.op_norm(v[0], w[0]) == (v[1] + w[1]) and (self.variant.is_bipartite() or v != w)","def DFSU(graph, v, a):\n a[v]= True # mark the current node as visited\n\n for i in graph[v]: # recursively check for all vertices adjacent.\n if a[i]==False:\n self.DFS(i,a)","def is_adjacent(self, startVertex: np.int_ , endVertex: np.int_):\n return self.__mat[startVertex][endVertex]>0","def clean_edges(self):\n for from_node in self.all_nodes():\n for to_node in self.all_nodes():\n if from_node == to_node:\n continue\n dup = list(filter(lambda x: x.from_node == from_node and x.to_node == to_node, self.edges))\n if len(dup) > 1:\n for d in dup[1:]:\n self.edges.remove(d)","def is_adjacent(v1, v2):\n return (v2 in _board_graph[v1])","def make_adj_list(V,E):\n\tG = {}\n\t#pa = {}\n\tif V is None or E is None:\n\t\treturn\n\tfor u in V:\n\t\tG[u] = []\n\t\t#pa[u] = []\n\t\tfor (w,v) in E:\n\t\t\tif w == u:\n\t\t\t\tG[u].append(v)\n\t\t#pa[v].append(u)\n\treturn G","def get_consistent_edges(graph):\n for u, v in _iter_pairs(graph):\n if pair_is_consistent(graph, u, v):\n yield u, v","def is_directed(G):\n return G.is_directed()","def edges(self) -> Set[Tuple[int, int]] : \n edges : Set[Tuple[int, int]] = set()\n for node_id in self.nodes: # iterator over id's\n for adj_node in self.nodes[node_id]:\n edge = (node_id, adj_node)\n if self.directed:\n edges.add(edge)\n else:\n if edge[::-1] not in edges: # if reverse edge not in edges...\n edges.add(edge)\n return edges","def __filterEdges(self):","def _get_non_matched_edges(self):\n return list(itertools.product(self.coords.values(), self.DIRECTIONS))","def is_legal(vtx, color):\n for neighbor in vtx[\"adjacent\"]:\n if VERTICES[neighbor][\"color\"] is color:\n return False\n return True","def haveNoSameEdges(seg1,seg2,segmentsMeta):\n seg1Edges = segmentsMeta['edges'][seg1]\n seg2Edges = segmentsMeta['edges'][seg2]\n return not any(a==b for a in seg1Edges for b in seg2Edges)","def __has_multiple_edges(self):\n return \\\n len(\n list(\n [\n tuple((edge.get_first_incident_node().get_name(), edge.get_second_incident_node().get_name()))\n for edge in self.get_edges()\n ] # the length of the list which allows duplicates...\n )\n ) != \\\n len(\n set(\n {\n tuple((edge.get_first_incident_node().get_name(), edge.get_second_incident_node().get_name()))\n for edge in self.get_edges()\n } # ...should equal the length of the set that does not allow duplicates\n )\n ) # return True if the two data structures are equal in size and False otherwise","def _mout_edges(nodes):\n n = nodes.shape[0]\n edges = []\n for i in range(0, n - 1):\n for j in range(i, n):\n if abs(nodes[i, 0] - nodes[j, 0]) > 1:\n break\n elif abs(nodes[i, 0] - nodes[j, 0]) == 1 and \\\n abs(nodes[i, 1] - nodes[j, 1]) == 0:\n edges.append([i, j])\n elif abs(nodes[i, 1] - nodes[j, 1]) == 1:\n edges.append([i, j])\n return edges","def edgesWithVertices(self):\n\n return {e for e in self.edges if not (e.vert1 is None or e.vert2 is None)}","def is_clique(G,S): #set of vertices where every pair in the set forms an edge \n for v in S:\n if list(set(S)&set(neighbors(G,v))) != []: #[] <-- empty list\n return False\n \n return True","def not_reachable(self,graph):\n reachable_in = nx.descendants(graph, 0)\n reachable_out = nx.ancestors(graph, self.nodes - 1)\n # add the last node back in\n reachable_out.add(self.nodes - 1)\n\n set_of_nodes = set(range(1, self.nodes))\n\n not_reachable_in = set_of_nodes - reachable_in\n not_reachable_out = set_of_nodes - reachable_out\n return not_reachable_in ,not_reachable_out","def is_bipartite(graph: list[list[int]]) -> bool:\n n = len(graph)\n color = [0] * n\n\n def dfs(c, node):\n color[node] = c\n for nxt in graph[node]:\n if color[nxt] == c:\n return False\n if color[nxt] == 0 and not dfs(-c, nxt):\n return False\n return True\n\n for i in range(n):\n if color[i] == 0 and not dfs(1, i):\n return False\n return True","def generate_edges(self):\n edges = []\n for vertex in self.graph_dict:\n for neighbour in self.graph_dict[vertex]:\n if (neighbour, vertex) not in edges:\n edges.append((vertex, neighbour))\n \n for pair in edges:\n for otherpair in edges:\n if pair[1] == otherpair[0]:\n edges.append((pair[0],otherpair[1]))\n return edges","def edge_filter(edge):\n # <= because self loops\n idx, jdx = edge\n return ((not graph.has_edge(idx, jdx) or is_multigraph) and\n (idx <= jdx or is_directed) and\n (idx != jdx or self_loops))","def test_bidirectional_edges(self):\n G = DiGraph()\n G.add_edges_from([(0, 1), (1, 2), (2, 3), (3, 0), (1, 3), (0, 2)])\n G.add_edge(1, 0)\n assert_false(is_tournament(G))","def graph_has_duplicates(edges, is_bidirectional=True):\n\n curr_edges = set()\n\n for edge in edges:\n if is_bidirectional and edge[0] > edge[1]:\n edge = (edge[1], edge[0])\n\n if edge in curr_edges:\n return True\n else:\n curr_edges.add(edge)\n\n return False","def remove_edge(self, u, v):\n \n try:\n del self.prefix[v][u]\n del self.suffix[u][v]\n except:\n print(\"ERROR: The edges not in graph\")","def containsEdge(self, v1, v2):\n for e in self.edges:\n if (e.pvt, e.nvt) in [(v1, v2), (v2, v1)]:\n return True\n return False","def constraint_not_adjacent(m, n) :\n return not constraint_adjacent(m,n)","def containsEdge(self, e):\n return any(e.nvt in [self.vertices[i-2], self.vertices[i]] and self.vertices[i-1] == e.pvt for i in range(len(self.vertices)))","def add_all_edges(self):\n for n1 in self.vertices():\n for n2 in self.vertices():\n if n1 != n2:\n self.add_edge((n1, n2))","def neighbours_L(self):\n seen = set()\n return [l.other(self) for l in self.dovetails_L \\\n if id(l) not in seen and not seen.add(id(l))]","def images_adjacent(i, j, img_adjacency):\n if img_adjacency[i][j] == 1 or img_adjacency[j][i] == 1:\n return True\n else:\n return False","def adjacencyLists():\r\n anyNeighbor = lambda u: any(self.neighbors(u))\r\n verticesWithNeighbors = filter(anyNeighbor, sorted(self.vertices()))\r\n return map(edgesFromVertex, verticesWithNeighbors)","def adjacencyLists():\r\n anyNeighbor = lambda u: any(self.neighbors(u))\r\n verticesWithNeighbors = filter(anyNeighbor, sorted(self.vertices()))\r\n return map(edgesFromVertex, verticesWithNeighbors)","def adjacentTo()\r\n\r\n def fitsWith(self, other):\r\n # TODO: Can use list comprehesion??\r\n for i, selfEdge in enumerate(self.getEdges()):\r\n for j, otherEdge in other.getEdges():\r\n if selfEdge.fitsWith(otherEdge):\r\n return i, j\r\n return False # made it here, so no edge fits together\r","def find_isolated_vertices(self):\n graph = self.__graph_dict\n isolated = []\n for vertex in graph:\n # print(isolated,vertex)\n if not graph[vertex]:\n isolated += [vertex]\n return isolated","def test_not_strongly_connected(self):\n G = DiGraph([(0, 1), (0, 2), (1, 2)])\n assert_false(is_strongly_connected(G))","def remove_edge(self, u, v):\r\n elements = self.d.keys()\r\n #check for nodes in graph\r\n if u not in elements or v not in elements:\r\n raise KeyError(str(u) + \" and \" + str(v) + \" must be in graph\")\r\n #remove other node from each value set\r\n self.d[u].remove(v)\r\n self.d[v].remove(u)","def is_graph(g):\n # g must be list\n if type(g) is not list:\n return False\n n = len(g)\n\n # Neighbors must all be vertices, and given in order, no dups\n for adjl in g:\n # Each adj list must be of type list\n if type(adjl) is not list:\n return False\n # Neighbors must be ints in [0,n)\n for v in adjl:\n if type(v) is not int:\n return False\n if v < 0 or v >= n:\n return False\n # Check adj list sorted & no duplicates\n # (Do *after* above so we know nbrs can be ordered & hashed)\n if adjl != sorted(list(set(adjl))):\n return False\n\n # Edges must be symmetric, and no loops\n for v1 in range(n):\n if v1 in g[v1]:\n return False\n for v2 in range(v1):\n e12 = v2 in g[v1]\n e21 = v1 in g[v2]\n if e12 != e21:\n return False\n return True","def pair_is_consistent(graph, u, v):\n relations = get_all_relations(graph, u, v)\n\n if 1 != len(relations):\n return False\n\n return list(relations)[0]","def edge_not_in_component(edge, component):\n x_start = edge[0]\n x_stop = edge[0] + edge[2]\n y_start = edge[1]\n y_stop = edge[1] + edge[3]\n if x_start >= component[1].start and x_stop <= component[1].stop and y_start >= component[0].start and y_stop <= \\\n component[0].stop:\n return False\n else:\n return True","def validate_edges(attack_surface_graph, admissible_path, starting_points):\n for i in range(len(admissible_path)-1):\n for edge in attack_surface_graph.edges(data=True):\n if edge[0] == admissible_path[i] and edge[1] == admissible_path[i+1]:\n descriptors = edge[2]\n if find_violation(descriptors) == [] and edge[0] not in starting_points:\n return False\n return True","def merge_edge(graph, u, v):\n # Attach v's adjacency list to u's adjacency list\n graph[u].extend(graph[v])\n\n # Go through all of the vertices in v's adjacency list and replace all instances of v in those adjacency lists with\n # u\n for i in graph[v]:\n adjacency_list = graph[i]\n\n for j in range(0, len(adjacency_list)):\n if adjacency_list[j] == v:\n adjacency_list[j] = u","def test_case21(self):\n\n result= self.graph1.isEdge(\"supervisor2\",\"student1\")\n\n self.assertFalse(result)","def isAdjacent(self, vertex1, vertex2):\n return vertex2 in self.adjList[vertex1]","def test_case19(self):\n\n result = self.graph1.isEdge(\"supervisor5\",\"student1\")\n self.assertFalse(result)","def remove_edge(self, v1, v2):\n verts = self.vertices\n if v1 in verts and v2 in verts[v1].adj:\n del verts[v1].adj[v2]\n if v2 in verts and v1 in verts[v2].adj:\n del verts[v2].adj[v1]","def CompareEdges(self,edge,dict):\n \"\"\"Does not assume symmetric edge lists, though you should probably have them\"\"\"\n # Edge is a tuple with two nodes\n # Dict is a dictionary of node-keys and tuple (node,float) values\n if edge[0] in dict.keys():\n if edge[1] in [x[0] for x in dict[edge[0]]]:\n return True\n else:\n return False\n else:\n if edge[1] in dict.keys():\n if edge[0] in [x[0] for x in dict[edge[1]]]:\n return True\n else:\n return False\n else:\n return False","def hypergraph_common_edges(u, v, hypergraph):\n total = 0\n for e in hypergraph.edges():\n if u in e.elements and v in e.elements:\n total += 1\n return total","def test_case20(self):\n\n result = self.graph1.isEdge(\"supervisor1\",\"student5\")\n self.assertFalse(result)","def test_adjacent_nodes(graph_with_edges):\n assert graph_with_edges.adjacent('A', 'B')","def eligible(self, u, v):\n return self.eligible_node(u) and self.eligible_node(v) and u != v","def edge_filtering(S, edge_list, co=0, type_='out'):\n edges = edge_list[:]\n for a in S:\n S_sort = sorted(S[a], key=S[a].get, reverse=True)\n for i in range(len(S[a])):\n b = S_sort[i]\n if (S[a][b] >= co) | (i == 0):\n if type_ != 'out':\n if (b,a) not in edges: edges.append((b,a))\n else:\n if (a,b) not in edges: edges.append((a,b))\n else: break\n return edges","def bipartite(adj):\n\n n = len(adj)\n side = [None] * n # None = undiscovered, 0 means a_side, 1 means b_side.\n queue = deque()\n\n # Try each possible starting point, to find all connected components.\n for s in range(n):\n # If s was previously discovered, then skip past it. (Otherwise we'd\n # waste time re-exploring the whole connected component containing s.)\n if side[s] != None: continue\n # Start new BFS at s. Doesn't matter which side we put it on, so we\n # arbitrarily pick a_side.\n side[s] = 0\n queue.append(s)\n while queue:\n u = queue.popleft()\n for v in adj[u]:\n if side[v] == None:\n # The next line simultaneously marks v as discovered and\n # puts it on the opposite side as u (since 1 - side[u]\n # flips 0 to 1 and 1 to 0).\n side[v] = 1 - side[u]\n queue.append(v)\n elif side[v] == side[u]:\n # If u and v are already in the same layer, then we know\n # the graph contains an odd cycle so is not bipartite.\n side[v] = 3\n side[u] = 3\n\n # If we wanted a list that says for each node which side it's on, we could\n # just return the side list. But we want the list of nodes on each side,\n # and there's a slick way to get these using list comprehensions.\n a_side = [u for u in range(n) if side[u] == 0]\n b_side = [u for u in range(n) if side[u] == 1]\n c_side = [u for u in range(n) if side[u] == 3]\n\n output = []\n output.append(a_side)\n output.append(b_side)\n return len(output)","def remove_adjacent(nums):\n unique_adjacents = []\n last_number = 0\n for num in nums:\n if num != last_number:\n unique_adjacents.append(num)\n last_number = num\n\n return unique_adjacents","def get_bridges(edges_list):\n\n # print(\"all edges:\", edges_list)\n\n # make a temporary graph\n temp_G = nx.Graph()\n\n # add all current edges to the graph\n for edge in edges_list:\n edge_node_1, edge_node_2 = edge\n temp_G.add_edge(edge_node_1, edge_node_2)\n\n # get all_bridges in temp graph\n bridges_all = list(nx.bridges(temp_G))\n\n # get set of edges with two traversals left (only want one of each, so use set)\n mult_trav_remaining = set([])\n\n for edge in edges_list:\n\n num_trav_remaining = edges_list.count(edge)\n\n if num_trav_remaining > 1:\n\n mult_trav_remaining.add(edge)\n\n mult_trav_remaining = list(mult_trav_remaining)\n\n # remove mult traversal edges from bridges list\n\n # print(\"bridges_ all:\", bridges_all)\n # print(\"\\nmult_trav_remaining:\", mult_trav_remaining)\n\n # make a new bridges list that contains only edges that don't have mult traversals left\n\n bridges_reduced = []\n\n for edge in bridges_all:\n # print(\"\\n\\nedge:\", edge)\n # print()\n if edge in mult_trav_remaining:\n continue\n # print()\n # print(f\"bridge {edge} is in {mult_trav_remaining}\")\n elif edge[::-1] in mult_trav_remaining:\n continue\n # print()\n # print(f\"bridge {edge} REVERSED is in {mult_trav_remaining}\")\n else:\n # print(f\"bridge {edge} is NOT in {mult_trav_remaining}\")\n\n bridges_reduced.append(edge)\n\n # return a list of true bridges\n return bridges_reduced","def test_missing_edges(self):\n G = DiGraph()\n G.add_edges_from([(0, 1), (1, 2), (2, 3), (3, 0), (1, 3)])\n assert_false(is_tournament(G))","def edges(self):\n return self.dovetails + self.containments + self.internals","def adjacency_opposite_calculator(graph):\n adjacency_matrix = sparse.csr_matrix(nx.adjacency_matrix(graph), dtype=np.float32).todense()\n adjacency_matrix_opposite = np.ones(adjacency_matrix.shape) - adjacency_matrix\n return adjacency_matrix_opposite","def generate_false_edges(true_edges, num_false_edges=5):\n nodes = list(set(chain.from_iterable(true_edges)))\n true_edges = set(true_edges)\n false_edges = set()\n \n while len(false_edges) < num_false_edges:\n # randomly sample two different nodes and check whether the pair exisit or not\n head, tail = np.random.choice(nodes, 2)\n if head != tail and ((head, tail) not in true_edges and (tail, head) not in true_edges) and ((head, tail) not in false_edges and (tail, head) not in false_edges):\n false_edges.add((head, tail)) \n false_edges = sorted(false_edges)\n \n return false_edges","def edge_assignment_from_graph(edge_index: nb.int64[:,:],\n true_edge_index: nb.int64[:,:]) -> nb.int64[:]:\n # Set the edge as true if it connects two nodes that are connected by a true dependency\n edge_assn = np.empty(len(edge_index), dtype=np.int64)\n for k, e in enumerate(edge_index):\n edge_assn[k] = (e == true_edge_index).any()\n\n return edge_assn","def is_connected_same_node(graph, node_u, node_v):\n for out_neighbor_u in graph.get_deductive_out_neighbors(node_u):\n for out_neighbor_v in graph.get_deductive_out_neighbors(node_v):\n if out_neighbor_u == out_neighbor_v:\n return True\n return False","def eligible_edges_with_indexes(self):\n return list(map(lambda e: (self.edges.index(e), e), self.eligible_edges))","def get_contradictory_pairs(graph):\n for u, v in _iter_pairs(graph):\n if pair_has_contradiction(graph, u, v):\n yield u, v","def is_independent(self, A):\n if self.variant.is_bipartite():\n raise ValueError()\n return not any(self.is_edge(v, w) for (v, w) in combinations(A, 2))"],"string":"[\n \"def isUndirected(G):\\n for v in G:\\n if v in G[v]:\\n return False\\n for w in G[v]:\\n if v not in G[w]:\\n return False\\n return True\",\n \"def de2ue(edges):\\n return set(de for de in edges if tuple(reversed(de)) in edges)\",\n \"def test_adjacent_none(graph_with_edges):\\n assert graph_with_edges.adjacent('B', 'A') is False\",\n \"def check_undirected(graph):\\n for node in graph:\\n for neighbor in graph[node]:\\n if node not in graph[neighbor]:\\n return False\\n return True\",\n \"def get_inconsistent_edges(graph: BELGraph) -> Iterable[Tuple[BaseEntity]]:\\n for u, v in graph.edges():\\n if not pair_is_consistent(graph, u, v):\\n yield u, v\",\n \"def get_inconsistent_edges(graph):\\n for u, v in _iter_pairs(graph):\\n if not pair_is_consistent(graph, u, v):\\n yield u, v\",\n \"def contract_edge(graph, u, v):\\n graph[v] = (graph[v] | graph[u]) - {u, v}\\n del graph[u]\\n for w in graph:\\n if u in graph[w]:\\n graph[w] = (graph[w] | {v}) - {u, w}\",\n \"def test_edges(self):\\n\\n edge_list = self.g.edges()\\n self.assertEqual(42, len(edge_list))\\n\\n # p1 p3 and p3 p1 are valid edges\\n t1 = ('p1', 'p3')\\n self.assertTrue(t1 in edge_list)\\n\\n t2 = ('p3', 'p1')\\n self.assertTrue(t2 in edge_list)\\n\\n made_up = ('z1', 'q123')\\n self.assertFalse(made_up in edge_list)\\n\\n return None\",\n \"def make_undir_graph(V,E):\\n\\tUD = []\\n\\tfor (u,v) in E:\\n\\t\\tif (v,u) not in E:\\n\\t\\t\\tUD.append((u,v))\\n\\t\\t\\tUD.append((v,u))\\n\\treturn UD\",\n \"def is_edge(graph, u, v):\\n return graph.matrix[u][v]\",\n \"def edges(adj_mat, vertices):\\n return [(i,j) for i,j in\\n vertices if (i < j and adj_mat[i][j] == 1)]\",\n \"def is_bipartite(adj_list):\\n A, B = -123, +123\\n colors = {}\\n v = next(iter(adj_list))\\n stack = [(A, v)]\\n while stack:\\n color, v = stack.pop()\\n if v in colors:\\n continue\\n colors[v] = color\\n for w in adj_list[v]:\\n if w not in colors:\\n stack += [(-color, w)]\\n elif colors[w] == color:\\n return False\\n assert colors.keys() == adj_list.keys(), \\\"must be connected\\\"\\n return True\",\n \"def remove_inconsistent_edges(graph: BELGraph) -> None:\\n for u, v in get_inconsistent_edges(graph):\\n edges = [(u, v, k) for k in graph[u][v]]\\n graph.remove_edges_from(edges)\",\n \"def no_non_adjacent_vertices(self):\\n clauses = []\\n for v in range(0,self.graph.num_vertices):\\n non_neighbours = sorted(list(set(range(0,self.graph.num_vertices))\\n - set([v])\\n - set(self.graph.edges[v])))\\n for nv in non_neighbours:\\n for position in range(0,self.graph.num_vertices-1):\\n clause = [ ClauseVariable(True,v,position),\\n ClauseVariable(True,nv,position+1)]\\n clauses.append(clause)\\n return clauses\",\n \"def remove_edges(g, edgelist):\\n for edge in edgelist:\\n (u, v) = tuple(edge)\\n g[u].remove(v)\\n g[v].remove(u)\",\n \"def _edge(u, v):\\n return (u, v) if u < v else (v, u)\",\n \"def adjacent(self):\\n result = set([v for e in self.edges for v in [e.v1, e.v2]])\\n result.remove(self)\\n return result\",\n \"def pair_has_contradiction(graph, u, v):\\n relations = get_all_relations(graph, u, v)\\n return relation_set_has_contradictions(relations)\",\n \"def edgeAdjacency( gen ):\\n if gen == 0:\\n return []\\n elif gen == 1:\\n return [(0,5), (1,8), (2,11)]\\n else:\\n raise ValueError, \\\"Hasn't been programmed yet!\\\"\",\n \"def test_graph_lists_adds_and_lists_edges(graph_no_edges):\\n graph_no_edges.add_edge(82, 34, 4)\\n graph_no_edges.add_edge(99, 'AA', 6)\\n assert (82, 34, 4) in graph_no_edges.edges()\\n assert (99, 'AA', 6) in graph_no_edges.edges()\",\n \"def shareNoEdges(segment,neighbours,segmentsMeta):\\n return np.fromiter(map(lambda x : haveNoSameEdges(segment,x,segmentsMeta),neighbours),np.bool)\",\n \"def is_nonprojective_edge(g,h,d):\\n rang = get_range(g,h,d)\\n roots = set()\\n for i in rang[1:-1]:\\n roots.add(get_root(g,rang[1:-1],i)) \\n for i in roots:\\n if not is_dominated(g,i,h):\\n return True\\n return False\",\n \"def mst(v, e):\\n vold = set(v)\\n vnew = set([v[0]])\\n result = set()\\n edges = sorted(e)\\n \\n while vnew != vold:\\n for uv in edges:\\n old = (uv.v1 in vnew) + (uv.v2 in vnew)\\n if old == 1:\\n vnew.add(uv.v1)\\n vnew.add(uv.v2)\\n result.add(uv)\\n #edges.remove(uv)\\n break\\n \\n return result\",\n \"def eligible_edges(self):\\n if len(self.edges) == 4:\\n return [self.edges[0], self.edges[2]]\\n return []\",\n \"def adjacent(self, u, v):\\n return u in self.e[v]\",\n \"def graph_has_self_loops(edges):\\n\\n for a, b in edges:\\n if a == b:\\n return True\\n\\n return False\",\n \"def test_adjacent_unpresent(graph_with_edges):\\n with pytest.raises(ValueError):\\n graph_with_edges.adjacent('Captain Picard', 'Star Wars')\",\n \"def F(graph):\\n return [p for p in graph if set(graph.neighbors(p)) in triads(p)]\",\n \"def run_removing_edges(self):\\n indices = np.where(self.X==1)\\n idx=[]\\n for i in range(len(indices[0])):\\n idx.append((indices[0][i],indices[1][i]))\\n idx = np.array(idx)\\n return self.node_equivalent(idx)\",\n \"def adj_to(self, v):\\n\\n neighbours = set()\\n\\n for (x, y) in self._edges:\\n if x == v: neighbours.add(y)\\n if y == v: neighbours.add(x)\\n\\n return neighbours\",\n \"def edges_without_adjacencies(self):\\n edges = dict(self.eligible_edges_with_indexes)\\n for adj in self.adjacencies.values():\\n for edge_info in adj:\\n if edge_info.self_edge_index in edges:\\n edges[edge_info.self_edge_index] = None\\n return list(filter(lambda x: x is not None, edges.values()))\",\n \"def opposite_vertex(t, tri, edge):\\n tn = neighbour(t, tri, edge)\\n if tn is None:\\n return None\\n\\n for i in range(3):\\n if not has_vertex(t, tri, t[tn][i]):\\n return t[tn][i]\\n\\n return None\",\n \"def check_edge_list(src_nodes, dst_nodes, edge_weights):\\n\\n if len(src_nodes) != len(dst_nodes):\\n raise EdgeListError(\\\"src_nodes and dst_nodes must be of same length.\\\")\\n\\n if edge_weights is None:\\n return\\n\\n if len(edge_weights) != len(src_nodes):\\n raise EdgeListError(\\\"src_nodes and edge_weights must be of same length.\\\")\",\n \"def is_vert(e) :\\n f = e[0][0]\\n for t in e :\\n if f != t[0] :\\n return False\\n return True\",\n \"def neighbours(self):\\n seen = set()\\n return [l.other(self) for l in self.dovetails \\\\\\n if id(l) not in seen and not seen.add(id(l))]\",\n \"def contains_edge(self, u: str, v: str) -> bool:\\n if v in self.adj_list[u]:\\n return True\\n else:\\n return False\",\n \"def find_boundary(edges):\\n\\n inputs = set([x[0] for x in edges])\\n outputs = set([x[1] for x in edges])\\n for e in edges:\\n inputs.discard(e[1])\\n outputs.discard(e[0])\\n return inputs, outputs\",\n \"def is_edge(self, v, w):\\n return self.op_norm(v[0], w[0]) == (v[1] + w[1]) and (self.variant.is_bipartite() or v != w)\",\n \"def DFSU(graph, v, a):\\n a[v]= True # mark the current node as visited\\n\\n for i in graph[v]: # recursively check for all vertices adjacent.\\n if a[i]==False:\\n self.DFS(i,a)\",\n \"def is_adjacent(self, startVertex: np.int_ , endVertex: np.int_):\\n return self.__mat[startVertex][endVertex]>0\",\n \"def clean_edges(self):\\n for from_node in self.all_nodes():\\n for to_node in self.all_nodes():\\n if from_node == to_node:\\n continue\\n dup = list(filter(lambda x: x.from_node == from_node and x.to_node == to_node, self.edges))\\n if len(dup) > 1:\\n for d in dup[1:]:\\n self.edges.remove(d)\",\n \"def is_adjacent(v1, v2):\\n return (v2 in _board_graph[v1])\",\n \"def make_adj_list(V,E):\\n\\tG = {}\\n\\t#pa = {}\\n\\tif V is None or E is None:\\n\\t\\treturn\\n\\tfor u in V:\\n\\t\\tG[u] = []\\n\\t\\t#pa[u] = []\\n\\t\\tfor (w,v) in E:\\n\\t\\t\\tif w == u:\\n\\t\\t\\t\\tG[u].append(v)\\n\\t\\t#pa[v].append(u)\\n\\treturn G\",\n \"def get_consistent_edges(graph):\\n for u, v in _iter_pairs(graph):\\n if pair_is_consistent(graph, u, v):\\n yield u, v\",\n \"def is_directed(G):\\n return G.is_directed()\",\n \"def edges(self) -> Set[Tuple[int, int]] : \\n edges : Set[Tuple[int, int]] = set()\\n for node_id in self.nodes: # iterator over id's\\n for adj_node in self.nodes[node_id]:\\n edge = (node_id, adj_node)\\n if self.directed:\\n edges.add(edge)\\n else:\\n if edge[::-1] not in edges: # if reverse edge not in edges...\\n edges.add(edge)\\n return edges\",\n \"def __filterEdges(self):\",\n \"def _get_non_matched_edges(self):\\n return list(itertools.product(self.coords.values(), self.DIRECTIONS))\",\n \"def is_legal(vtx, color):\\n for neighbor in vtx[\\\"adjacent\\\"]:\\n if VERTICES[neighbor][\\\"color\\\"] is color:\\n return False\\n return True\",\n \"def haveNoSameEdges(seg1,seg2,segmentsMeta):\\n seg1Edges = segmentsMeta['edges'][seg1]\\n seg2Edges = segmentsMeta['edges'][seg2]\\n return not any(a==b for a in seg1Edges for b in seg2Edges)\",\n \"def __has_multiple_edges(self):\\n return \\\\\\n len(\\n list(\\n [\\n tuple((edge.get_first_incident_node().get_name(), edge.get_second_incident_node().get_name()))\\n for edge in self.get_edges()\\n ] # the length of the list which allows duplicates...\\n )\\n ) != \\\\\\n len(\\n set(\\n {\\n tuple((edge.get_first_incident_node().get_name(), edge.get_second_incident_node().get_name()))\\n for edge in self.get_edges()\\n } # ...should equal the length of the set that does not allow duplicates\\n )\\n ) # return True if the two data structures are equal in size and False otherwise\",\n \"def _mout_edges(nodes):\\n n = nodes.shape[0]\\n edges = []\\n for i in range(0, n - 1):\\n for j in range(i, n):\\n if abs(nodes[i, 0] - nodes[j, 0]) > 1:\\n break\\n elif abs(nodes[i, 0] - nodes[j, 0]) == 1 and \\\\\\n abs(nodes[i, 1] - nodes[j, 1]) == 0:\\n edges.append([i, j])\\n elif abs(nodes[i, 1] - nodes[j, 1]) == 1:\\n edges.append([i, j])\\n return edges\",\n \"def edgesWithVertices(self):\\n\\n return {e for e in self.edges if not (e.vert1 is None or e.vert2 is None)}\",\n \"def is_clique(G,S): #set of vertices where every pair in the set forms an edge \\n for v in S:\\n if list(set(S)&set(neighbors(G,v))) != []: #[] <-- empty list\\n return False\\n \\n return True\",\n \"def not_reachable(self,graph):\\n reachable_in = nx.descendants(graph, 0)\\n reachable_out = nx.ancestors(graph, self.nodes - 1)\\n # add the last node back in\\n reachable_out.add(self.nodes - 1)\\n\\n set_of_nodes = set(range(1, self.nodes))\\n\\n not_reachable_in = set_of_nodes - reachable_in\\n not_reachable_out = set_of_nodes - reachable_out\\n return not_reachable_in ,not_reachable_out\",\n \"def is_bipartite(graph: list[list[int]]) -> bool:\\n n = len(graph)\\n color = [0] * n\\n\\n def dfs(c, node):\\n color[node] = c\\n for nxt in graph[node]:\\n if color[nxt] == c:\\n return False\\n if color[nxt] == 0 and not dfs(-c, nxt):\\n return False\\n return True\\n\\n for i in range(n):\\n if color[i] == 0 and not dfs(1, i):\\n return False\\n return True\",\n \"def generate_edges(self):\\n edges = []\\n for vertex in self.graph_dict:\\n for neighbour in self.graph_dict[vertex]:\\n if (neighbour, vertex) not in edges:\\n edges.append((vertex, neighbour))\\n \\n for pair in edges:\\n for otherpair in edges:\\n if pair[1] == otherpair[0]:\\n edges.append((pair[0],otherpair[1]))\\n return edges\",\n \"def edge_filter(edge):\\n # <= because self loops\\n idx, jdx = edge\\n return ((not graph.has_edge(idx, jdx) or is_multigraph) and\\n (idx <= jdx or is_directed) and\\n (idx != jdx or self_loops))\",\n \"def test_bidirectional_edges(self):\\n G = DiGraph()\\n G.add_edges_from([(0, 1), (1, 2), (2, 3), (3, 0), (1, 3), (0, 2)])\\n G.add_edge(1, 0)\\n assert_false(is_tournament(G))\",\n \"def graph_has_duplicates(edges, is_bidirectional=True):\\n\\n curr_edges = set()\\n\\n for edge in edges:\\n if is_bidirectional and edge[0] > edge[1]:\\n edge = (edge[1], edge[0])\\n\\n if edge in curr_edges:\\n return True\\n else:\\n curr_edges.add(edge)\\n\\n return False\",\n \"def remove_edge(self, u, v):\\n \\n try:\\n del self.prefix[v][u]\\n del self.suffix[u][v]\\n except:\\n print(\\\"ERROR: The edges not in graph\\\")\",\n \"def containsEdge(self, v1, v2):\\n for e in self.edges:\\n if (e.pvt, e.nvt) in [(v1, v2), (v2, v1)]:\\n return True\\n return False\",\n \"def constraint_not_adjacent(m, n) :\\n return not constraint_adjacent(m,n)\",\n \"def containsEdge(self, e):\\n return any(e.nvt in [self.vertices[i-2], self.vertices[i]] and self.vertices[i-1] == e.pvt for i in range(len(self.vertices)))\",\n \"def add_all_edges(self):\\n for n1 in self.vertices():\\n for n2 in self.vertices():\\n if n1 != n2:\\n self.add_edge((n1, n2))\",\n \"def neighbours_L(self):\\n seen = set()\\n return [l.other(self) for l in self.dovetails_L \\\\\\n if id(l) not in seen and not seen.add(id(l))]\",\n \"def images_adjacent(i, j, img_adjacency):\\n if img_adjacency[i][j] == 1 or img_adjacency[j][i] == 1:\\n return True\\n else:\\n return False\",\n \"def adjacencyLists():\\r\\n anyNeighbor = lambda u: any(self.neighbors(u))\\r\\n verticesWithNeighbors = filter(anyNeighbor, sorted(self.vertices()))\\r\\n return map(edgesFromVertex, verticesWithNeighbors)\",\n \"def adjacencyLists():\\r\\n anyNeighbor = lambda u: any(self.neighbors(u))\\r\\n verticesWithNeighbors = filter(anyNeighbor, sorted(self.vertices()))\\r\\n return map(edgesFromVertex, verticesWithNeighbors)\",\n \"def adjacentTo()\\r\\n\\r\\n def fitsWith(self, other):\\r\\n # TODO: Can use list comprehesion??\\r\\n for i, selfEdge in enumerate(self.getEdges()):\\r\\n for j, otherEdge in other.getEdges():\\r\\n if selfEdge.fitsWith(otherEdge):\\r\\n return i, j\\r\\n return False # made it here, so no edge fits together\\r\",\n \"def find_isolated_vertices(self):\\n graph = self.__graph_dict\\n isolated = []\\n for vertex in graph:\\n # print(isolated,vertex)\\n if not graph[vertex]:\\n isolated += [vertex]\\n return isolated\",\n \"def test_not_strongly_connected(self):\\n G = DiGraph([(0, 1), (0, 2), (1, 2)])\\n assert_false(is_strongly_connected(G))\",\n \"def remove_edge(self, u, v):\\r\\n elements = self.d.keys()\\r\\n #check for nodes in graph\\r\\n if u not in elements or v not in elements:\\r\\n raise KeyError(str(u) + \\\" and \\\" + str(v) + \\\" must be in graph\\\")\\r\\n #remove other node from each value set\\r\\n self.d[u].remove(v)\\r\\n self.d[v].remove(u)\",\n \"def is_graph(g):\\n # g must be list\\n if type(g) is not list:\\n return False\\n n = len(g)\\n\\n # Neighbors must all be vertices, and given in order, no dups\\n for adjl in g:\\n # Each adj list must be of type list\\n if type(adjl) is not list:\\n return False\\n # Neighbors must be ints in [0,n)\\n for v in adjl:\\n if type(v) is not int:\\n return False\\n if v < 0 or v >= n:\\n return False\\n # Check adj list sorted & no duplicates\\n # (Do *after* above so we know nbrs can be ordered & hashed)\\n if adjl != sorted(list(set(adjl))):\\n return False\\n\\n # Edges must be symmetric, and no loops\\n for v1 in range(n):\\n if v1 in g[v1]:\\n return False\\n for v2 in range(v1):\\n e12 = v2 in g[v1]\\n e21 = v1 in g[v2]\\n if e12 != e21:\\n return False\\n return True\",\n \"def pair_is_consistent(graph, u, v):\\n relations = get_all_relations(graph, u, v)\\n\\n if 1 != len(relations):\\n return False\\n\\n return list(relations)[0]\",\n \"def edge_not_in_component(edge, component):\\n x_start = edge[0]\\n x_stop = edge[0] + edge[2]\\n y_start = edge[1]\\n y_stop = edge[1] + edge[3]\\n if x_start >= component[1].start and x_stop <= component[1].stop and y_start >= component[0].start and y_stop <= \\\\\\n component[0].stop:\\n return False\\n else:\\n return True\",\n \"def validate_edges(attack_surface_graph, admissible_path, starting_points):\\n for i in range(len(admissible_path)-1):\\n for edge in attack_surface_graph.edges(data=True):\\n if edge[0] == admissible_path[i] and edge[1] == admissible_path[i+1]:\\n descriptors = edge[2]\\n if find_violation(descriptors) == [] and edge[0] not in starting_points:\\n return False\\n return True\",\n \"def merge_edge(graph, u, v):\\n # Attach v's adjacency list to u's adjacency list\\n graph[u].extend(graph[v])\\n\\n # Go through all of the vertices in v's adjacency list and replace all instances of v in those adjacency lists with\\n # u\\n for i in graph[v]:\\n adjacency_list = graph[i]\\n\\n for j in range(0, len(adjacency_list)):\\n if adjacency_list[j] == v:\\n adjacency_list[j] = u\",\n \"def test_case21(self):\\n\\n result= self.graph1.isEdge(\\\"supervisor2\\\",\\\"student1\\\")\\n\\n self.assertFalse(result)\",\n \"def isAdjacent(self, vertex1, vertex2):\\n return vertex2 in self.adjList[vertex1]\",\n \"def test_case19(self):\\n\\n result = self.graph1.isEdge(\\\"supervisor5\\\",\\\"student1\\\")\\n self.assertFalse(result)\",\n \"def remove_edge(self, v1, v2):\\n verts = self.vertices\\n if v1 in verts and v2 in verts[v1].adj:\\n del verts[v1].adj[v2]\\n if v2 in verts and v1 in verts[v2].adj:\\n del verts[v2].adj[v1]\",\n \"def CompareEdges(self,edge,dict):\\n \\\"\\\"\\\"Does not assume symmetric edge lists, though you should probably have them\\\"\\\"\\\"\\n # Edge is a tuple with two nodes\\n # Dict is a dictionary of node-keys and tuple (node,float) values\\n if edge[0] in dict.keys():\\n if edge[1] in [x[0] for x in dict[edge[0]]]:\\n return True\\n else:\\n return False\\n else:\\n if edge[1] in dict.keys():\\n if edge[0] in [x[0] for x in dict[edge[1]]]:\\n return True\\n else:\\n return False\\n else:\\n return False\",\n \"def hypergraph_common_edges(u, v, hypergraph):\\n total = 0\\n for e in hypergraph.edges():\\n if u in e.elements and v in e.elements:\\n total += 1\\n return total\",\n \"def test_case20(self):\\n\\n result = self.graph1.isEdge(\\\"supervisor1\\\",\\\"student5\\\")\\n self.assertFalse(result)\",\n \"def test_adjacent_nodes(graph_with_edges):\\n assert graph_with_edges.adjacent('A', 'B')\",\n \"def eligible(self, u, v):\\n return self.eligible_node(u) and self.eligible_node(v) and u != v\",\n \"def edge_filtering(S, edge_list, co=0, type_='out'):\\n edges = edge_list[:]\\n for a in S:\\n S_sort = sorted(S[a], key=S[a].get, reverse=True)\\n for i in range(len(S[a])):\\n b = S_sort[i]\\n if (S[a][b] >= co) | (i == 0):\\n if type_ != 'out':\\n if (b,a) not in edges: edges.append((b,a))\\n else:\\n if (a,b) not in edges: edges.append((a,b))\\n else: break\\n return edges\",\n \"def bipartite(adj):\\n\\n n = len(adj)\\n side = [None] * n # None = undiscovered, 0 means a_side, 1 means b_side.\\n queue = deque()\\n\\n # Try each possible starting point, to find all connected components.\\n for s in range(n):\\n # If s was previously discovered, then skip past it. (Otherwise we'd\\n # waste time re-exploring the whole connected component containing s.)\\n if side[s] != None: continue\\n # Start new BFS at s. Doesn't matter which side we put it on, so we\\n # arbitrarily pick a_side.\\n side[s] = 0\\n queue.append(s)\\n while queue:\\n u = queue.popleft()\\n for v in adj[u]:\\n if side[v] == None:\\n # The next line simultaneously marks v as discovered and\\n # puts it on the opposite side as u (since 1 - side[u]\\n # flips 0 to 1 and 1 to 0).\\n side[v] = 1 - side[u]\\n queue.append(v)\\n elif side[v] == side[u]:\\n # If u and v are already in the same layer, then we know\\n # the graph contains an odd cycle so is not bipartite.\\n side[v] = 3\\n side[u] = 3\\n\\n # If we wanted a list that says for each node which side it's on, we could\\n # just return the side list. But we want the list of nodes on each side,\\n # and there's a slick way to get these using list comprehensions.\\n a_side = [u for u in range(n) if side[u] == 0]\\n b_side = [u for u in range(n) if side[u] == 1]\\n c_side = [u for u in range(n) if side[u] == 3]\\n\\n output = []\\n output.append(a_side)\\n output.append(b_side)\\n return len(output)\",\n \"def remove_adjacent(nums):\\n unique_adjacents = []\\n last_number = 0\\n for num in nums:\\n if num != last_number:\\n unique_adjacents.append(num)\\n last_number = num\\n\\n return unique_adjacents\",\n \"def get_bridges(edges_list):\\n\\n # print(\\\"all edges:\\\", edges_list)\\n\\n # make a temporary graph\\n temp_G = nx.Graph()\\n\\n # add all current edges to the graph\\n for edge in edges_list:\\n edge_node_1, edge_node_2 = edge\\n temp_G.add_edge(edge_node_1, edge_node_2)\\n\\n # get all_bridges in temp graph\\n bridges_all = list(nx.bridges(temp_G))\\n\\n # get set of edges with two traversals left (only want one of each, so use set)\\n mult_trav_remaining = set([])\\n\\n for edge in edges_list:\\n\\n num_trav_remaining = edges_list.count(edge)\\n\\n if num_trav_remaining > 1:\\n\\n mult_trav_remaining.add(edge)\\n\\n mult_trav_remaining = list(mult_trav_remaining)\\n\\n # remove mult traversal edges from bridges list\\n\\n # print(\\\"bridges_ all:\\\", bridges_all)\\n # print(\\\"\\\\nmult_trav_remaining:\\\", mult_trav_remaining)\\n\\n # make a new bridges list that contains only edges that don't have mult traversals left\\n\\n bridges_reduced = []\\n\\n for edge in bridges_all:\\n # print(\\\"\\\\n\\\\nedge:\\\", edge)\\n # print()\\n if edge in mult_trav_remaining:\\n continue\\n # print()\\n # print(f\\\"bridge {edge} is in {mult_trav_remaining}\\\")\\n elif edge[::-1] in mult_trav_remaining:\\n continue\\n # print()\\n # print(f\\\"bridge {edge} REVERSED is in {mult_trav_remaining}\\\")\\n else:\\n # print(f\\\"bridge {edge} is NOT in {mult_trav_remaining}\\\")\\n\\n bridges_reduced.append(edge)\\n\\n # return a list of true bridges\\n return bridges_reduced\",\n \"def test_missing_edges(self):\\n G = DiGraph()\\n G.add_edges_from([(0, 1), (1, 2), (2, 3), (3, 0), (1, 3)])\\n assert_false(is_tournament(G))\",\n \"def edges(self):\\n return self.dovetails + self.containments + self.internals\",\n \"def adjacency_opposite_calculator(graph):\\n adjacency_matrix = sparse.csr_matrix(nx.adjacency_matrix(graph), dtype=np.float32).todense()\\n adjacency_matrix_opposite = np.ones(adjacency_matrix.shape) - adjacency_matrix\\n return adjacency_matrix_opposite\",\n \"def generate_false_edges(true_edges, num_false_edges=5):\\n nodes = list(set(chain.from_iterable(true_edges)))\\n true_edges = set(true_edges)\\n false_edges = set()\\n \\n while len(false_edges) < num_false_edges:\\n # randomly sample two different nodes and check whether the pair exisit or not\\n head, tail = np.random.choice(nodes, 2)\\n if head != tail and ((head, tail) not in true_edges and (tail, head) not in true_edges) and ((head, tail) not in false_edges and (tail, head) not in false_edges):\\n false_edges.add((head, tail)) \\n false_edges = sorted(false_edges)\\n \\n return false_edges\",\n \"def edge_assignment_from_graph(edge_index: nb.int64[:,:],\\n true_edge_index: nb.int64[:,:]) -> nb.int64[:]:\\n # Set the edge as true if it connects two nodes that are connected by a true dependency\\n edge_assn = np.empty(len(edge_index), dtype=np.int64)\\n for k, e in enumerate(edge_index):\\n edge_assn[k] = (e == true_edge_index).any()\\n\\n return edge_assn\",\n \"def is_connected_same_node(graph, node_u, node_v):\\n for out_neighbor_u in graph.get_deductive_out_neighbors(node_u):\\n for out_neighbor_v in graph.get_deductive_out_neighbors(node_v):\\n if out_neighbor_u == out_neighbor_v:\\n return True\\n return False\",\n \"def eligible_edges_with_indexes(self):\\n return list(map(lambda e: (self.edges.index(e), e), self.eligible_edges))\",\n \"def get_contradictory_pairs(graph):\\n for u, v in _iter_pairs(graph):\\n if pair_has_contradiction(graph, u, v):\\n yield u, v\",\n \"def is_independent(self, A):\\n if self.variant.is_bipartite():\\n raise ValueError()\\n return not any(self.is_edge(v, w) for (v, w) in combinations(A, 2))\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.70223045","0.67823124","0.6704551","0.663785","0.65423083","0.65288144","0.6453709","0.6431163","0.64235234","0.63841563","0.6299269","0.6283511","0.6264669","0.6231787","0.6221642","0.6220229","0.6163761","0.6078412","0.60337824","0.60281676","0.60275817","0.60050607","0.6002308","0.5966166","0.59659004","0.5955145","0.5936407","0.59119505","0.5864954","0.5860937","0.58568484","0.58442277","0.58183664","0.58130324","0.58083034","0.57946575","0.57931054","0.57879686","0.5783363","0.57739836","0.57566774","0.57509","0.5748516","0.57320595","0.5725899","0.57247543","0.57214797","0.5714436","0.5711417","0.570343","0.5701145","0.56926954","0.5692678","0.568859","0.568409","0.56745744","0.56735957","0.56662595","0.5663943","0.56614023","0.5659472","0.5653762","0.5643468","0.5627662","0.56215113","0.562089","0.56161296","0.55973953","0.55973953","0.55929613","0.55910903","0.5583616","0.55834556","0.5579062","0.5575259","0.5552589","0.55524737","0.5550962","0.5547503","0.5546429","0.5544383","0.5537431","0.5533304","0.5528875","0.5511274","0.5511072","0.54936916","0.54890513","0.54874754","0.54773504","0.5475274","0.5471657","0.5466426","0.54661053","0.54646283","0.5464157","0.54609597","0.5458243","0.5456279","0.54552674"],"string":"[\n \"0.70223045\",\n \"0.67823124\",\n \"0.6704551\",\n \"0.663785\",\n \"0.65423083\",\n \"0.65288144\",\n \"0.6453709\",\n \"0.6431163\",\n \"0.64235234\",\n \"0.63841563\",\n \"0.6299269\",\n \"0.6283511\",\n \"0.6264669\",\n \"0.6231787\",\n \"0.6221642\",\n \"0.6220229\",\n \"0.6163761\",\n \"0.6078412\",\n \"0.60337824\",\n \"0.60281676\",\n \"0.60275817\",\n \"0.60050607\",\n \"0.6002308\",\n \"0.5966166\",\n \"0.59659004\",\n \"0.5955145\",\n \"0.5936407\",\n \"0.59119505\",\n \"0.5864954\",\n \"0.5860937\",\n \"0.58568484\",\n \"0.58442277\",\n \"0.58183664\",\n \"0.58130324\",\n \"0.58083034\",\n \"0.57946575\",\n \"0.57931054\",\n \"0.57879686\",\n \"0.5783363\",\n \"0.57739836\",\n \"0.57566774\",\n \"0.57509\",\n \"0.5748516\",\n \"0.57320595\",\n \"0.5725899\",\n \"0.57247543\",\n \"0.57214797\",\n \"0.5714436\",\n \"0.5711417\",\n \"0.570343\",\n \"0.5701145\",\n \"0.56926954\",\n \"0.5692678\",\n \"0.568859\",\n \"0.568409\",\n \"0.56745744\",\n \"0.56735957\",\n \"0.56662595\",\n \"0.5663943\",\n \"0.56614023\",\n \"0.5659472\",\n \"0.5653762\",\n \"0.5643468\",\n \"0.5627662\",\n \"0.56215113\",\n \"0.562089\",\n \"0.56161296\",\n \"0.55973953\",\n \"0.55973953\",\n \"0.55929613\",\n \"0.55910903\",\n \"0.5583616\",\n \"0.55834556\",\n \"0.5579062\",\n \"0.5575259\",\n \"0.5552589\",\n \"0.55524737\",\n \"0.5550962\",\n \"0.5547503\",\n \"0.5546429\",\n \"0.5544383\",\n \"0.5537431\",\n \"0.5533304\",\n \"0.5528875\",\n \"0.5511274\",\n \"0.5511072\",\n \"0.54936916\",\n \"0.54890513\",\n \"0.54874754\",\n \"0.54773504\",\n \"0.5475274\",\n \"0.5471657\",\n \"0.5466426\",\n \"0.54661053\",\n \"0.54646283\",\n \"0.5464157\",\n \"0.54609597\",\n \"0.5458243\",\n \"0.5456279\",\n \"0.54552674\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.61262304"},"document_rank":{"kind":"string","value":"17"}}},{"rowIdx":24998,"cells":{"query":{"kind":"string","value":"Validation of the implementaiton of periodic angle axis in Magnetic (MagFEMM) and Force (ForceMT) modules"},"document":{"kind":"string","value":"def test_FEMM_periodicity_time_no_periodicity_a():\n\n SPMSM_015 = load(join(DATA_DIR, \"Machine\", \"SPMSM_015.json\"))\n\n assert SPMSM_015.comp_periodicity() == (9, False, 9, True)\n\n simu = Simu1(name=\"test_FEMM_periodicity_time_no_periodicity_a\", machine=SPMSM_015)\n\n # Definition of the enforced output of the electrical module\n I0_rms = 250 / sqrt(2)\n Phi0 = 140 * pi / 180 # Maximum Torque Per Amp\n\n Id_ref = (I0_rms * exp(1j * Phi0)).real\n Iq_ref = (I0_rms * exp(1j * Phi0)).imag\n\n simu.input = InputCurrent(\n Id_ref=Id_ref,\n Iq_ref=Iq_ref,\n Na_tot=252 * 9,\n Nt_tot=4 * 9,\n N0=1000,\n )\n\n # Definition of the magnetic simulation: with periodicity\n simu.mag = MagFEMM(\n type_BH_stator=1,\n type_BH_rotor=1,\n is_periodicity_a=False,\n is_periodicity_t=True,\n nb_worker=cpu_count(),\n Kmesh_fineness=2,\n )\n simu.force = ForceMT()\n\n # Definition of the magnetic simulation: no periodicity\n simu2 = simu.copy()\n simu2.mag.is_periodicity_t = False\n\n # Run simulations\n out = Output(simu=simu)\n simu.run()\n\n out2 = Output(simu=simu2)\n simu2.run()\n\n # Plot the result\n out.mag.B.plot_2D_Data(\n \"time\",\n \"angle[0]{°}\",\n data_list=[out2.mag.B],\n legend_list=[\"Periodic\", \"Full\"],\n save_path=join(save_path, simu.name + \"_B_time.png\"),\n is_show_fig=False,\n **dict_2D\n )\n\n out.mag.B.plot_2D_Data(\n \"angle{°}\",\n \"time[1]\",\n data_list=[out2.mag.B],\n legend_list=[\"Periodic\", \"Full\"],\n save_path=join(save_path, simu.name + \"_B_space.png\"),\n is_show_fig=False,\n **dict_2D\n )\n\n out.force.AGSF.plot_2D_Data(\n \"wavenumber=[0,100]\",\n \"time[0]\",\n data_list=[out2.force.AGSF],\n legend_list=[\"Periodic\", \"Full\"],\n save_path=join(save_path, simu.name + \"_P_space_fft.png\"),\n is_show_fig=False,\n **dict_2D\n )\n\n out.force.AGSF.plot_2D_Data(\n \"freqs\",\n \"angle[0]\",\n data_list=[out2.force.AGSF],\n legend_list=[\"Periodic\", \"Full\"],\n save_path=join(save_path, simu.name + \"_P_fft2.png\"),\n is_show_fig=False,\n **dict_2D\n )\n\n out.mag.Tem.plot_2D_Data(\n \"time\",\n data_list=[out2.mag.Tem],\n legend_list=[\"Periodic\", \"Full\"],\n save_path=join(save_path, simu.name + \"_Tem_time.png\"),\n is_show_fig=False,\n **dict_2D\n )\n\n out.mag.Phi_wind_stator.plot_2D_Data(\n \"time\",\n \"phase\",\n data_list=[out2.mag.Phi_wind_stator],\n legend_list=[\"Periodic\", \"Full\"],\n save_path=join(save_path, simu.name + \"_Phi_wind_stator_time.png\"),\n is_show_fig=False,\n **dict_2D\n )\n\n Bflux = out.mag.B\n arg_list = [\"time\"]\n result = Bflux.get_rphiz_along(*arg_list)\n Brad = result[\"radial\"]\n time = result[\"time\"]\n\n Bflux2 = out2.mag.B\n arg_list = [\"time\"]\n result2 = Bflux2.get_rphiz_along(*arg_list)\n Brad2 = result2[\"radial\"]\n time2 = result2[\"time\"]\n\n # Compare both simu\n assert_array_almost_equal((Brad - Brad2) / Brad2, 0, decimal=2)\n assert_array_almost_equal(time, time2, decimal=6)\n\n AGSF = out.force.AGSF\n arg_list = [\"time\"]\n result_AGSF = AGSF.get_rphiz_along(*arg_list)\n Prad = result_AGSF[\"radial\"]\n time3 = result_AGSF[\"time\"]\n\n AGSF2 = out2.force.AGSF\n arg_list = [\"time\"]\n result_AGSF2 = AGSF2.get_rphiz_along(*arg_list)\n Prad2 = result_AGSF2[\"radial\"]\n time4 = result_AGSF2[\"time\"]\n\n # Compare both simu\n assert_array_almost_equal((Prad - Prad2) / Prad2, 0, decimal=2)\n assert_array_almost_equal(time3, time4, decimal=6)\n\n return out, out2"},"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 test_FEMM_periodicity_angle():\n\n SPMSM_015 = load(join(DATA_DIR, \"Machine\", \"SPMSM_015.json\"))\n\n assert SPMSM_015.comp_periodicity() == (9, False, 9, True)\n\n simu = Simu1(name=\"test_FEMM_periodicity_angle\", machine=SPMSM_015)\n\n # Definition of the enforced output of the electrical module\n I0_rms = 250 / sqrt(2)\n Phi0 = 140 * pi / 180 # Maximum Torque Per Amp\n\n Id_ref = (I0_rms * exp(1j * Phi0)).real\n Iq_ref = (I0_rms * exp(1j * Phi0)).imag\n\n simu.input = InputCurrent(\n Id_ref=Id_ref,\n Iq_ref=Iq_ref,\n Na_tot=252 * 9,\n Nt_tot=4 * 9,\n N0=1000,\n )\n\n # Definition of the magnetic simulation: with periodicity\n simu.mag = MagFEMM(\n type_BH_stator=1,\n type_BH_rotor=1,\n is_periodicity_a=True,\n is_periodicity_t=False,\n nb_worker=cpu_count(),\n Kmesh_fineness=2,\n )\n simu.force = ForceMT()\n\n # Definition of the magnetic simulation: no periodicity\n # Definition of the magnetic simulation: no periodicity\n simu2 = simu.copy()\n simu2.mag.is_periodicity_a = False\n\n simu2.force = ForceMT()\n\n # Run simulations\n out = Output(simu=simu)\n simu.run()\n\n out2 = Output(simu=simu2)\n simu2.run()\n\n # Plot the result\n out.mag.B.plot_2D_Data(\n \"time\",\n \"angle[0]{°}\",\n data_list=[out2.mag.B],\n legend_list=[\"Periodic\", \"Full\"],\n save_path=join(save_path, simu.name + \"_B_time.png\"),\n is_show_fig=False,\n **dict_2D\n )\n\n out.mag.B.plot_2D_Data(\n \"angle{°}\",\n \"time[1]\",\n data_list=[out2.mag.B],\n legend_list=[\"Periodic\", \"Full\"],\n save_path=join(save_path, simu.name + \"_B_space.png\"),\n is_show_fig=False,\n **dict_2D\n )\n\n out.force.AGSF.plot_2D_Data(\n \"wavenumber=[0,100]\",\n \"time[0]\",\n data_list=[out2.force.AGSF],\n legend_list=[\"Periodic\", \"Full\"],\n save_path=join(save_path, simu.name + \"_P_space_fft.png\"),\n is_show_fig=False,\n **dict_2D\n )\n\n out.force.AGSF.plot_2D_Data(\n \"freqs\",\n \"angle[0]\",\n data_list=[out2.force.AGSF],\n legend_list=[\"Periodic\", \"Full\"],\n save_path=join(save_path, simu.name + \"_P_fft2.png\"),\n is_show_fig=False,\n **dict_2D\n )\n\n out.mag.Tem.plot_2D_Data(\n \"time\",\n data_list=[out2.mag.Tem],\n legend_list=[\"Periodic\", \"Full\"],\n save_path=join(save_path, simu.name + \"_Tem_time.png\"),\n is_show_fig=False,\n **dict_2D\n )\n\n out.mag.Phi_wind_stator.plot_2D_Data(\n \"time\",\n \"phase\",\n data_list=[out2.mag.Phi_wind_stator],\n legend_list=[\"Periodic\", \"Full\"],\n save_path=join(save_path, simu.name + \"_Phi_wind_stator_time.png\"),\n is_show_fig=False,\n **dict_2D\n )\n\n # Compare both simu\n Bflux = out.mag.B\n arg_list = [\"angle\"]\n result = Bflux.get_rphiz_along(*arg_list)\n Brad = result[\"radial\"]\n angle = result[\"angle\"]\n\n Bflux2 = out2.mag.B\n arg_list = [\"angle\"]\n result2 = Bflux2.get_rphiz_along(*arg_list)\n Brad2 = result2[\"radial\"]\n\n assert_array_almost_equal(Brad, Brad2, decimal=1)\n\n return out, out2","def test_mag_form_fac_case1():\n ion = MagneticFormFactor('Fe')\n formfac, _temp = ion.calc_mag_form_fac()[0], ion.calc_mag_form_fac()[1:]\n del _temp\n assert (abs(np.sum(formfac) - 74.155233575216599) < 1e-12)","def test_mag_form_fac():\n ion = MagneticFormFactor('Fe')\n formfac, _temp = ion.calc_mag_form_fac(q=1.)[0], ion.calc_mag_form_fac(q=1.)[1:]\n del _temp\n assert (abs(formfac - 0.932565) < 1e-6)","def test_mag_form_fac_case2():\n ion = MagneticFormFactor('Fe')\n formfac, _temp = ion.calc_mag_form_fac(qrange=[0, 2])[0], ion.calc_mag_form_fac(qrange=[0, 2])[1:]\n del _temp\n assert (abs(np.sum(formfac) - 74.155233575216599) < 1e-12)","def test_library_charges_monatomic_ions(self, monatomic_ion, formal_charge):\n ff = ForceField(\n get_data_file_path(\"test_forcefields/test_forcefield.offxml\"),\n get_data_file_path(\"test_forcefields/ion_charges.offxml\"),\n )\n mol = Molecule.from_smiles(\"[{}]\".format(monatomic_ion))\n omm_system = ff.create_openmm_system(mol.to_topology())\n\n nonbondedForce = [\n f for f in omm_system.getForces() if type(f) == NonbondedForce\n ][0]\n q, _, _ = nonbondedForce.getParticleParameters(0)\n assert q == formal_charge","def check(self, X):\n if (np.min(X) < -90.) or (np.max(X) > 90.):\n print \"Warning: X may be defined in degrees instead of radians\"","def check_force_parameters(self, skipImpropers = False):\n self.check_bonds(self.bond_force0, self.bond_force1)\n self.check_angles(self.angle_force0, self.angle_force1)\n self.check_nonbonded(self.nonbonded_force0, self.nonbonded_force1)\n self.check_proper_torsions(self.torsion_force0, self.torsion_force1, self.bond_force0, self.bond_force1)\n if not skipImpropers:\n self.check_improper_torsions(self.torsion_force0, self.torsion_force1, self.bond_force0, self.bond_force1)\n logger.info(\"Note: skipping degenerate impropers with < 4 atoms.\")","def test_assign_charges_using_library_charges_by_single_atoms(self):\n ff = ForceField(\n get_data_file_path(\"test_forcefields/test_forcefield.offxml\"),\n xml_ethanol_library_charges_by_atom_ff,\n )\n\n molecules = [\n Molecule.from_file(get_data_file_path(\"molecules/ethanol.sdf\")),\n Molecule.from_file(get_data_file_path(\"molecules/ethanol_reordered.sdf\")),\n ]\n top = Topology.from_molecules(molecules)\n omm_system = ff.create_openmm_system(top)\n nonbondedForce = [\n f for f in omm_system.getForces() if type(f) == NonbondedForce\n ][0]\n expected_charges = [\n -0.2,\n -0.1,\n 0.3,\n 0.08,\n -0.02,\n -0.02,\n -0.02,\n -0.01,\n -0.01,\n -0.2,\n 0.3,\n -0.1,\n 0.08,\n -0.02,\n -0.02,\n -0.02,\n -0.01,\n -0.01,\n ] * openmm_unit.elementary_charge\n for particle_index, expected_charge in enumerate(expected_charges):\n q, _, _ = nonbondedForce.getParticleParameters(particle_index)\n assert q == expected_charge","def test_check_compact_axis_angle():\n a_list = [0, 0, 0]\n a = pr.check_compact_axis_angle(a_list)\n assert_array_almost_equal(a_list, a)\n assert_equal(type(a), np.ndarray)\n assert_equal(a.dtype, np.float64)\n\n random_state = np.random.RandomState(0)\n a = pr.norm_vector(pr.random_vector(random_state, 3))\n a *= np.pi + random_state.randn() * 4.0 * np.pi\n a2 = pr.check_compact_axis_angle(a)\n pr.assert_compact_axis_angle_equal(a, a2)\n assert_greater(np.linalg.norm(a2), 0)\n assert_greater(np.pi, np.linalg.norm(a2))\n\n assert_raises_regexp(\n ValueError, \"Expected axis and angle in array with shape\",\n pr.check_compact_axis_angle, np.zeros(4))\n assert_raises_regexp(\n ValueError, \"Expected axis and angle in array with shape\",\n pr.check_compact_axis_angle, np.zeros((3, 3)))","def test_FEMM_periodicity_time():\n\n SPMSM_015 = load(join(DATA_DIR, \"Machine\", \"SPMSM_015.json\"))\n\n assert SPMSM_015.comp_periodicity() == (9, False, 9, True)\n\n simu = Simu1(name=\"test_FEMM_periodicity_time\", machine=SPMSM_015)\n\n # Definition of the enforced output of the electrical module\n I0_rms = 250 / sqrt(2)\n Phi0 = 140 * pi / 180 # Maximum Torque Per Amp\n\n Id_ref = (I0_rms * exp(1j * Phi0)).real\n Iq_ref = (I0_rms * exp(1j * Phi0)).imag\n\n simu.input = InputCurrent(\n Id_ref=Id_ref,\n Iq_ref=Iq_ref,\n Na_tot=252 * 9,\n Nt_tot=4 * 9,\n N0=1000,\n )\n\n # Definition of the magnetic simulation: with periodicity\n simu.mag = MagFEMM(\n type_BH_stator=1,\n type_BH_rotor=1,\n is_periodicity_a=True,\n is_periodicity_t=True,\n nb_worker=cpu_count(),\n Kmesh_fineness=2,\n )\n simu.force = ForceMT()\n\n # Definition of the magnetic simulation: no periodicity\n simu2 = simu.copy()\n simu2.mag.is_periodicity_t = False\n\n # Run simulations\n out = Output(simu=simu)\n simu.run()\n\n out2 = Output(simu=simu2)\n simu2.run()\n\n # Plot the result\n out.mag.B.plot_2D_Data(\n \"time\",\n \"angle[0]{°}\",\n data_list=[out2.mag.B],\n legend_list=[\"Periodic\", \"Full\"],\n save_path=join(save_path, simu.name + \"_B_time.png\"),\n is_show_fig=False,\n **dict_2D\n )\n\n out.mag.B.plot_2D_Data(\n \"angle{°}\",\n \"time[1]\",\n data_list=[out2.mag.B],\n legend_list=[\"Periodic\", \"Full\"],\n save_path=join(save_path, simu.name + \"_B_space.png\"),\n is_show_fig=False,\n **dict_2D\n )\n\n out.force.AGSF.plot_2D_Data(\n \"wavenumber=[0,100]\",\n \"time[0]\",\n data_list=[out2.force.AGSF],\n legend_list=[\"Periodic\", \"Full\"],\n save_path=join(save_path, simu.name + \"_P_space_fft.png\"),\n is_show_fig=False,\n **dict_2D\n )\n\n out.force.AGSF.plot_2D_Data(\n \"freqs\",\n \"angle[0]\",\n data_list=[out2.force.AGSF],\n legend_list=[\"Periodic\", \"Full\"],\n save_path=join(save_path, simu.name + \"_P_fft2.png\"),\n is_show_fig=False,\n **dict_2D\n )\n\n out.mag.Tem.plot_2D_Data(\n \"time\",\n data_list=[out2.mag.Tem],\n legend_list=[\"Periodic\", \"Full\"],\n save_path=join(save_path, simu.name + \"_Tem_time.png\"),\n is_show_fig=False,\n **dict_2D\n )\n\n out.mag.Phi_wind_stator.plot_2D_Data(\n \"time\",\n \"phase\",\n data_list=[out2.mag.Phi_wind_stator],\n legend_list=[\"Periodic\", \"Full\"],\n save_path=join(save_path, simu.name + \"_Phi_wind_stator_time.png\"),\n is_show_fig=False,\n **dict_2D\n )\n\n # Compare both simu with B\n Bflux = out.mag.B\n arg_list = [\"time\"]\n result = Bflux.get_rphiz_along(*arg_list)\n Brad = result[\"radial\"]\n time = result[\"time\"]\n\n # Check Flux spatio-temporal reconstruction full\n Bflux2 = out2.mag.B\n arg_list = [\"time\"]\n result2 = Bflux2.get_rphiz_along(*arg_list)\n Brad2 = result2[\"radial\"]\n time = result2[\"time\"]\n\n assert_array_almost_equal(Brad, Brad2, decimal=2)\n\n # Compare both simu with AGSF\n AGSF = out.force.AGSF\n arg_list = [\"time\"]\n result_AGSF = AGSF.get_rphiz_along(*arg_list)\n Prad = result_AGSF[\"radial\"]\n time = result_AGSF[\"time\"]\n\n AGSF2 = out2.force.AGSF\n arg_list = [\"time\"]\n result_AGSF2 = AGSF2.get_rphiz_along(*arg_list)\n Prad2 = result_AGSF2[\"radial\"]\n time = result_AGSF2[\"time\"]\n\n assert_array_almost_equal(Prad / 1000, Prad2 / 1000, decimal=0)\n\n return out, out2","def comp_angle_magnet(self):\n Rbo = self.get_Rbo()\n W0 = self.comp_W0m()\n Harc = self.comp_H_arc()\n if self.is_outwards():\n return float(2 * arctan(W0 / (2 * (Rbo + self.H1 - Harc))))\n else:\n return float(2 * arctan(W0 / (2 * (Rbo - self.H1 - Harc))))\n\n # if self.W0_is_rad:\n # return self.W0\n # else: # Convert W0 from m to rad\n # Rbo = self.get_Rbo()\n # return float(2 * arcsin(self.W0 / (2 * Rbo)))","def _forces_moments(self, delta):\n # assert delta.shape == (4,1)\n da = delta[0]\n de = delta[1]\n dt = delta[2]\n dr = delta[3]\n\n e0 = self._state[3]\n e1 = self._state[4]\n e2 = self._state[5]\n e3 = self._state[6]\n u = self._state[7]\n v = self._state[8]\n w = self._state[9]\n p = self._state[10]\n q = self._state[11]\n r = self._state[12]\n\n self._Va = np.sqrt(u**2 + v**2 + w**2)\n self._alpha = np.arctan(1.0*w/u)\n self._beta = np.arcsin(1.0*v/self._Va)\n\n\n\n Fg = self.mass*self.gravity*np.array([2*(e1*e3-e2*e0),\n 2*(e2*e3 + e1*e0),\n e3**2 + e0**2 - e1**2 - e2**2,\n ])\n\n # Fg = self.mass*self.gravity*np.array([2*(e1*e3 - e2*e0),\n # 2*(e2*e3 + e1*e0),\n # e3**2 + e0**2 - e1**2 - e2**2,\n # ])\n\n M_e = 25\n sig = lambda a: (1+np.exp(-M_e*(a-self.alpha0))+np.exp(M_e*(a+self.alpha0)))/((1+np.exp(-M_e*(a-self.alpha0)))*(1+np.exp(M_e*(a+self.alpha0))))\n cla = lambda a: (1-sig(a))*(self.C_L_0+self.C_L_alpha*a)+sig(a)*(2*np.sign(a)*np.sin(a)**2*np.cos(a))\n cda = lambda a: self.C_D_p + (self.C_L_0+self.C_L_alpha*a)**2/(np.pi*self.e*self.AR)\n\n cxa = lambda a: -(cda(a)) * np.cos(a) + (cla(a)) * np.sin(a)\n\n cxq = lambda a: -self.C_D_q * np.cos(a) +self.C_L_q * np.sin(a)\n\n cxde = lambda a: -self.C_D_delta_e * np.cos(a) + self.C_L_delta_e * np.sin(a)\n\n cza = lambda a: -(cda(a)) * np.sin(a) - (cla(a)) * np.cos(a)\n\n czq = lambda a: -self.C_D_q * np.sin(a) - self.C_L_q * np.cos(a)\n\n czde = lambda a: -self.C_D_delta_e * np.sin(a) - self.C_L_delta_e * np.cos(a)\n\n c = self.c/(2.0*self._Va)\n b = self.b/(2.0*self._Va)\n\n\n\n one = 0.5*self.rho*self._Va**2*self.S_wing\n # two = np.array([[1,0,0],[0,1,0],[0,0,1]])\n three = np.array([[cxa(self._alpha)+cxq(self._alpha)*c*q+cxde(self._alpha)*de],\n [self.C_Y_0+self.C_Y_beta*self._beta+self.C_Y_p*b*p+self.C_Y_r*b*r+self.C_Y_delta_a*da+self.C_Y_delta_r*dr],\n [cza(self._alpha)+czq(self._alpha)*c*q+czde(self._alpha)*de]])\n\n Fa = np.squeeze(three) * one\n # pdb.set_trace()\n Fa = Fa.reshape((3,-1))\n\n F = Fg + Fa\n #\n # print(\"Fa:\",Fa)\n\n Fp = 0.5*self.rho*self.S_prop*self.C_prop*((self.k_motor*dt)**2-self._Va**2)\n\n # print(\"FP:\", Fp)\n\n fx = F[0] + Fp\n # + 0.5*MAV.rho*self._Va**2*MAV.S_wing*(\\\n # +cxa(self._alpha)\\\n # + cxq(self._alpha)*c*q\\\n # + cxde(self._alpha)*de\n # )\n\n fy = F[1]\n fz = F[2]\n\n # Moment time!!!\n one = 0.5*self.rho*self._Va**2*self.S_wing\n two = np.array([\\\n [self.b*(self.C_ell_0+self.C_ell_beta*self._beta+self.C_ell_p*b*p+self.C_ell_r*b*r+self.C_ell_delta_a*da+self.C_ell_delta_r*dr)],\n [self.c*(self.C_m_0+(self.C_m_alpha*self._alpha)+(self.C_m_q*c*q)+(self.C_m_delta_e*de))],\n [self.b*(self.C_n_0+(self.C_n_beta*self._beta)+(self.C_n_p*b*p)+(self.C_n_r*b*r)+(self.C_n_delta_a*da)+(self.C_n_delta_r*dr))]\n ])\n Ma = one * np.squeeze(two)\n # print(\"\\nMa:\", Ma)\n # pdb.set_trace()\n Ma = Ma.reshape((3,-1))\n\n size = Ma.shape[1]\n\n Mp = np.block([[np.ones(size)*-self.kTp*(self.kOmega*dt)**2],\n [np.zeros(size)],\n [np.zeros(size)]\n ])\n\n M = Mp + Ma\n\n Mx = M[0]\n My = M[1]\n Mz = M[2]\n\n # self._forces[0] = fx\n # self._forces[1] = fy\n # self._forces[2] = fz\n # pdb.set_trace()\n # print(fx, fy, fz, Mx, My, Mz)\n\n return np.array([fx, fy, fz, Mx, My, Mz])","def test_library_charges_dont_parameterize_molecule_because_of_incomplete_coverage(\n self,\n ):\n molecules = [Molecule.from_file(get_data_file_path(\"molecules/toluene.sdf\"))]\n top = Topology.from_molecules(molecules)\n\n # The library charges in the FF should not be able to fully cover toluene\n ff = ForceField(\n get_data_file_path(\"test_forcefields/test_forcefield.offxml\"),\n xml_ethanol_library_charges_by_atom_ff,\n )\n # Delete the ToolkitAM1BCCHandler so the molecule won't get charges from anywhere\n del ff._parameter_handlers[\"ToolkitAM1BCC\"]\n with pytest.raises(\n RuntimeError, match=\"Cc1ccccc1 could not be fully assigned charges\"\n ):\n omm_system = ff.create_openmm_system(top)\n\n # If we do NOT delete the ToolkiAM1BCCHandler, then toluene should be assigned some nonzero partial charges.\n # The exact value will vary by toolkit, so we don't test that here.\n ff = ForceField(\n get_data_file_path(\"test_forcefields/test_forcefield.offxml\"),\n xml_ethanol_library_charges_by_atom_ff,\n )\n omm_system = ff.create_openmm_system(top)\n nonbondedForce = [\n f for f in omm_system.getForces() if type(f) == NonbondedForce\n ][0]\n for particle_index in range(top.n_atoms):\n q, _, _ = nonbondedForce.getParticleParameters(particle_index)\n assert q != 0 * unit.elementary_charge","def is_valid_angle(self, theta_step):\n return not (self.angle % theta_step)","def test_fractional_bondorder_invalid_interpolation_method(self):\n mol = create_ethanol()\n\n forcefield = ForceField(\n get_data_file_path(\"test_forcefields/test_forcefield.offxml\"), xml_ff_bo\n )\n forcefield.get_parameter_handler(\n \"ProperTorsions\"\n )._fractional_bondorder_interpolation = \"invalid method name\"\n topology = Topology.from_molecules([mol])\n\n # If important, this can be a custom exception instead of a verbose ValidationError\n with pytest.raises(\n ValidationError,\n match=\"given=invalid method name\",\n ):\n forcefield.create_openmm_system(\n topology,\n charge_from_molecules=[mol],\n )","def f_theta_omega(angles, times):\n # gravity = 9.81\n # arm_length = 0.1 \n\n # omega = angles[0]\n # theta = angles[1]\n # ftheta = omega\n # fomega = -(gravity/arm_length) * np.sin(theta)\n pass","def is_pure_magnetic(self):\n klist = [key for key in self.components if not self.component_is_zero(key)]\n return all([key.startswith('magnetic') for key in klist])","def test_charge_increment_model_forward_and_reverse_ethanol(self):\n file_path = get_data_file_path(\"test_forcefields/test_forcefield.offxml\")\n ff = ForceField(file_path, xml_charge_increment_model_ff_ethanol)\n del ff._parameter_handlers[\"ToolkitAM1BCC\"]\n top = Topology.from_molecules([create_ethanol(), create_reversed_ethanol()])\n sys = ff.create_openmm_system(top)\n nonbonded_force = [\n force\n for force in sys.getForces()\n if isinstance(force, openmm.NonbondedForce)\n ][0]\n expected_charges = [\n 0.2,\n -0.15,\n -0.05,\n 0.0,\n 0.0,\n 0.0,\n 0.0,\n 0.0,\n 0.0,\n 0.0,\n 0.0,\n 0.0,\n 0.0,\n 0.0,\n 0.0,\n -0.05,\n -0.15,\n 0.2,\n ] * openmm_unit.elementary_charge\n for idx, expected_charge in enumerate(expected_charges):\n charge, _, _ = nonbonded_force.getParticleParameters(idx)\n assert (\n abs(charge - expected_charge) < 1.0e-6 * openmm_unit.elementary_charge\n )","def test_float_input_angles(self):\n decomposer = OneQubitEulerDecomposer(\"PSX\")\n input_matrix = np.array(\n [\n [0.70710678, 0.70710678],\n [0.70710678, -0.70710678],\n ],\n dtype=np.float64,\n )\n (theta, phi, lam) = decomposer.angles(input_matrix)\n expected_theta = 1.5707963267948966\n expected_phi = 0.0\n expected_lam = 3.141592653589793\n self.assertAlmostEqual(theta, expected_theta)\n self.assertAlmostEqual(phi, expected_phi)\n self.assertAlmostEqual(lam, expected_lam)","def test_check_axis_angle():\n a_list = [1, 0, 0, 0]\n a = pr.check_axis_angle(a_list)\n assert_array_almost_equal(a_list, a)\n assert_equal(type(a), np.ndarray)\n assert_equal(a.dtype, np.float64)\n\n random_state = np.random.RandomState(0)\n a = np.empty(4)\n a[:3] = pr.random_vector(random_state, 3)\n a[3] = random_state.randn() * 4.0 * np.pi\n a2 = pr.check_axis_angle(a)\n pr.assert_axis_angle_equal(a, a2)\n assert_almost_equal(np.linalg.norm(a2[:3]), 1.0)\n assert_greater(a2[3], 0)\n assert_greater(np.pi, a2[3])\n\n assert_raises_regexp(\n ValueError, \"Expected axis and angle in array with shape\",\n pr.check_axis_angle, np.zeros(3))\n assert_raises_regexp(\n ValueError, \"Expected axis and angle in array with shape\",\n pr.check_axis_angle, np.zeros((3, 3)))","def test_float_input_angles_and_phase(self):\n decomposer = OneQubitEulerDecomposer(\"PSX\")\n input_matrix = np.array(\n [\n [0.70710678, 0.70710678],\n [0.70710678, -0.70710678],\n ],\n dtype=np.float64,\n )\n (theta, phi, lam, gamma) = decomposer.angles_and_phase(input_matrix)\n expected_theta = 1.5707963267948966\n expected_phi = 0.0\n expected_lam = 3.141592653589793\n expected_gamma = -0.7853981633974483\n self.assertAlmostEqual(theta, expected_theta)\n self.assertAlmostEqual(phi, expected_phi)\n self.assertAlmostEqual(lam, expected_lam)\n self.assertAlmostEqual(gamma, expected_gamma)","def check_nonbonded(self, force0, force1):\n\n assert type(force0) == type(force1), \"Error: force0 and force1 must be the same type.\"\n assert type(force0) == mm.NonbondedForce, \"Error: forces must be NonbondedForces\"\n assert force0.getNumParticles() == force1.getNumParticles(), \"Error: Systems have %d and %d particles in NonbondedForce, respectively.\" % (force0.getNumParticles(), force1.getNumParticles())\n\n n_atoms = force0.getNumParticles()\n\n q, sigma, epsilon = force0.getParticleParameters(0)\n #unit_q, unit_sigma, unit_epsilon = q.unit, sigma.unit, epsilon.unit\n unit_q = u.elementary_charge\n unit_sigma = u.angstrom\n unit_epsilon = u.kilojoule_per_mole\n\n for k in range(n_atoms):\n q0, sigma0, epsilon0 = force0.getParticleParameters(k)\n q1, sigma1, epsilon1 = force1.getParticleParameters(k)\n\n q0, sigma0, epsilon0 = q0 / unit_q, sigma0 / unit_sigma, epsilon0 / unit_epsilon\n q1, sigma1, epsilon1 = q1 / unit_q, sigma1 / unit_sigma, epsilon1 / unit_epsilon\n\n assert compare(q0, q1), \"Error: Particle %d has charges of %f and %f, respectively.\" % (k, q0, q1)\n\n if epsilon0 != 0.:\n assert compare(sigma0, sigma1), \"Error: Particle %d has sigma of %f and %f angstroms, respectively.\" % (k, sigma0, sigma1)\n else:\n logger.info(\"Skipping comparison of sigma (%f, %f) on particle %d because epsilon has values %f, %f kJ/mol\" % (sigma0, sigma1, k, epsilon0, epsilon1))\n\n assert compare(epsilon0, epsilon1), \"Error: Particle %d has epsilon of %f and %f kJ/mol, respectively.\" % (k, epsilon0, epsilon1)\n\n n_exceptions = force0.getNumExceptions()\n assert force0.getNumExceptions() == force1.getNumExceptions(), \"Error: Systems have %d and %d exceptions in NonbondedForce, respectively.\" % (force0.getNumExceptions(), force1.getNumExceptions())\n\n i0, i1, qq, sigma, epsilon = force0.getExceptionParameters(0)\n unit_qq = u.elementary_charge**2\n unit_sigma = u.angstrom\n unit_epsilon = u.kilojoule_per_mole\n\n dict0, dict1 = {}, {}\n for k in range(n_exceptions):\n i0, i1, qq, sigma, epsilon = force0.getExceptionParameters(k)\n i0, i1 = reorder_bonds(i0, i1)\n dict0[i0, i1] = ((qq / unit_qq, sigma / unit_sigma, epsilon / unit_epsilon))\n\n i0, i1, qq, sigma, epsilon = force1.getExceptionParameters(k)\n i0, i1 = reorder_bonds(i0, i1)\n dict1[i0, i1] = ((qq / unit_qq, sigma / unit_sigma, epsilon / unit_epsilon))\n\n keys0 = set(dict0.keys())\n keys1 = set(dict1.keys())\n logger.info(\"Exceptions0 - Exceptions1 = %s\" % (keys0.difference(keys1)))\n logger.info(\"Exceptions1 - Exceptions0 = %s\" % (keys1.difference(keys0)))\n assert set(dict0.keys()) == set(dict1.keys()), \"Systems have different NonBondedForce Exceptions\"\n\n for k, parameter_name in enumerate([\"qq\", \"sigma\", \"epsilon\"]):\n for (i0, i1) in dict0.keys():\n val0 = dict0[i0, i1][k]\n val1 = dict1[i0, i1][k]\n if parameter_name == \"sigma\" and dict0[i0, i1][2] == 0.0 and dict1[i0, i1][2] == 0.0:\n continue # If both epsilon parameters are zero, then sigma doesn't matter so skip the comparison.\n if parameter_name ==\"sigma\":\n assert compare(val0, val1), \"Error: NonBondedForce Exception, atom (%d, %d) has sigma values of %f and %f angstroms, respectively.\" % (i0, i1, parameter_name, val0, val1)\n elif parameter_name==\"qq\":\n assert compare(val0, val1), \"Error: NonBondedForce Exception atom (%d, %d) has squared charge values of %f and %f (elementary charge)**2, respectively.\" % (i0, i1, val0, val1)\n else:\n assert compare(val0, val1), \"Error: NonBondedForce Exception, atom (%d, %d) has epsilon values of %f and %f kJ/mol, respectively.\" % (i0, i1, val0, val1)","def comp_angle_opening_magnet(self):\n\n if self.W1 > 0:\n Rbo = self.get_Rbo()\n return float(2 * arcsin(self.W1 / (2 * Rbo)))\n else:\n return self.comp_angle_magnet()","def check_angles(self, force0, force1):\n\n assert type(force0) == type(force1), \"Error: force0 and force1 must be the same type.\"\n assert type(force0) == mm.HarmonicAngleForce, \"Error: forces must be HarmonicAngleForces\"\n\n n_angles0 = force0.getNumAngles()\n n_angles1 = force1.getNumAngles()\n\n dict0, dict1 = {}, {}\n\n i0, i1, i2, theta0, k0 = force0.getAngleParameters(0)\n #unit_theta = theta0.unit\n unit_theta = u.degrees\n #unit_k = k0.unit\n unit_k = u.kilojoules_per_mole/(u.degrees)**2\n\n for k in range(n_angles0):\n i0, i1, i2, theta0, k0 = force0.getAngleParameters(k)\n if (k0 / k0.unit) != 0.0: # Skip forces with strength 0.0\n i0, i1, i2 = reorder_angles(i0, i1, i2)\n dict0[i0, i1, i2] = ((theta0 / unit_theta, k0 / unit_k))\n\n for k in range(n_angles1):\n i0, i1, i2, theta0, k0 = force1.getAngleParameters(k)\n if (k0 / k0.unit) != 0.0: # Skip forces with strength 0.0\n i0, i1, i2 = reorder_angles(i0, i1, i2)\n dict1[i0, i1, i2] = ((theta0 / unit_theta, k0 / unit_k))\n\n keys0 = set(dict0.keys())\n keys1 = set(dict1.keys())\n logger.info(\"Angles0 - Angles1 = %s\" % (keys0.difference(keys1)))\n logger.info(\"Angles1 - Angles0 = %s\" % (keys1.difference(keys0)))\n diff_keys = keys0.symmetric_difference(keys1)\n assert diff_keys == set(), \"Systems have different HarmonicAngleForce entries: extra keys are: \\n%s\" % diff_keys\n\n for k, parameter_name in enumerate([\"theta0\", \"k0\"]):\n for (i0, i1, i2) in dict0.keys():\n val0 = dict0[i0, i1, i2][k]\n val1 = dict1[i0, i1, i2][k]\n if parameter_name=='theta0':\n assert compare(val0, val1), \"Error: Harmonic Angle (%d, %d, %d) has angle values of %f and %f degrees, respectively.\" % (i0, i1, i2, val0, val1)\n else:\n assert compare(val0, val1), \"Error: Harmonic Angle (%d, %d, %d) has force constant values of %f and %f kJ/(mol degree**2), respectively.\" % (i0, i1, i2, val0, val1)","def isSecondOblateAxis(alpha1, alpha2, beta1, beta2, maxDist, maxTorsAngle): \n a1 = np.asarray(alpha1)\n a2 = np.asarray(alpha2)\n b1 = np.asarray(beta1)\n b2 = np.asarray(beta2)\n #lent = alpha1 - beta1\n adir = a2 - a1\n bdir = b2 - b1\n aLength = np.sqrt ( np.dot(adir, adir) )\n bLength = np.sqrt ( np.dot(bdir, bdir) )\n DotProdNormed = np.dot(adir, bdir) / ( aLength * bLength ) \n maxTors = np.cos( np.radians( maxTorsAngle ))\n if (abs(DotProdNormed) > maxTors):\n # print beta1, beta2, \"not rectangular, angle = \", np.arccos(DotProdNormed)\n return False\n # print beta1, beta2, \"is rectangular.\" \n # find nearest point to alpha mid on the potential beta axis by bisection\n # midAlpha = [a2 + 0.5 * dAlph for a2, dAlph in zip(alpha2, dirAlpha)]\n axisDist = minimalDistance(a1, a2, b1, b2)\n# print \"Distance of\", a1, \"<->\", a2, \" to \", b1, \"<->\", b2, \"is\", axisDist\n #midBeta = [b2 + 0.5 * dBeta for b2, dBeta in zip(beta2, dirBeta)]\n if axisDist < maxDist:\n # print b1, \"<->\", b2, \"is possible axis\"\n return True\n else:\n # print b1, \"<->\", b2, \"is too far (\", axisDist ,\") from\", a1, \"<->\", a2, \", maximal allowed distance =\", maxDist\n return False","def test_axis_angle_from_compact_axis_angle():\n ca = [0.0, 0.0, 0.0]\n a = pr.axis_angle_from_compact_axis_angle(ca)\n assert_array_almost_equal(a, np.array([1.0, 0.0, 0.0, 0.0]))\n\n random_state = np.random.RandomState(1)\n for _ in range(5):\n ca = pr.random_compact_axis_angle(random_state)\n a = pr.axis_angle_from_compact_axis_angle(ca)\n assert_almost_equal(np.linalg.norm(ca), a[3])\n assert_array_almost_equal(ca[:3] / np.linalg.norm(ca), a[:3])","def test_compact_axis_angle():\n a = np.array([1.0, 0.0, 0.0, 0.0])\n ca = pr.compact_axis_angle(a)\n assert_array_almost_equal(ca, np.zeros(3))\n\n random_state = np.random.RandomState(0)\n for _ in range(5):\n a = pr.random_axis_angle(random_state)\n ca = pr.compact_axis_angle(a)\n assert_array_almost_equal(pr.norm_vector(ca), a[:3])\n assert_almost_equal(np.linalg.norm(ca), a[3])","def testCorrectForTwoAtomCellWithoutPeriodicityNEEDED(self):\n\t\texpDist = 0.01*10\n\t\tself._checkExpMatchesActual(expDist)","def test_comp_magnetostrictive_tensor_1cell():\n\n # Physical quantities\n dim = 2\n Nt_tot = 1\n\n mu = 1\n Be = np.array([[[mu / 2, 0]]])\n He = np.array([[[-1 / 2, 0]]])\n mue = np.array([[mu]])\n\n Me = np.reshape(Be / mue - He, (dim, 1, Nt_tot))\n\n alphaij = [[1, 0, 0], [1, 0, 0]]\n\n alpha1 = 1\n alpha2 = 1\n\n # Computation\n tensor = ForceTensor()\n\n tensor_comp = tensor.comp_magnetrosctrictive_tensor(\n mue, Me, Nt_tot, alphaij\n ) # Should be equal to -alpha1*mu*MM' - alpha2*mu*M²*I2\n\n assert tensor_comp[0, 0, 0] == -mu * (alpha1 + alpha2)\n assert tensor_comp[0, 1, 0] == 0\n assert tensor_comp[1, 0, 0] == 0\n assert tensor_comp[1, 1, 0] == -mu * alpha2\n\n print(\"test_comp_magnetostrictive_tensor succeeded\")\n\n return True","def _validate_mesh(self):\n if not (np.abs(self.axis_u.dot(self.axis_v) < 1e-6) and #pylint: disable=no-member\n np.abs(self.axis_v.dot(self.axis_w) < 1e-6) and #pylint: disable=no-member\n np.abs(self.axis_w.dot(self.axis_u) < 1e-6)): #pylint: disable=no-member\n raise ValueError('axis_u, axis_v, and axis_w must be orthogonal')\n return True","def check_these(phi, chi, omega):\n #Calculate the leg position from these angles\n self.getplatepos(phi, chi, omega)\n #Make sure the legs are not in fault\n self.check_limits()\n return (not any(self.leg_fault))","def test_get_partial_charges(self, force_field):\n ethanol: Molecule = create_ethanol()\n\n ethanol_partial_charges = from_openmm(\n self.get_partial_charges_from_create_openmm_system(ethanol, force_field)\n )\n\n partial_charges = force_field.get_partial_charges(ethanol)\n\n assert (\n ethanol_partial_charges - partial_charges < 1.0e-6 * unit.elementary_charge\n ).all()\n assert partial_charges.shape == (ethanol.n_atoms,)","def test_Force_Tensor_compforce():\n\n # 'axes_dict' input\n axes_dict = {\n \"Time\": [0],\n \"Angle\": [0],\n }\n\n # 'output' input\n\n # Mesh object\n\n mesh = MeshMat()\n mesh.cell[\"triangle3\"] = CellMat(nb_node_per_cell=3)\n mesh.node = NodeMat()\n\n mesh.node.add_node(np.array([0, 0]))\n mesh.node.add_node(np.array([0, 1]))\n mesh.node.add_node(np.array([1, 0]))\n\n nodes_test = np.array([0, 1, 2])\n mesh.add_cell(nodes_test, \"triangle3\")\n\n # Mag object\n Time = Data1D(name=\"time\", values=[0], is_components=True)\n indices_cell = [0]\n Indices_Cell = Data1D(name=\"indice\", values=indices_cell, is_components=True)\n axis_list = [Time, Indices_Cell]\n\n mu = 1\n\n B_elem = np.array([[[mu / 2, 0]]])\n H_elem = np.array([[[1 / 2, 0]]])\n mu_elem = np.array([[mu]])\n\n B_sol = build_solution_vector(\n field=B_elem,\n axis_list=axis_list,\n name=\"Magnetic Flux Density\",\n symbol=\"B\",\n unit=\"T\",\n )\n H_sol = build_solution_vector(\n field=H_elem,\n axis_list=axis_list,\n name=\"Magnetic Field\",\n symbol=\"H\",\n unit=\"A/m\",\n )\n mu_sol = build_solution_data(\n field=mu_elem,\n axis_list=axis_list,\n name=\"Magnetic Permeability\",\n symbol=\"mu\",\n unit=\"H/m\",\n )\n\n list_solution = [B_sol, H_sol, mu_sol]\n\n out_dict[\"meshsolution\"] = build_meshsolution(\n list_solution=list_solution,\n label=\"FEMM 2D Magnetostatic\",\n list_mesh=meshFEMM,\n group=groups,\n )","def check_validity(self,check_derivative=True,verbose=True):\n is_valid = True\n if self.f0(0.0)!=0.0:\n is_valid = False\n if verbose:\n print(\"DynamicalSystem: Warning: The system does \"+\n \"not satisfy f0(0)=0 (f(0)=\",self.f0(0.0),\")\")\n if self.f1(1.0)!=1.0:\n is_valid = False\n if verbose:\n print(\"DynamicalSystem: Warning: The system does \"+\n \"not satisfy f0(1)=1 (f1(1)=\",self.f1(1.0),\")\")\n if self.rho_max<self.rho_min:\n is_valid = False\n if verbose:\n print(\"DynamicalSystem: Warning: The system does \"+\n \"not satisfy rho_max>=rho_min (rho_min,rho_max=\",\n rho_min,rho_max,\")\")\n if check_derivative:\n # Coarse check if the derivative is bounded below by some d>1\n # Note it is sufficient to check the restricted ranges given\n xs0 = np.linspace(0.0,self.rho_max,129)\n xs1 = np.linspace(self.rho_min,1.0,129)\n d = np.min(np.concatenate((self.df0(xs0),self.df1(xs1))))\n if d<=1.0:\n is_valid = False\n if verbose:\n print(\"DynamicalSystem: Warning: The system does \"+\n \"not satisfy: d>1 (d<=\",d,\")\")\n return is_valid","def check_angle(self):\n self.find_pixels()\n alpha_theta=np.deg2rad(70)\n alpha_phi=np.deg2rad(70)\n extreme_values=self.compute_extreme_values(alpha_phi, alpha_theta)\n x=np.linspace(extreme_values[0], extreme_values[1], self.number_of_pix[1])\n y=np.linspace(extreme_values[2], extreme_values[3], self.number_of_pix[0])\n phi_0=20\n phi_0=np.deg2rad(phi_0)\n j, diff=self.compute_phi(\"find_orient.png\")\n print \"j=\", j\n print \"diff=\", diff","def test_field():\n\n # Using mesh with radius 10 nm (nmag ex. 1)\n mesh = from_geofile(os.path.join(MODULE_DIR, \"sphere1.geo\"))\n S3 = df.VectorFunctionSpace(mesh, \"Lagrange\", 1)\n m_function = df.interpolate(df.Constant((1, 0, 0)), S3)\n m = Field(S3, m_function)\n\n demag = Demag()\n demag.setup(m, Field(df.FunctionSpace(mesh, 'DG', 0), Ms), unit_length=1e-9)\n\n # Compute demag field\n H_demag = demag.compute_field()\n H_demag.shape = (3, -1)\n x, y, z = H_demag[0], H_demag[1], H_demag[2]\n\n print \"Max values in direction:\"\n print \"x: %g, y: %g, z: %g\" % (max(x), max(y), max(z))\n print \"Min values in direction:\"\n print \"x: %g, y: %g, z: %g\" % (min(x), min(y), min(z))\n\n x, y, z = average(x), average(y), average(z)\n print \"Average values in direction\"\n print \"x: %g, y: %g, z: %g\" % (x, y, z)\n\n # Compute relative erros\n x = abs((x + 1./3*Ms)/Ms)\n y = abs(y/Ms)\n z = abs(z/Ms)\n\n print \"Relative error:\"\n print \"x: %g, y: %g, z: %g\" % (x, y, z)\n assert x < TOL, \"x-average is %g, should be -1/3.\" % x\n assert y < TOL, \"y-average is %g, should be zero.\" % y\n assert z < TOL, \"z-average is %g, should be zero.\" % z","def read_force_field(ff_file, units=\"Angstrom\", fragment_id=AtomicData.atomic_number):\n fh = open(ff_file)\n line = fh.readline()\n # read number of atoms\n nat = int(line.split()[0])\n # skip comment\n fh.readline()\n #\n atomlist = []\n atomtypes = []\n partial_charges = []\n lattice_vectors = []\n for i in xrange(nat+3):\n # read nat atoms and at most 3 lattice vectors\n line = fh.readline()\n if not line:\n # end of file reached\n break\n words = line.split()\n x,y,z = map(float, words[1:4])\n if units == \"Angstrom\":\n x,y,z = map(lambda c: c/AtomicData.bohr_to_angs, [x,y,z])\n if words[0] == \"Tv\":\n lattice_vectors.append( [x,y,z] )\n continue\n atno = fragment_id(words[0])\n atomlist.append((atno, [x,y,z]))\n atomtypes.append(int(words[4]))\n if len(words) > 5:\n # 6th column contains partial charges\n partial_charges.append( float(words[5]) )\n else:\n partial_charges.append( 0.0 ) \n fh.close()\n if lattice_vectors == []:\n print \"No lattice vectors found\"\n # no lattice vectors were provided\n # HACK: By setting a lattice vectors to 0, we tell\n # the function 'build_force_field' that we do not want\n # a periodic calculation in this direction.\n # If all lattice vectors are 0, only the atoms in the central\n # unit cell are included (number of replica cells == 0)\n lattice_vectors = [ [0.0, 0.0, 0.0],\n [0.0, 0.0, 0.0],\n [0.0, 0.0, 0.0] ]\n\n assert len(lattice_vectors) == 3, \"Need 3 lattice vectors, got %d!\" % len(lattice_vectors)\n return atomlist, atomtypes, partial_charges, lattice_vectors","def test_assign_charges_to_molecule_in_parts_using_multiple_library_charges(self):\n ff = ForceField(\n get_data_file_path(\"test_forcefields/test_forcefield.offxml\"),\n xml_ethanol_library_charges_in_parts_ff,\n )\n\n molecules = [\n Molecule.from_file(get_data_file_path(\"molecules/ethanol.sdf\")),\n Molecule.from_file(get_data_file_path(\"molecules/ethanol_reordered.sdf\")),\n ]\n top = Topology.from_molecules(molecules)\n omm_system = ff.create_openmm_system(top)\n nonbondedForce = [\n f for f in omm_system.getForces() if type(f) == NonbondedForce\n ][0]\n expected_charges = [\n -0.2,\n -0.1,\n 0.3,\n 0.08,\n -0.02,\n -0.02,\n -0.02,\n -0.01,\n -0.01,\n -0.2,\n 0.3,\n -0.1,\n 0.08,\n -0.02,\n -0.02,\n -0.02,\n -0.01,\n -0.01,\n ] * openmm_unit.elementary_charge\n for particle_index, expected_charge in enumerate(expected_charges):\n q, _, _ = nonbondedForce.getParticleParameters(particle_index)\n assert q == expected_charge","def test_get_moment_of_inertia_tensor(self):\n symbols = ['O', 'C', 'C', 'H', 'H', 'H', 'H', 'H', 'H']\n coords = np.array([[1.28706525, 0.52121353, 0.04219198],\n [0.39745682, -0.35265044, -0.63649234],\n [0.36441173, -1.68197093, 0.08682400],\n [-0.59818222, 0.10068325, -0.65235399],\n [0.74799641, -0.48357798, -1.66461710],\n [0.03647269, -1.54932006, 1.12314420],\n [-0.31340646, -2.38081353, -0.41122551],\n [1.36475837, -2.12581592, 0.12433596],\n [2.16336803, 0.09985803, 0.03295192]], np.float64)\n tensor = get_moment_of_inertia_tensor(coords=coords, symbols=symbols)\n expected_tensor = [[50.24197604, -15.43600683, -3.07977736],\n [-15.43600683, 22.20416597, 2.5935549],\n [-3.07977736, 2.5935549, 55.49144794]]\n np.testing.assert_almost_equal(tensor, expected_tensor)","def test_fractional_bondorder_multiple_same_mol(self):\n\n mol = create_ethanol()\n mol2 = create_reversed_ethanol()\n\n forcefield = ForceField(\n get_data_file_path(\"test_forcefields/test_forcefield.offxml\"),\n xml_ff_bo,\n )\n topology = Topology.from_molecules([mol, mol2])\n\n with pytest.raises(ValueError):\n forcefield.create_openmm_system(\n topology,\n charge_from_molecules=[mol],\n partial_bond_orders_from_molecules=[mol, mol2],\n )","def test_conversions_matrix_axis_angle_continuous():\n for angle in np.arange(3.1, 3.2, 0.01):\n a = np.array([1.0, 0.0, 0.0, angle])\n R = pr.matrix_from_axis_angle(a)\n pr.assert_rotation_matrix(R)\n\n a2 = pr.axis_angle_from_matrix(R)\n pr.assert_axis_angle_equal(a, a2)\n\n R2 = pr.matrix_from_axis_angle(a2)\n assert_array_almost_equal(R, R2)\n pr.assert_rotation_matrix(R2)","def ft_ext_force(self):\r\n return self._arm.ft_ext_force","def check_proper_torsions(self, force0, force1, bond_force0, bond_force1):\n\n assert type(force0) == type(force1), \"Error: force0 and force1 must be the same type.\"\n assert type(force0) == mm.PeriodicTorsionForce, \"Error: forces must be PeriodicTorsionForce\"\n\n bond_set0 = get_symmetrized_bond_set(bond_force0)\n bond_set1 = get_symmetrized_bond_set(bond_force1)\n\n # Build list of atoms to help make output more useful\n atoms0 = [ atom for atom in self.simulation0.topology.atoms() ]\n atoms1 = [ atom for atom in self.simulation1.topology.atoms() ]\n\n\n # Check torsions for equivalent\n\n if force0.getNumTorsions() == 0 and force1.getNumTorsions() == 0:\n return # Must leave now, otherwise try to access torsions that don't exist.\n\n F = force0 if force0.getNumTorsions() > 0 else force1 # Either force0 or force1 is nonempty, so find that one.\n i0, i1, i2, i3, per, phase, k0 = F.getTorsionParameters(0)\n #phase_unit, k0_unit = phase.unit, k0.unit\n k0_unit = u.kilojoules_per_mole\n phase_unit = u.degrees\n\n dict0, dict1 = {}, {}\n for k in range(force0.getNumTorsions()):\n i0, i1, i2, i3, per, phase, k0 = force0.getTorsionParameters(k)\n if not is_proper(i0, i1, i2, i3, bond_set0):\n continue\n\n i0, i1, i2, i3 = reorder_proper_torsions(i0, i1, i2, i3)\n\n phase, k0 = phase / phase_unit, k0 / k0_unit\n if k0 == 0.0:\n continue\n\n if not (i0, i1, i2, i3) in dict0:\n dict0[i0, i1, i2, i3] = []\n\n dict0[i0, i1, i2, i3].append((per, phase, k0))\n\n for k in range(force1.getNumTorsions()):\n i0, i1, i2, i3, per, phase, k0 = force1.getTorsionParameters(k)\n if not is_proper(i0, i1, i2, i3, bond_set1):\n continue\n\n i0, i1, i2, i3 = reorder_proper_torsions(i0, i1, i2, i3)\n\n phase, k0 = phase / phase_unit, k0 / k0_unit\n if k0 == 0.0:\n continue\n\n if not (i0, i1, i2, i3) in dict1:\n dict1[i0, i1, i2, i3] = []\n\n dict1[i0, i1, i2, i3].append((per, phase, k0))\n\n keys0 = set(dict0.keys())\n keys1 = set(dict1.keys())\n diff_keys = keys0.symmetric_difference(keys1)\n\n logger.info(\"Propers0 - Propers1 = %s\" % (keys0.difference(keys1)))\n logger.info(\"Propers1 - Propers0 = %s\" % (keys1.difference(keys0)))\n assert diff_keys == set(), \"Systems have different (proper) PeriodicTorsionForce entries: extra keys are: \\n%s\" % diff_keys\n\n for (i0, i1, i2, i3) in dict0.keys():\n # Store strings for printing debug info\n torsion_atoms0 = '%s - %s - %s - %s' % (atoms0[i0].name, atoms0[i1].name, atoms0[i2].name, atoms0[i3].name )\n torsion_atoms1 = '%s - %s - %s - %s' % (atoms1[i0].name, atoms1[i1].name, atoms1[i2].name, atoms1[i3].name )\n\n # Proceed to check\n entries0 = dict0[i0, i1, i2, i3]\n entries1 = dict1[i0, i1, i2, i3]\n if len(entries0) != len(entries1):\n print(\"Compared torsion involving atoms '%s' with that involving atoms '%s': \" % (torsion_atoms0, torsion_atoms1))\n raise Exception(\"Error: (proper) PeriodicTorsionForce entry (atoms %d, %d, %d, %d) has different numbers of terms (%d and %d, respectively).\" % (i0, i1, i2, i3, len(entries0), len(entries1)))\n\n subdict0 = dict(((per, reduce_precision(phase)), k0) for (per, phase, k0) in entries0)\n subdict1 = dict(((per, reduce_precision(phase)), k0) for (per, phase, k0) in entries1)\n\n if set(subdict0.keys()) != set(subdict1.keys()):\n print(\"Compared torsion involving atoms '%s' with that involving atoms '%s': \" % (torsion_atoms0, torsion_atoms1))\n print(\"Keys for system0: '%s'; keys for system1: '%s'\" % (subdict0.keys(), subdict1.keys() ) )\n raise Exception(\"Error: (proper) PeriodicTorsionForce entry (atoms %d, %d, %d, %d) has different terms.\" % (i0, i1, i2, i3) )\n\n for (per, phase) in subdict0.keys():\n val0 = subdict0[per, phase]\n val1 = subdict1[per, phase]\n if not compare(val0, val1):\n print(\"Compared torsion involving atoms '%s' with that involving atoms '%s': \" % (torsion_atoms0, torsion_atoms1))\n raise Exception( \"Error: (proper) PeriodicTorsionForce (atoms %d, %d, %d, %d, periodicity %d, phase %f degrees) has barrier height values of %f and %f kJ/mol, respectively.\" % (i0, i1, i2, i3, per, phase, val0, val1) )","def test_run_mantel_test_no_cdm(self):\r\n self.assertRaises(ValueError, run_mantel_test, 'partial_mantel',\r\n [self.fp1, self.fp2], [self.dm1,\r\n self.dm2], self.num_perms,\r\n 'two sided', self.comment, self.alpha)","def test_euler_angles_1q_hard_thetas(self, gate):\n self.check_one_qubit_euler_angles(Operator(gate))","def test_maf(self):\n # Flipping the strand\n self.assertAlmostEqual(self.g.maf(), 8 / 18)","def is_valid(self):\n return (4 * (self.a ** 3) + 27 * (self.b ** 2)) % self.fp != 0","def CalcForce_aeroframe_DEP(V, CoefMatrix, x, rho, g):\r\n\r\n #Compute aero forces\r\n # here x must be of the form (alpha, beta, p, q, r, da, dr, de) (last one punctualy used)\r\n # set non dim for p,q,r\r\n nonDim=np.ones(7)\r\n nonDim[2]=g.b/(2*V)\r\n nonDim[3]=g.c/(2*V)\r\n nonDim[4]=g.b/(2*V)\r\n # F=np.dot(CoefMatrix,x[0:7]) # commented form, modification to account for symmetric drag increase of side slip\r\n F=np.zeros((3))\r\n M=np.zeros((3))\r\n xsym=np.copy(x[0:-1])\r\n xsym[1]=abs(xsym[1]) # make beta always positive since derivatives have already correct sign for drag and lift only\r\n xsym[-3]=abs(xsym[-3]) # make ailerons deflection always positive for drag increase and lift decrease\r\n xsym[-1]=abs(xsym[-1]) # make rudder deflection always positive for drag increase and lift decrease\r\n F[0]=np.dot(CoefMatrix[0],xsym)\r\n F[1]=np.dot(CoefMatrix[1],x[0:-1]) #side force\r\n F[2]=np.dot(CoefMatrix[2],xsym)\r\n M=np.dot(CoefMatrix[3:6,:],x[0:-1])\r\n# print(\"Printing moment coeff\")\r\n# print(M)\r\n\r\n \r\n #No need to project\r\n# alpha=x[0]\r\n# beta=x[1]\r\n# H=np.array([[math.cos(alpha)*math.sin(beta), -math.cos(alpha)*math.sin(beta), -math.sin(alpha)],[math.sin(beta), math.cos(beta), 0],[math.sin(alpha)*math.cos(beta), -math.sin(alpha)*math.sin(beta), math.cos(alpha)]])\r\n if V<=71 :\r\n Fbody=np.array([-F[0]-g.Cd0_fl,F[1],-F[2]-g.CL0_fl]) # add alpha=0 coefficients\r\n Moment=M+np.array([0,x[-1]*g.Cm_de+g.Cm0_fl,0])\r\n else:\r\n Fbody=np.array([-F[0]-g.Cd0,F[1],-F[2]-g.CL0]) # add alpha=0 coefficients\r\n Moment=M+np.array([0,x[-1]*g.Cm_de+g.Cm0,0])\r\n \r\n\r\n Fbody=0.5*V**2.0*rho*g.S*Fbody\r\n Moment=0.5*V**2.0*rho*g.S*g.b*Moment\r\n \r\n return np.append(Fbody, Moment)","def test_force(self):\n group = hoomd.group.all()\n\n # compute forces\n f = azplugins.restrain.plane(group=group, point=(0,0,0), normal=(1,0,0), k=2.0)\n hoomd.run(1)\n np.testing.assert_array_almost_equal(f.forces[0].force, (-2.,0,0))\n np.testing.assert_array_almost_equal(f.forces[1].force, ( 2.,0,0))\n np.testing.assert_array_almost_equal(f.forces[2].force, ( 6.,0,0))\n self.assertAlmostEqual(f.forces[0].energy, 1.)\n self.assertAlmostEqual(f.forces[1].energy, 1.)\n self.assertAlmostEqual(f.forces[2].energy, 9.)\n np.testing.assert_array_almost_equal(f.forces[0].virial, (-2.,0,0,0,0,0))\n np.testing.assert_array_almost_equal(f.forces[1].virial, (-2.,0,4.,0,0,0))\n np.testing.assert_array_almost_equal(f.forces[2].virial, (12.,0,0,0,0,0))\n\n # change the spring constant\n f.set_params(k=1.0)\n hoomd.run(1)\n np.testing.assert_array_almost_equal(f.forces[0].force, (-1.,0,0))\n np.testing.assert_array_almost_equal(f.forces[1].force, ( 1.,0,0))\n np.testing.assert_array_almost_equal(f.forces[2].force, ( 3.,0,0))\n self.assertAlmostEqual(f.forces[0].energy, 0.5)\n self.assertAlmostEqual(f.forces[1].energy, 0.5)\n self.assertAlmostEqual(f.forces[2].energy, 4.5)\n\n # shift the plane down\n f.set_params(point=(-1,0,0))\n hoomd.run(1)\n np.testing.assert_array_almost_equal(f.forces[0].force, (-2.,0,0))\n np.testing.assert_array_almost_equal(f.forces[1].force, ( 0.,0,0))\n np.testing.assert_array_almost_equal(f.forces[2].force, ( 2.,0,0))\n self.assertAlmostEqual(f.forces[0].energy, 2.0)\n self.assertAlmostEqual(f.forces[1].energy, 0.0)\n self.assertAlmostEqual(f.forces[2].energy, 2.0)\n\n # rotate the plane so that only particle 1 is off the line\n f.set_params(point=(0,0,0), normal=(0,0,1))\n hoomd.run(1)\n np.testing.assert_array_almost_equal(f.forces[0].force, (0,0,0))\n np.testing.assert_array_almost_equal(f.forces[1].force, (0,0,-2))\n np.testing.assert_array_almost_equal(f.forces[2].force, (0,0,0))\n self.assertAlmostEqual(f.forces[0].energy, 0.0)\n self.assertAlmostEqual(f.forces[1].energy, 2.0)\n self.assertAlmostEqual(f.forces[2].energy, 0.0)","def calculate_allowable_angles(self, angular_resolution=0.01, visualize=0, optimized=False):\n #Could be optimized more, if required.\n \n if visualize:\n pylab.ion() #Turns interaction on (?)\n print \"Calculation started\"\n\n if angular_resolution < self.ANGULAR_RESOLUTION_MIN:\n warnings.warn(\"Requested too small angular resolution. Using %s\" % self.ANGULAR_RESOLUTION_MIN)\n angular_resolution = self.ANGULAR_RESOLUTION_MIN\n\n #We do not need to look at more than the motor step size in phi, since the sample rotational\n # motor does the rest.\n self.phi_range = 0.99 * (self.sample_motor_step_size / 2)\n #Arbitrary max ranges here. TODO: User setting?\n self.chi_range = pi/8\n self.omega_range = pi/6\n\n #Make the lists\n self.phi_list = array([-self.phi_range, 0, self.phi_range])\n self.phi_list = np.append(np.arange(-self.phi_range, self.phi_range, angular_resolution), (self.phi_range) )\n self.chi_list = np.arange(-self.chi_range, self.chi_range, angular_resolution)\n self.omega_list = np.arange(-self.omega_range, self.omega_range, angular_resolution)\n\n #Create the allowed angle map, all false\n self.allowed = np.zeros( (self.phi_list.size, self.chi_list.size, self.omega_list.size), dtype=np.bool )\n\n #Make sure the limits are calculated\n self.calculate_leg_xy_limits()\n\n\n #Loop through all the angles\n for i_phi in range(self.phi_list.size):\n phi = self.phi_list[i_phi]\n print 'Calculating phi = %s' % phi\n was_anything_in_line = False\n for i_chi in range(self.chi_list.size):\n chi = self.chi_list[i_chi]\n was_allowed = False\n for i_omega in range(self.omega_list.size):\n omega = self.omega_list[i_omega]\n\n #Calcualte the leg position from these angles\n self.getplatepos(phi, chi, omega)\n #Make sure the legs are not in fault\n self.check_limits()\n allowed = not any(self.leg_fault)\n #Save it\n self.allowed[i_phi, i_chi, i_omega] = allowed\n if optimized:\n #Check that we have reached an unallowed section, to speed calculation\n if allowed: was_allowed = True\n if was_allowed and (not allowed):\n break #All other omega values in this chi will be false. Exit to the next line\n #(end of omega loop)\n\n if optimized:\n #Is there anything allowed in this chi line?\n anything_in_line = any(self.allowed[i_phi, i_chi, :])\n #Once we reach a completely disallowed line, all others after will be too\n if anything_in_line: was_anything_in_line = True\n if was_anything_in_line and (not anything_in_line):\n break #we don't need to look at the remaining lines.\n #(end of chi loop)\n #(end of phi loop)\n\n print \"Done!\"\n \n if visualize==1:\n #2D Animated plot\n for i_phi in range(self.phi_list.size):\n phi = self.phi_list[i_phi]\n #Here we are still in the phi loop\n if visualize:\n pylab.figure(0)\n pylab.imshow(self.allowed[i_phi, :, :], interpolation='nearest', extent=(-self.omega_range, self.omega_range, -self.chi_range, self.chi_range))\n pylab.xlabel(\"Omega\")\n pylab.ylabel(\"Chi\")\n pylab.title(\"Allowable angles for phi=%s\" % phi)\n pylab.draw()\n time.sleep(0.2)\n pylab.draw()\n time.sleep(1)\n pylab.ion()\n \n\n if visualize==2:\n #Single 3D plot of allowed angles.\n mlab.clf() #Clear figure\n mlab.contour3d(self.allowed.astype(float), contours=[0.5])\n mlab.xlabel(\"Phi\")\n mlab.ylabel(\"Chi\")\n mlab.zlabel(\"Omega\")\n mlab.axes()\n mlab.show()\n\n #Done calculating\n return None","def check_doa(geometry, doa):\n if doa < 0:\n return False\n if geometry == \"linear\" and doa > 180:\n return False\n if geometry == \"circular\" and doa >= 360:\n return False\n return True","def HFincidentAngle(self,PFC, MHD):\n xyz = PFC.centers\n r,z,phi = tools.xyz2cyl(xyz[:,0],xyz[:,1],xyz[:,2])\n BNorms = MHD.Bfield_pointcloud(PFC.ep, r, z, phi, PFC.powerDir, normal=True)\n PFC.bdotn = np.multiply(PFC.norms, BNorms).sum(1)\n return","def force_12(alpha, r1, r2, R_particle, eps_particle, k, eps_out, eps_in,\n fiber_radius, nmin, nmax, kzimax, E0_mod, nmin_sc, nmax_sc, case):\n\n dr = 1 / k * 1e-5\n dz = dr\n dtheta = 1e-5\n\n p1 = dipole_moment(1, r1, r2, R_particle, eps_particle, k, eps_out, eps_in,\n fiber_radius, nmin, nmax, kzimax,\n E0_mod, nmin_sc, nmax_sc, case)\n p1c = p1.conjugate()\n\n # Fr\n if alpha == 0:\n r1plusdr = r1 + np.array([dr, 0, 0])\n r1minusdr = r1 - np.array([dr, 0, 0])\n Eplusr = total_loc_efield(1, r1plusdr, r2, k, case, nmin, nmax, kzimax,\n fiber_radius, eps_out, eps_in, E0_mod,\n nmin_sc, nmax_sc, R_particle, eps_particle)\n Eminusr = total_loc_efield(1, r1minusdr, r2, k, case, nmin, nmax, kzimax,\n fiber_radius, eps_out, eps_in, E0_mod,\n nmin_sc, nmax_sc, R_particle, eps_particle)\n grad_r = (Eplusr - Eminusr) / (2 * dr)\n\n return(0.5 * np.dot(p1c, grad_r).real)\n # Ftheta\n elif alpha == 1:\n r1plusdtheta = r1 + np.array([0, dtheta, 0])\n r1minusdtheta = r1 - np.array([0, dtheta, 0])\n\n Eplustheta = total_loc_efield(1, r1plusdtheta, r2, k, case, nmin, nmax, kzimax,\n fiber_radius, eps_out, eps_in, E0_mod,\n nmin_sc, nmax_sc, R_particle, eps_particle)\n Eminustheta = total_loc_efield(1, r1minusdtheta, r2, k, case, nmin, nmax, kzimax,\n fiber_radius, eps_out, eps_in, E0_mod,\n nmin_sc, nmax_sc, R_particle, eps_particle)\n grad_theta = (Eplustheta - Eminustheta) / (r1[0] * 2 * dtheta)\n\n return(0.5 * np.dot(p1c, grad_theta).real)\n # Fz\n elif alpha == 2:\n r1plusdz = r1 + np.array([0, 0, dz])\n r1minusdz = r1 - np.array([0, 0, dz])\n\n Eplusz = total_loc_efield(1, r1plusdz, r2, k, case, nmin, nmax, kzimax,\n fiber_radius, eps_out, eps_in, E0_mod,\n nmin_sc, nmax_sc, R_particle, eps_particle)\n Eminusz = total_loc_efield(1, r1minusdz, r2, k, case, nmin, nmax, kzimax,\n fiber_radius, eps_out, eps_in, E0_mod,\n nmin_sc, nmax_sc, R_particle, eps_particle)\n grad_z = (Eplusz - Eminusz) / (2 * dz)\n\n return(0.5 * np.dot(p1c, grad_z).real)\n else:\n print('alpha is out of range!')\n return(0)","def checkForwardBackwardUnity(self):\n if round(self.alpha[-1,-1] - self.beta[0, 0], 7) != 0:\n print('')\n raise BaumWelchForwardBackwardDifference(self.alpha[-1,-1], self.beta[0,0])","def check_improper_torsions(self, force0, force1, bond_force0, bond_force1):\n\n assert type(force0) == type(force1), \"Error: force0 and force1 must be the same type.\"\n assert type(force0) == mm.PeriodicTorsionForce, \"Error: forces must be PeriodicTorsionForce\"\n\n bond_set0 = get_symmetrized_bond_set(bond_force0)\n bond_set1 = get_symmetrized_bond_set(bond_force1)\n\n if force0.getNumTorsions() == 0 and force1.getNumTorsions() == 0:\n return # Must leave now, otherwise try to access torsions that don't exist.\n\n F = force0 if force0.getNumTorsions() > 0 else force1 # Either force0 or force1 is nonempty, so find that one.\n i0, i1, i2, i3, per, phase, k0 = F.getTorsionParameters(0)\n #phase_unit, k0_unit = phase.unit, k0.unit\n k0_unit = u.kilojoules_per_mole\n phase_unit = u.degrees\n\n dict0, dict1 = {}, {}\n for k in range(force0.getNumTorsions()):\n i0, i1, i2, i3, per, phase, k0 = force0.getTorsionParameters(k)\n if not is_improper(i0, i1, i2, i3, bond_set0):\n continue\n\n i0, i1, i2, i3 = reorder_improper_torsions(i0, i1, i2, i3, bond_set0)\n\n phase, k0 = phase / phase_unit, k0 / k0_unit\n if k0 == 0.0:\n continue\n\n if not (i0, i1, i2, i3) in dict0:\n dict0[i0, i1, i2, i3] = []\n\n dict0[i0, i1, i2, i3].append((per, phase, k0))\n\n for k in range(force1.getNumTorsions()):\n i0, i1, i2, i3, per, phase, k0 = force1.getTorsionParameters(k)\n if not is_improper(i0, i1, i2, i3, bond_set1):\n continue\n\n i0, i1, i2, i3 = reorder_improper_torsions(i0, i1, i2, i3, bond_set0)\n\n phase, k0 = phase / phase_unit, k0 / k0_unit\n if k0 == 0.0:\n continue\n\n if not (i0, i1, i2, i3) in dict1:\n dict1[i0, i1, i2, i3] = []\n\n dict1[i0, i1, i2, i3].append((per, phase, k0))\n\n keys0 = set(dict0.keys())\n keys1 = set(dict1.keys())\n diff_keys = keys0.symmetric_difference(keys1)\n\n logger.info(\"Impropers0 - Impropers1 = %s\" % (keys0.difference(keys1)))\n logger.info(\"Impropers1 - Impropers0 = %s\" % (keys1.difference(keys0)))\n assert diff_keys == set(), \"Systems have different (improper) PeriodicTorsionForce entries: extra keys are: \\n%s\" % diff_keys\n\n for (i0, i1, i2, i3) in dict0.keys():\n entries0 = dict0[i0, i1, i2, i3]\n entries1 = dict1[i0, i1, i2, i3]\n assert len(entries0) == len(entries1), \"Error: (improper) PeriodicTorsionForce entry (%d, %d, %d, %d) has different numbers of terms (%d and %d, respectively).\" % (i0, i1, i2, i3, len(entries0), len(entries1))\n\n subdict0 = dict(((per, reduce_precision(phase)), k0) for (per, phase, k0) in entries0)\n subdict1 = dict(((per, reduce_precision(phase)), k0) for (per, phase, k0) in entries1)\n\n assert set(subdict0.keys()) == set(subdict1.keys()), \"Error: (improper) PeriodicTorsionForce entry (%d, %d, %d, %d) has different terms.\" % (i0, i1, i2, i3)\n\n for (per, phase) in subdict0.keys():\n val0 = subdict0[per, phase]\n val1 = subdict1[per, phase]\n assert compare(val0, val1), \"Error: (improper) PeriodicTorsionForce (atoms %d, %d, %d, %d, periodicity %d, phase %f degrees) has barrier height values of %f and %f kJ/mol, respectively.\" % (i0, i1, i2, i3, per, phase, val0, val1)","def read_forces(self, fname):\n outfile = open(fname)\n lines = outfile.readlines()\n outfile.close()\n nats = len(self.atoms)\n forces = np.zeros((nats, 3), float)\n infinite_force=\"*****\"\n if 'mozyme' in self.str_params['job_type'].lower():\n for i, line in enumerate(lines):\n if line.find('FINAL POINT AND DERIVATIVES') != -1:\n for j in range(nats):\n gline = lines[i + j + 5]\n pre_force=gline[8:35]\n if(infinite_force in pre_force):\n forces[j] = [999999999.9999,999999999.9999,999999999.9999]\n else:\n forces[j] = [float( pre_force[0:9].strip()),float( pre_force[9:18].strip()),float( pre_force[18:27].strip())]\n else:\n for i, line in enumerate(lines):\n if line.find('GRADIENT\\n') != -1:\n for j in range(nats * 3):\n gline = lines[i + j + 1]\n pre_force=gline[49:62]\n if(infinite_force in pre_force):\n forces[int(j/3), int(j%3)] =999999999.9999\n else:\n forces[int(j/3), int(j%3)] = float(pre_force)\n break\n#do not change unit for mopac\n forces *= - (kcal / mol)\n return forces","def test_remove_translational_rotational_dof(positions):\n class DummyTimeStep:\n def __init__(self, positions):\n self.positions = positions\n self.n_atoms = len(positions)\n ts = DummyTimeStep(positions=positions)\n\n transform = RemoveTransRotDOF(\n center_atom_idx=0,\n axis_atom_idx=2,\n plane_atom_idx=3,\n axis='z',\n plane='xz'\n )\n ts = transform(ts)\n\n # The center atom is at the origin.\n assert np.allclose(ts.positions[transform._center_atom_idx], 0.0)\n\n # The axis atom is on the expected axis.\n expected_axis_atom_position = transform.axis * np.linalg.norm(\n positions[transform._axis_atom_idx] - positions[transform._center_atom_idx])\n assert np.allclose(ts.positions[transform._axis_atom_idx], expected_axis_atom_position)\n\n # The plane atom is orthogonal to the plane normal.\n assert np.allclose(np.dot(ts.positions[transform._plane_atom_idx], transform.plane), 0.0)\n\n # The constrained atom indices is correct.\n expected = np.array([0, 1, 2, 6, 7, 10])\n assert np.all(transform.constrained_dof_indices == expected)","def magnetisation(field):\n norm_field = df.Field(field.mesh, dim=1, value=(field.norm.array != 0))\n volume = df.integral(norm_field * df.dV, direction='xyz')\n return df.integral(field * df.dV / volume, direction='xyz')","def validate_pmf(pmf, ops):\n validate_normalization(pmf, ops)\n validate_probabilities(pmf, ops)\n return True","def diwire_dfm(pl):\n\t# check angle\n\ttake3 = takeNGenerator(pl.points, 3)\n\tvalid = reduce(lambda flag, p: flag and (getAngle(*p) <= 135), take3, True)\n\t# check distance\n\ttake2 = takeNGenerator(pl.points, 2)\n\tvalid = reduce(lambda flag, p: flag and (\n\t\tgetDistance(*p) >= 12), take2, valid)\n\tif valid:\n\t\treturn True\n\telse:\n\t\treturn False","def _determine_extra_angles(self, angle_force, reference_topology, growth_indices):\n from simtk import openmm\n import itertools\n from openeye import oechem, oeomega\n\n if len(growth_indices)==0:\n return\n angle_force_constant = 400.0*unit.kilojoules_per_mole/unit.radians**2\n atoms = list(reference_topology.atoms())\n growth_indices = list(growth_indices)\n #get residue from first atom\n residue = atoms[growth_indices[0].idx].residue\n try:\n oemol = FFAllAngleGeometryEngine._oemol_from_residue(residue)\n except Exception as e:\n print(\"Could not generate an oemol from the residue.\")\n print(e)\n\n #get the omega geometry of the molecule:\n\n omega = oeomega.OEOmega()\n omega.SetMaxConfs(1)\n omega.SetStrictStereo(False) #TODO: fix stereochem\n omega(oemol)\n\n #we now have the residue as an oemol. Time to find the relevant angles.\n #There's no equivalent to OEGetTorsions, so first find atoms that are relevant\n #TODO: find out if that's really true\n aromatic_pred = oechem.OEIsAromaticAtom()\n heavy_pred = oechem.OEIsHeavy()\n angle_criteria = oechem.OEAndAtom(aromatic_pred, heavy_pred)\n\n #get all heavy aromatic atoms:\n #TODO: do this more efficiently\n heavy_aromatics = list(oemol.GetAtoms(angle_criteria))\n for atom in heavy_aromatics:\n #bonded_atoms = [bonded_atom for bonded_atom in list(atom.GetAtoms()) if bonded_atom in heavy_aromatics]\n bonded_atoms = list(atom.GetAtoms())\n for angle_atoms in itertools.combinations(bonded_atoms, 2):\n angle = oechem.OEGetAngle(oemol, angle_atoms[0], atom, angle_atoms[1])\n atom_indices = [angle_atoms[0].GetData(\"topology_index\"), atom.GetData(\"topology_index\"), angle_atoms[1].GetData(\"topology_index\")]\n angle_radians = angle*unit.radian\n growth_idx = self._calculate_growth_idx(atom_indices, growth_indices)\n #If this is a CustomAngleForce, we need to pass the parameters as a list, and it will have the growth_idx parameter.\n #If it's a regular HarmonicAngleForce, there is no growth_index and the parameters are passed separately.\n if isinstance(angle_force, openmm.CustomAngleForce):\n angle_force.addAngle(atom_indices[0], atom_indices[1], atom_indices[2], [angle_radians, angle_force_constant, growth_idx])\n elif isinstance(angle_force, openmm.HarmonicAngleForce):\n angle_force.addAngle(atom_indices[0], atom_indices[1], atom_indices[2], angle_radians, angle_force_constant)\n else:\n raise ValueError(\"Angle force must be either CustomAngleForce or HarmonicAngleForce\")\n return angle_force","def test_norm_compact_axis_angle():\n a = np.array([np.pi, 0.0, 0.0])\n n = pr.norm_compact_axis_angle(a)\n assert_array_almost_equal(a, n)\n\n a = np.array([0.0, np.pi, 0.0])\n n = pr.norm_compact_axis_angle(a)\n assert_array_almost_equal(a, n)\n\n a = np.array([0.0, 0.0, np.pi])\n n = pr.norm_compact_axis_angle(a)\n assert_array_almost_equal(a, n)\n\n random_state = np.random.RandomState(0)\n for _ in range(5):\n a = pr.random_compact_axis_angle(random_state)\n axis = a / np.linalg.norm(a)\n angle = random_state.uniform(-20.0, -10.0 + 2.0 * np.pi)\n a = axis * angle\n n = pr.norm_compact_axis_angle(a)\n for angle_offset in np.arange(0.0, 10.1 * np.pi, 2.0 * np.pi):\n a = axis * (angle + angle_offset)\n n2 = pr.norm_compact_axis_angle(a)\n assert_array_almost_equal(n, n2)","def backward_phi(self):\n for f in self.component_fields:\n f.require_grid_space()","def isAcute(trpl):\n vd = vectorFormat(trpl)\n if angle_between(*vd) < np.pi/2:\n return True\n else:\n return False","def mod_check(x, y):\r\n if (as_tensor_variable(x).dtype in complex_dtypes or\r\n as_tensor_variable(y).dtype in complex_dtypes):\r\n # Currently forbidden.\r\n raise scal.Mod.complex_error\r\n else:\r\n return mod(x, y)","def test_norm_axis_angle():\n a = np.array([1.0, 0.0, 0.0, np.pi])\n n = pr.norm_axis_angle(a)\n assert_array_almost_equal(a, n)\n\n a = np.array([0.0, 1.0, 0.0, np.pi])\n n = pr.norm_axis_angle(a)\n assert_array_almost_equal(a, n)\n\n a = np.array([0.0, 0.0, 1.0, np.pi])\n n = pr.norm_axis_angle(a)\n assert_array_almost_equal(a, n)\n\n random_state = np.random.RandomState(0)\n for _ in range(5):\n a = pr.random_axis_angle(random_state)\n angle = random_state.uniform(-20.0, -10.0 + 2.0 * np.pi)\n a[3] = angle\n n = pr.norm_axis_angle(a)\n for angle_offset in np.arange(0.0, 10.1 * np.pi, 2.0 * np.pi):\n a[3] = angle + angle_offset\n n2 = pr.norm_axis_angle(a)\n assert_array_almost_equal(n, n2)","def assert_no_error(self): \r\n Nx = self['Nx']\r\n Nt = self.m.Nt\r\n L, T = self.problem['L T'.split()]\r\n L = L/2 # only half the domain used (symmetry)\r\n x = np.linspace(0, L, Nx+1) # Mesh points in space \r\n t = np.linspace(0, T, Nt+1) # Mesh points in time\r\n \r\n for n in range(len(t)):\r\n u_e = self.problem.u_exact(x, t[n])\r\n diff = np.abs(self.f.u[n,:] - u_e).max()\r\n print 'diff:', diff\r\n tol = 1E-13\r\n assert diff < tol","def _is_trivial_angle(rad: float, atol: float) -> bool:\n return abs(rad) < atol or abs(abs(rad) - np.pi / 4) < atol","def assertAngle(self, angle: float):\n assert isinstance(angle, float), f\"bad angle instance, type of angle is {type(angle)}\"\n assert -180 <= angle <= 180","def test_fractional_bondorder_from_molecule(\n self,\n get_molecule,\n k_torsion_interpolated,\n k_bond_interpolated,\n length_bond_interpolated,\n central_atoms,\n ):\n mol = get_molecule()\n forcefield = ForceField(\n get_data_file_path(\"test_forcefields/test_forcefield.offxml\"), xml_ff_bo\n )\n topology = Topology.from_molecules(mol)\n\n omm_system = forcefield.create_openmm_system(\n topology,\n charge_from_molecules=[mol],\n partial_bond_orders_from_molecules=[mol],\n )\n\n # Verify that the assigned bond parameters were correctly interpolated\n off_bond_force = [\n force\n for force in omm_system.getForces()\n if isinstance(force, openmm.HarmonicBondForce)\n ][0]\n\n for idx in range(off_bond_force.getNumBonds()):\n params = off_bond_force.getBondParameters(idx)\n\n atom1, atom2 = params[0], params[1]\n atom1_mol, atom2_mol = central_atoms\n\n if ((atom1 == atom1_mol) and (atom2 == atom2_mol)) or (\n (atom1 == atom2_mol) and (atom2 == atom1_mol)\n ):\n k = params[-1]\n length = params[-2]\n assert_almost_equal(k / k.unit, k_bond_interpolated)\n assert_almost_equal(length / length.unit, length_bond_interpolated)\n\n # Verify that the assigned torsion parameters were correctly interpolated\n off_torsion_force = [\n force\n for force in omm_system.getForces()\n if isinstance(force, openmm.PeriodicTorsionForce)\n ][0]\n\n for idx in range(off_torsion_force.getNumTorsions()):\n params = off_torsion_force.getTorsionParameters(idx)\n\n atom2, atom3 = params[1], params[2]\n atom2_mol, atom3_mol = central_atoms\n\n if ((atom2 == atom2_mol) and (atom3 == atom3_mol)) or (\n (atom2 == atom3_mol) and (atom3 == atom2_mol)\n ):\n k = params[-1]\n assert_almost_equal(k / k.unit, k_torsion_interpolated)","def test_get_principal_moments_of_inertia(self):\n numbers = [6, 6, 8, 1, 1, 1, 1, 1, 1]\n coords = np.array([[1.235366, -0.257231, -0.106315],\n [0.083698, 0.554942, 0.046628],\n [-1.210594, -0.239505, -0.021674],\n [0.132571, 1.119728, 0.987719],\n [0.127795, 1.278999, -0.769346],\n [-1.272620, -0.962700, 0.798216],\n [-2.074974, 0.426198, 0.055846],\n [-1.275744, -0.785745, -0.965493],\n [1.241416, -0.911257, 0.593856]], np.float64)\n principal_moments_of_inertia = get_principal_moments_of_inertia(coords=coords, numbers=numbers)[0]\n expected_principal_moments_of_inertia = [60.98026894, 53.83156297, 14.48858465]\n for moment, expected_moment in zip(principal_moments_of_inertia, expected_principal_moments_of_inertia):\n self.assertAlmostEqual(moment, expected_moment)\n\n symbols = ['N', 'O', 'O'] # test a linear molecule\n coords = np.array([[0.000000, 0.000000, 1.106190],\n [0.000000, 0.000000, -0.072434],\n [0.000000, 0.000000, -1.191782]], np.float64)\n with self.assertRaises(InputError):\n get_principal_moments_of_inertia(coords=coords, numbers=numbers)\n principal_moments_of_inertia, axes = get_principal_moments_of_inertia(coords=coords, symbols=symbols)\n expected_principal_moments_of_inertia = [39.4505153, 39.4505153, 0.0]\n expected_axes = [[1, 0, 0], [0, 1, 0], [0, 0, 1]]\n for moment, expected_moment in zip(principal_moments_of_inertia, expected_principal_moments_of_inertia):\n self.assertAlmostEqual(moment, expected_moment)\n for axis, expected_axis in zip(axes, expected_axes):\n for entry, expected_entry in zip(axis, expected_axis):\n self.assertAlmostEqual(entry, expected_entry)\n self.assertIsInstance(principal_moments_of_inertia, tuple)\n self.assertIsInstance(axes, tuple)","def test_angle_angle_explicit(pcff):\n\n expected = {\n \"K\": \"3.5475\",\n \"reference\": \"1\",\n \"Theta10\": \"107.6600\",\n \"Theta20\": \"105.8500\",\n }\n\n i = \"h\"\n j = \"c\"\n k = \"h\"\n l = \"n+\" # noqa: E741\n ptype, key, form, parameters = pcff.angle_angle_parameters(i, j, k, l)\n assert ptype == \"explicit\"\n assert key == (\"h\", \"c\", \"h\", \"n+\")\n assert parameters == expected","def test_t(self):\n assert np.isclose(self.stepper.t, self.final_t)","def test_charge_increment_model_one_less_ci_than_tagged_atom(self):\n # Make a FF from each OFFXML string\n file_path = get_data_file_path(\"test_forcefields/test_forcefield.offxml\")\n ff1 = ForceField(file_path, xml_charge_increment_model_ff_one_less_ci)\n del ff1._parameter_handlers[\"ToolkitAM1BCC\"]\n ff2 = ForceField(file_path, xml_charge_increment_model_ff_no_missing_cis)\n del ff2._parameter_handlers[\"ToolkitAM1BCC\"]\n top = Topology.from_molecules([create_ethanol()])\n # Make a system from each FF\n sys1 = ff2.create_openmm_system(top)\n sys2 = ff2.create_openmm_system(top)\n # Extract the nonbonded force from each system\n nonbonded_force1 = [\n force\n for force in sys1.getForces()\n if isinstance(force, openmm.NonbondedForce)\n ][0]\n nonbonded_force2 = [\n force\n for force in sys2.getForces()\n if isinstance(force, openmm.NonbondedForce)\n ][0]\n\n # Ensure that the systems both have the correct charges assigned\n expected_charges = [\n 0.17,\n -0.18,\n -0.04,\n 0.01,\n 0.01,\n 0.01,\n 0.01,\n 0.01,\n 0.0,\n ] * openmm_unit.elementary_charge\n for idx, expected_charge in enumerate(expected_charges):\n charge1, _, _ = nonbonded_force1.getParticleParameters(idx)\n charge2, _, _ = nonbonded_force2.getParticleParameters(idx)\n assert (\n abs(charge1 - expected_charge) < 1.0e-6 * openmm_unit.elementary_charge\n )\n assert charge1 == charge2","def check_extension(sim_par, base_mof, mobile_mof, emap, emap_atom_list, new_structure):\n emap_max = [emap[-1][0], emap[-1][1], emap[-1][2]]\n emap_min = [emap[0][0], emap[0][1], emap[0][2]]\n\n energy_limit = sim_par['atom_energy_limit']\n ext_cut_off = sim_par['ext_cut_off']\n\n rotation_info = new_structure['rotation']\n first_point = new_structure['first_point']\n translation_vector = Coor(new_structure['translation_vector'])\n\n Quat = Quaternion([0, 1, 1, 1])\n\n packing_factor = Packing.factor(mobile_mof.uc_size, ext_cut_off)\n uc_vectors = Packing.uc_vectors(mobile_mof.uc_size, mobile_mof.uc_angle)\n trans_vec = Packing.translation_vectors(packing_factor, uc_vectors)\n packed_coors = Packing.uc_coors(trans_vec, packing_factor, uc_vectors, mobile_mof.atom_coors)\n\n x_angle = rotation_info[0]\n y_angle = rotation_info[1]\n z_angle = rotation_info[2]\n\n collision = False\n for unit_cell in packed_coors:\n\n if not collision:\n\n for coor_index, coor in enumerate(unit_cell):\n\n if not collision:\n\n new_coor = Coor(coor)\n Q = Quaternion([1, new_coor.x, new_coor.y, new_coor.z]) # Might be a better way to do this\n Q = Quat.rotation(Q.xyz(), [0, 0, 0], [1, 0, 0], x_angle)\n Q = Quat.rotation(Q.xyz(), [0, 0, 0], [0, 1, 0], y_angle)\n Q = Quat.rotation(Q.xyz(), [0, 0, 0], [0, 0, 1], z_angle)\n new_coor = Coor(Q.xyz())\n\n new_coor += translation_vector\n pbc_coor = new_coor.pbc(base_mof.uc_size, base_mof.uc_angle, base_mof.frac_ucv)\n\n atom_name = mobile_mof.atom_names[coor_index]\n atom_index = energy_map_atom_index(atom_name, emap_atom_list)\n\n point_energy = trilinear_interpolate(pbc_coor.xyz(), atom_index, emap, emap_max, emap_min)\n\n if point_energy < energy_limit:\n continue\n else:\n collision = True\n break\n else:\n break\n else:\n break\n\n return collision","def search_base_angles(self, motor_positions):\n\n # Errore nelle soluzioni\n err = [0, 0, 0]\n\n # Angolo di inizio ricerca\n # Se gia' eseguita una conversione suo i valori precedenti\n if self.isLastAnglesValid:\n self.alpha_start = list(self.alpha)\n else:\n # Angolo minimo di partenza ( -alpha_limit )\n # TO_CHECK: perche' parto da una configurazione sicuramente errata? -10?\n self.alpha_start = [self.alpha_limit_r, self.alpha_limit_r, self.alpha_limit_r]\n\n # Angoli presunti\n # self.temp = list(self.alpha_start)\n alpha = list(self.alpha_start)\n\n # Altezze reali degli attuatori\n height = [self.real_height + motor_positions[0],\n self.real_height + motor_positions[1],\n self.real_height + motor_positions[2]]\n\n # Trovo il mediano tra 0-1-2\n '''\n if any([all([motor_positions[0] > motor_positions[1], motor_positions[0] < motor_positions[2]]),\n all([motor_positions[0] < motor_positions[1], motor_positions[0] > motor_positions[2]])]):\n is_0_median = True\n is_1_median = False\n is_2_median = False\n else:\n is_0_median = False\n if any([all([motor_positions[1] > motor_positions[2], motor_positions[1] < motor_positions[0]]),\n all([motor_positions[1] < motor_positions[2], motor_positions[1] > motor_positions[0]])]):\n is_0_median = False\n is_1_median = True\n is_2_median = False\n else:\n is_1_median = False\n if any([all([motor_positions[2] > motor_positions[1], motor_positions[2] < motor_positions[0]]),\n all([motor_positions[2] < motor_positions[1], motor_positions[2] > motor_positions[0]])]):\n is_0_median = False\n is_1_median = False\n is_2_median = True\n else:\n is_2_median = False\n '''\n\n # Incrementi degli angoli\n # TO_CHECK: perche' quattro? L'ultimo e' di backup?\n step_alpha_base = 0.1 * Kinematic.M_TO_RAD\n step_alpha = [step_alpha_base, step_alpha_base, step_alpha_base]\n\n # Numero di cicli eseguiti\n self.cycles = 0\n\n # Calcolo la condizione iniziale\n d1 = self.distance_12(alpha, height)\n err[0] = d1 - self.base_length\n step_alpha[1] = err[0] * self.ke * step_alpha_base\n\n d2 = self.distance_23(alpha, height)\n err[1] = d2 - self.base_length\n step_alpha[2] = err[1] * self.ke * step_alpha_base\n\n d3 = self.distance_13(alpha, height)\n err[2] = d3 - self.base_length\n step_alpha[0] = err[2] * self.ke * step_alpha_base\n\n i = 0\n while i < self.cycle_limit:\n\n i += 1\n\n # Incremento alfa1 ed azzero alfa2\n alpha[0] += step_alpha[0]\n alpha[1] = self.alpha_start[1]\n\n j = 0\n\n while j < self.cycle_limit:\n\n j += 1\n\n # self.next_iteration(alpha, step_alpha, i, j, n, err)\n self.cycles += 1\n\n if self.cycles > self.cycle_limit:\n logging.error(\"Maximum number of cycles executed, no solution found!\")\n return False\n\n # Incremento alfa1 ed azzero alfa2\n alpha[1] += step_alpha[1]\n\n # Se supero l'angolo limite\n # Partendo da -10 ( -0.17 ), non devo superare 10 ( 0.17 )\n if alpha[1] > -self.alpha_limit_r:\n\n # Angolo non trovato\n step_alpha[1] = step_alpha_base\n step_alpha[0] = err[0] * step_alpha_base * self.ke\n self.alpha_start[1] = -self.alpha_limit_r - 2 * step_alpha[1]\n break\n\n d1 = self.distance_12(alpha, height)\n err[0] = d1 - self.base_length\n step_alpha[1] = err[0] * self.ke * step_alpha_base\n\n if abs(err[0]) < self.err_limit:\n\n # Trovato il minimo\n self.alpha_start[1] = alpha[1]\n step_alpha[1] = step_alpha_base\n\n n = 0\n while n < self.cycle_limit:\n\n n += 1\n\n # self.next_iteration(alpha, step_alpha, i, j, n, err)\n self.cycles += 1\n\n if self.cycles > self.cycle_limit:\n logging.error(\"Maximum number of cycles executed, no solution found!\")\n return False\n\n alpha[2] += step_alpha[2]\n d2 = self.distance_23(alpha, height)\n err[1] = d2 - self.base_length\n step_alpha[2] = err[1] * self.ke * step_alpha_base\n\n if abs(err[1]) < self.err_limit:\n\n step_alpha[2] = step_alpha_base\n d3 = self.distance_13(alpha, height)\n err[2] = d3 - self.base_length\n step_alpha[0] = err[2] * self.ke * step_alpha_base\n\n if abs(err[2]) < self.err_limit:\n\n # Trovatas la soluzione\n self.alpha = list(alpha)\n return True\n\n # NEXT j!!!\n break\n\n # Next i!!!\n break","def alchemical_forces(self):\n return self._cpp_obj._forces * self._cpp_obj.norm_value","def test_integrate_wontfix(self):\n ans_flam = 8.8608168e-09 * (u.erg / (u.cm * u.cm * u.s))\n assert_quantity_allclose(\n self.sp.integrate(wavelengths=self.w, flux_unit='flam',\n integration_type='analytical'), ans_flam)","def test_non_integral_validation(self):","def test_non_integral_validation(self):","def is_valid(self):\n posit1 = (self.mean_v > 0) & (self.kappa_y > 0) & (self.eta_y > 0)\n posit2 = (self.kappa_s > 0) & (self.eta_s > 0)\n return posit1 & posit2 & self.feller()","def _validate_axes(self):\n if not (\n np.abs(self.axis_u.dot(self.axis_v) < 1e-6)\n and np.abs(self.axis_v.dot(self.axis_w) < 1e-6)\n and np.abs(self.axis_w.dot(self.axis_u) < 1e-6)\n ):\n raise ValueError(\"axis_u, axis_v, and axis_w must be orthogonal\")\n return True","def modify_openmm_forces(self, *args, **kwargs):\n raise NotImplementedError()","def validate_magvar(mv):\n result = VALID\n mag_var = None\n try:\n mag_var = float(mv)\n if (mag_var > 360) or (mag_var < -360):\n result = NOT_VALID\n except ValueError:\n try:\n prefix = mv[0]\n if REGEX_MAGVAR_DD.match(mv[1:]): # Check if there are only numbers > 0, eg. 1.5, not -1.5\n mag_var = float(mv[1:])\n if prefix == 'W':\n result = -mag_var\n elif prefix == 'E':\n result = mag_var\n else:\n result = NOT_VALID\n else:\n result = NOT_VALID\n\n if (mag_var != None) and ((mag_var > 360) or (mag_var < -360)):\n result = NOT_VALID \n \n except ValueError:\n result = NOT_VALID\n mag_var = None\n\n return result, mag_var","def test_norm_angle():\n random_state = np.random.RandomState(0)\n a_norm = random_state.uniform(-np.pi, np.pi, size=(100,))\n for b in np.linspace(-10.0 * np.pi, 10.0 * np.pi, 11):\n a = a_norm + b\n assert_array_almost_equal(pr.norm_angle(a), a_norm)\n\n assert_almost_equal(pr.norm_angle(-np.pi), np.pi)\n assert_almost_equal(pr.norm_angle(np.pi), np.pi)","def test_run_mantel_correlogram_invaid_input(self):\r\n self.assertRaises(ValueError, run_mantel_correlogram, [self.fp1],\r\n [self.dm1, self.dm3], self.num_perms, None, self.alpha)","def comp_axes(self, machine, N0=None):\n if self.time is None and N0 is None:\n raise InputError(\"ERROR: time and N0 can't be both None\")\n\n # Get machine pole pair number\n p = machine.get_pole_pair_number()\n\n # Get electrical fundamental frequency\n f_elec = self.comp_felec()\n\n # Airgap radius\n Rag = machine.comp_Rgap_mec()\n\n # Setup normalizations for time and angle axes\n norm_time = {\n \"elec_order\": f_elec,\n \"mech_order\": f_elec / p,\n }\n if N0 is not None:\n norm_time[\"angle_rotor\"] = 1 / (360 * N0 / 60)\n\n norm_angle = {\"space_order\": p, \"distance\": 1 / Rag}\n\n # Create time axis\n if self.time is None:\n # Create time axis as a DataLinspace\n Time = DataLinspace(\n name=\"time\",\n unit=\"s\",\n initial=0,\n final=60 / N0 * self.Nrev,\n number=self.Nt_tot,\n include_endpoint=False,\n normalizations=norm_time,\n )\n else:\n # Load time data\n time = self.time.get_data()\n self.Nt_tot = len(time)\n Time = Data1D(name=\"time\", unit=\"s\", values=time, normalizations=norm_time)\n\n # Create angle axis\n if self.angle is None:\n # Create angle axis as a DataLinspace\n Angle = DataLinspace(\n name=\"angle\",\n unit=\"rad\",\n initial=0,\n final=2 * pi,\n number=self.Na_tot,\n include_endpoint=False,\n normalizations=norm_angle,\n )\n else:\n # Load angle data\n angle = self.angle.get_data()\n self.Na_tot = len(angle)\n Angle = Data1D(\n name=\"angle\", unit=\"rad\", values=angle, normalizations=norm_angle\n )\n\n return Time, Angle","def update_forces(self):\n\n pass","def test_magmom(convcell_cr: PhonopyAtoms):\n symprec = 1e-5\n symmetry_nonspin = Symmetry(convcell_cr, symprec=symprec)\n atom_map_nonspin = symmetry_nonspin.get_map_atoms()\n len_sym_nonspin = len(symmetry_nonspin.symmetry_operations[\"rotations\"])\n\n spin = [1, -1]\n cell_withspin = convcell_cr.copy()\n cell_withspin.magnetic_moments = spin\n symmetry_withspin = Symmetry(cell_withspin, symprec=symprec)\n atom_map_withspin = symmetry_withspin.get_map_atoms()\n len_sym_withspin = len(symmetry_withspin.symmetry_operations[\"rotations\"])\n\n broken_spin = [1, -2]\n cell_brokenspin = convcell_cr.copy()\n cell_brokenspin = convcell_cr.copy()\n cell_brokenspin.magnetic_moments = broken_spin\n symmetry_brokenspin = Symmetry(cell_brokenspin, symprec=symprec)\n atom_map_brokenspin = symmetry_brokenspin.get_map_atoms()\n len_sym_brokenspin = len(symmetry_brokenspin.symmetry_operations[\"rotations\"])\n\n assert (atom_map_nonspin == atom_map_withspin).all()\n assert (atom_map_nonspin != atom_map_brokenspin).any()\n assert len_sym_nonspin == len_sym_withspin\n assert len_sym_nonspin != len_sym_brokenspin","def test_run_mantel_test_invaid_input(self):\r\n self.assertRaises(ValueError, run_mantel_test, 'mantel',\r\n [self.fp1,\r\n self.fp2], [\r\n self.dm1], self.num_perms, 'two sided',\r\n None, self.alpha)","def test_abs_magnitude_graph_missing_velocity_returns_exception():\n from space_rocks.views.plot_magnitude import graph_abs_magnitude\n\n test_mag = [1, 2, 3, 4, 5]\n test_neo_names = [\"ceres\", \"phobos\", \"deimos\", \"asteroid x\", \"it was earth all along!!\"]\n\n with pytest.raises(UnknownAxisException):\n graph_abs_magnitude(test_mag, [], test_neo_names)","def test_charge_increment_model_net_charge(self):\n file_path = get_data_file_path(\"test_forcefields/test_forcefield.offxml\")\n ff = ForceField(file_path, xml_charge_increment_model_ff_net_charge)\n del ff._parameter_handlers[\"ToolkitAM1BCC\"]\n\n acetate = create_acetate()\n top = acetate.to_topology()\n\n sys = ff.create_openmm_system(top)\n nonbonded_force = [\n force\n for force in sys.getForces()\n if isinstance(force, openmm.NonbondedForce)\n ][0]\n expected_charges = [\n 0,\n 0.15,\n -0.2,\n -0.95,\n 0,\n 0,\n 0,\n ] * openmm_unit.elementary_charge\n for idx, expected_charge in enumerate(expected_charges):\n charge, _, _ = nonbonded_force.getParticleParameters(idx)\n assert (\n abs(charge - expected_charge) < 1.0e-6 * openmm_unit.elementary_charge\n )","def bode(system, mn=0.001, mx=1000, npts=100, title=\"\", xlim=False, ylim=False, sv=False,\n disp3db=False, lowcut=None, magnitude=True, angle=True, freqaxis=\"rad\"):\n # Condition system input to ensure proper execution\n system = _sys_condition(system, False)\n\n # Condition min and max freq terms\n degrees = False\n if freqaxis.lower().find(\"deg\") != -1: # degrees requested\n degrees = True\n # Scale Degrees to Radians for calculation\n mn = 2 * _np.pi * mn\n mx = 2 * _np.pi * mx\n mn = _np.log10(mn) # find the _exponent value\n mx = _np.log10(mx) # find the _exponent value\n\n # Generate the frequency range to calculate over\n wover = _np.logspace(mn, mx, npts)\n\n # Calculate the bode system\n w, mag, ang = _sig.bode(system, wover)\n\n def _plot(plot_title, y_label):\n _plt.title(plot_title)\n _plt.ylabel(y_label)\n if degrees: # Plot in degrees\n _plt.plot(w / (2 * _np.pi), ang)\n _plt.xlabel(\"Frequency (Hz)\")\n else: # Plot in radians\n _plt.plot(w, ang)\n _plt.xlabel(\"Frequency (rad/sec)\")\n _plt.xscale(\"log\")\n _plt.grid(which=\"both\")\n if xlim:\n _plt.xlim(xlim)\n if ylim:\n _plt.ylim(ylim)\n if sv:\n _plt.savefig(title + \".png\")\n\n # Plot Magnitude\n if magnitude:\n magTitle = \"Magnitude \" + title\n _plot(magTitle, \"Magnitude (DB)\")\n if disp3db:\n _plt.axhline(-3)\n if lowcut is not None:\n _plt.axhline(lowcut)\n _plt.show()\n\n # Plot Angle\n if angle:\n angTitle = \"Angle \" + title\n _plot(angTitle, \"Angle (degrees)\")\n _plt.show()","def check_openmm_requirements(cls, combine_nonbonded_forces: bool) -> None:","def test_calculate_angle():\n r1 = np.array([0, 0, -1])\n r2 = np.array([0, 0, 0])\n r3 = np.array([1, 0, 0])\n\n expected_angle = 90\n calculated_angle = molecool.calculate_angle(r1, r2, r3, degrees = True)\n\n assert expected_angle == calculated_angle","def intf_ANGLE(E):\n if ( not E.The.StackSize() >= 3\n or not inc.point_formatted_LST(E.The,1)\n or not inc.point_formatted_LST(E.The,2)\n or not inc.point_formatted_LST(E.The,3) ):\n print(\"Input Error: angle\")\n print(intf_ANGLE.__doc__)\n return # Without doing much of anything.\n import math\n Cobject= E.The.StackPop()\n #C= map(lambda x:x.val, Cobject.val) # Should now be a list of floats.\n C= [x.val for x in Cobject.val] # Should now be a list of floats.\n Bobject= E.The.StackPop()\n #B= map(lambda x:x.val, Bobject.val) # Should now be a list of floats.\n B= [x.val for x in Bobject.val] # Should now be a list of floats.\n Aobject= E.The.StackPop()\n #A= map(lambda x:x.val, Aobject.val) # Should now be a list of floats.\n A= [x.val for x in Aobject.val] # Should now be a list of floats.\n v1= [ A[0]-B[0], A[1]-B[1], A[2]-B[2] ]\n v2= [ C[0]-B[0], C[1]-B[1], C[2]-B[2] ]\n v1mag= math.sqrt( v1[0]*v1[0] + v1[1]*v1[1] + v1[2]*v1[2] )\n v2mag= math.sqrt( v2[0]*v2[0] + v2[1]*v2[1] + v2[2]*v2[2] )\n try:\n v1norm= [x/v1mag for x in v1]\n v2norm= [x/v2mag for x in v2]\n dotprod= v1norm[0]*v2norm[0] + v1norm[1]*v2norm[1] + v1norm[2]*v2norm[2]\n a= math.acos(dotprod) * 180 / math.pi\n except ZeroDivisionError:\n print(\"The supplied points are not distinct or have some other math problem.\")\n return\n d= objectifier.StackOB_VAL(a) # Can't be just regular Python ints.\n E.The.StackPush(d)","def validate(self, mesh, mod):\n return True","def _assert_validity_of_inputs(self):\n for item in [\"frequency\", \"Dt\", \"gain\", \"gain_imu\", \"gain_marg\"]:\n if isinstance(self.__getattribute__(item), bool):\n raise TypeError(f\"Parameter '{item}' must be numeric.\")\n if not isinstance(self.__getattribute__(item), (int, float)):\n raise TypeError(f\"Parameter '{item}' is not a non-zero number.\")\n if self.__getattribute__(item) <= 0.0:\n raise ValueError(f\"Parameter '{item}' must be a non-zero number.\")\n if self.q0 is not None:\n if not isinstance(self.q0, (list, tuple, np.ndarray)):\n raise TypeError(f\"Parameter 'q0' must be an array. Got {type(self.q0)}.\")\n self.q0 = np.copy(self.q0)\n if self.q0.shape != (4,):\n raise ValueError(f\"Parameter 'q0' must be an array of shape (4,). It is {self.q0.shape}.\")\n if not np.allclose(np.linalg.norm(self.q0), 1.0):\n raise ValueError(f\"Parameter 'q0' must be a versor (norm equal to 1.0). Its norm is equal to {np.linalg.norm(self.q0)}.\")","def _validate_mass(mass):\n if not isinstance(mass, u.unyt_array):\n warnings.warn(\"Masses are assumed to be g/mol\")\n mass *= u.gram / u.mol\n elif mass.units.dimensions != (u.gram / u.mol).units.dimensions:\n warnings.warn(\"Masses are assumed to be g/mol\")\n mass = mass.value * u.gram / u.mol\n else:\n pass\n\n return mass","def validPeriod(period):\r\n try:\r\n i = float(period)\r\n except ValueError:\r\n return False\r\n else:\r\n if i>0:\r\n return True\r\n else:\r\n return False"],"string":"[\n \"def test_FEMM_periodicity_angle():\\n\\n SPMSM_015 = load(join(DATA_DIR, \\\"Machine\\\", \\\"SPMSM_015.json\\\"))\\n\\n assert SPMSM_015.comp_periodicity() == (9, False, 9, True)\\n\\n simu = Simu1(name=\\\"test_FEMM_periodicity_angle\\\", machine=SPMSM_015)\\n\\n # Definition of the enforced output of the electrical module\\n I0_rms = 250 / sqrt(2)\\n Phi0 = 140 * pi / 180 # Maximum Torque Per Amp\\n\\n Id_ref = (I0_rms * exp(1j * Phi0)).real\\n Iq_ref = (I0_rms * exp(1j * Phi0)).imag\\n\\n simu.input = InputCurrent(\\n Id_ref=Id_ref,\\n Iq_ref=Iq_ref,\\n Na_tot=252 * 9,\\n Nt_tot=4 * 9,\\n N0=1000,\\n )\\n\\n # Definition of the magnetic simulation: with periodicity\\n simu.mag = MagFEMM(\\n type_BH_stator=1,\\n type_BH_rotor=1,\\n is_periodicity_a=True,\\n is_periodicity_t=False,\\n nb_worker=cpu_count(),\\n Kmesh_fineness=2,\\n )\\n simu.force = ForceMT()\\n\\n # Definition of the magnetic simulation: no periodicity\\n # Definition of the magnetic simulation: no periodicity\\n simu2 = simu.copy()\\n simu2.mag.is_periodicity_a = False\\n\\n simu2.force = ForceMT()\\n\\n # Run simulations\\n out = Output(simu=simu)\\n simu.run()\\n\\n out2 = Output(simu=simu2)\\n simu2.run()\\n\\n # Plot the result\\n out.mag.B.plot_2D_Data(\\n \\\"time\\\",\\n \\\"angle[0]{°}\\\",\\n data_list=[out2.mag.B],\\n legend_list=[\\\"Periodic\\\", \\\"Full\\\"],\\n save_path=join(save_path, simu.name + \\\"_B_time.png\\\"),\\n is_show_fig=False,\\n **dict_2D\\n )\\n\\n out.mag.B.plot_2D_Data(\\n \\\"angle{°}\\\",\\n \\\"time[1]\\\",\\n data_list=[out2.mag.B],\\n legend_list=[\\\"Periodic\\\", \\\"Full\\\"],\\n save_path=join(save_path, simu.name + \\\"_B_space.png\\\"),\\n is_show_fig=False,\\n **dict_2D\\n )\\n\\n out.force.AGSF.plot_2D_Data(\\n \\\"wavenumber=[0,100]\\\",\\n \\\"time[0]\\\",\\n data_list=[out2.force.AGSF],\\n legend_list=[\\\"Periodic\\\", \\\"Full\\\"],\\n save_path=join(save_path, simu.name + \\\"_P_space_fft.png\\\"),\\n is_show_fig=False,\\n **dict_2D\\n )\\n\\n out.force.AGSF.plot_2D_Data(\\n \\\"freqs\\\",\\n \\\"angle[0]\\\",\\n data_list=[out2.force.AGSF],\\n legend_list=[\\\"Periodic\\\", \\\"Full\\\"],\\n save_path=join(save_path, simu.name + \\\"_P_fft2.png\\\"),\\n is_show_fig=False,\\n **dict_2D\\n )\\n\\n out.mag.Tem.plot_2D_Data(\\n \\\"time\\\",\\n data_list=[out2.mag.Tem],\\n legend_list=[\\\"Periodic\\\", \\\"Full\\\"],\\n save_path=join(save_path, simu.name + \\\"_Tem_time.png\\\"),\\n is_show_fig=False,\\n **dict_2D\\n )\\n\\n out.mag.Phi_wind_stator.plot_2D_Data(\\n \\\"time\\\",\\n \\\"phase\\\",\\n data_list=[out2.mag.Phi_wind_stator],\\n legend_list=[\\\"Periodic\\\", \\\"Full\\\"],\\n save_path=join(save_path, simu.name + \\\"_Phi_wind_stator_time.png\\\"),\\n is_show_fig=False,\\n **dict_2D\\n )\\n\\n # Compare both simu\\n Bflux = out.mag.B\\n arg_list = [\\\"angle\\\"]\\n result = Bflux.get_rphiz_along(*arg_list)\\n Brad = result[\\\"radial\\\"]\\n angle = result[\\\"angle\\\"]\\n\\n Bflux2 = out2.mag.B\\n arg_list = [\\\"angle\\\"]\\n result2 = Bflux2.get_rphiz_along(*arg_list)\\n Brad2 = result2[\\\"radial\\\"]\\n\\n assert_array_almost_equal(Brad, Brad2, decimal=1)\\n\\n return out, out2\",\n \"def test_mag_form_fac_case1():\\n ion = MagneticFormFactor('Fe')\\n formfac, _temp = ion.calc_mag_form_fac()[0], ion.calc_mag_form_fac()[1:]\\n del _temp\\n assert (abs(np.sum(formfac) - 74.155233575216599) < 1e-12)\",\n \"def test_mag_form_fac():\\n ion = MagneticFormFactor('Fe')\\n formfac, _temp = ion.calc_mag_form_fac(q=1.)[0], ion.calc_mag_form_fac(q=1.)[1:]\\n del _temp\\n assert (abs(formfac - 0.932565) < 1e-6)\",\n \"def test_mag_form_fac_case2():\\n ion = MagneticFormFactor('Fe')\\n formfac, _temp = ion.calc_mag_form_fac(qrange=[0, 2])[0], ion.calc_mag_form_fac(qrange=[0, 2])[1:]\\n del _temp\\n assert (abs(np.sum(formfac) - 74.155233575216599) < 1e-12)\",\n \"def test_library_charges_monatomic_ions(self, monatomic_ion, formal_charge):\\n ff = ForceField(\\n get_data_file_path(\\\"test_forcefields/test_forcefield.offxml\\\"),\\n get_data_file_path(\\\"test_forcefields/ion_charges.offxml\\\"),\\n )\\n mol = Molecule.from_smiles(\\\"[{}]\\\".format(monatomic_ion))\\n omm_system = ff.create_openmm_system(mol.to_topology())\\n\\n nonbondedForce = [\\n f for f in omm_system.getForces() if type(f) == NonbondedForce\\n ][0]\\n q, _, _ = nonbondedForce.getParticleParameters(0)\\n assert q == formal_charge\",\n \"def check(self, X):\\n if (np.min(X) < -90.) or (np.max(X) > 90.):\\n print \\\"Warning: X may be defined in degrees instead of radians\\\"\",\n \"def check_force_parameters(self, skipImpropers = False):\\n self.check_bonds(self.bond_force0, self.bond_force1)\\n self.check_angles(self.angle_force0, self.angle_force1)\\n self.check_nonbonded(self.nonbonded_force0, self.nonbonded_force1)\\n self.check_proper_torsions(self.torsion_force0, self.torsion_force1, self.bond_force0, self.bond_force1)\\n if not skipImpropers:\\n self.check_improper_torsions(self.torsion_force0, self.torsion_force1, self.bond_force0, self.bond_force1)\\n logger.info(\\\"Note: skipping degenerate impropers with < 4 atoms.\\\")\",\n \"def test_assign_charges_using_library_charges_by_single_atoms(self):\\n ff = ForceField(\\n get_data_file_path(\\\"test_forcefields/test_forcefield.offxml\\\"),\\n xml_ethanol_library_charges_by_atom_ff,\\n )\\n\\n molecules = [\\n Molecule.from_file(get_data_file_path(\\\"molecules/ethanol.sdf\\\")),\\n Molecule.from_file(get_data_file_path(\\\"molecules/ethanol_reordered.sdf\\\")),\\n ]\\n top = Topology.from_molecules(molecules)\\n omm_system = ff.create_openmm_system(top)\\n nonbondedForce = [\\n f for f in omm_system.getForces() if type(f) == NonbondedForce\\n ][0]\\n expected_charges = [\\n -0.2,\\n -0.1,\\n 0.3,\\n 0.08,\\n -0.02,\\n -0.02,\\n -0.02,\\n -0.01,\\n -0.01,\\n -0.2,\\n 0.3,\\n -0.1,\\n 0.08,\\n -0.02,\\n -0.02,\\n -0.02,\\n -0.01,\\n -0.01,\\n ] * openmm_unit.elementary_charge\\n for particle_index, expected_charge in enumerate(expected_charges):\\n q, _, _ = nonbondedForce.getParticleParameters(particle_index)\\n assert q == expected_charge\",\n \"def test_check_compact_axis_angle():\\n a_list = [0, 0, 0]\\n a = pr.check_compact_axis_angle(a_list)\\n assert_array_almost_equal(a_list, a)\\n assert_equal(type(a), np.ndarray)\\n assert_equal(a.dtype, np.float64)\\n\\n random_state = np.random.RandomState(0)\\n a = pr.norm_vector(pr.random_vector(random_state, 3))\\n a *= np.pi + random_state.randn() * 4.0 * np.pi\\n a2 = pr.check_compact_axis_angle(a)\\n pr.assert_compact_axis_angle_equal(a, a2)\\n assert_greater(np.linalg.norm(a2), 0)\\n assert_greater(np.pi, np.linalg.norm(a2))\\n\\n assert_raises_regexp(\\n ValueError, \\\"Expected axis and angle in array with shape\\\",\\n pr.check_compact_axis_angle, np.zeros(4))\\n assert_raises_regexp(\\n ValueError, \\\"Expected axis and angle in array with shape\\\",\\n pr.check_compact_axis_angle, np.zeros((3, 3)))\",\n \"def test_FEMM_periodicity_time():\\n\\n SPMSM_015 = load(join(DATA_DIR, \\\"Machine\\\", \\\"SPMSM_015.json\\\"))\\n\\n assert SPMSM_015.comp_periodicity() == (9, False, 9, True)\\n\\n simu = Simu1(name=\\\"test_FEMM_periodicity_time\\\", machine=SPMSM_015)\\n\\n # Definition of the enforced output of the electrical module\\n I0_rms = 250 / sqrt(2)\\n Phi0 = 140 * pi / 180 # Maximum Torque Per Amp\\n\\n Id_ref = (I0_rms * exp(1j * Phi0)).real\\n Iq_ref = (I0_rms * exp(1j * Phi0)).imag\\n\\n simu.input = InputCurrent(\\n Id_ref=Id_ref,\\n Iq_ref=Iq_ref,\\n Na_tot=252 * 9,\\n Nt_tot=4 * 9,\\n N0=1000,\\n )\\n\\n # Definition of the magnetic simulation: with periodicity\\n simu.mag = MagFEMM(\\n type_BH_stator=1,\\n type_BH_rotor=1,\\n is_periodicity_a=True,\\n is_periodicity_t=True,\\n nb_worker=cpu_count(),\\n Kmesh_fineness=2,\\n )\\n simu.force = ForceMT()\\n\\n # Definition of the magnetic simulation: no periodicity\\n simu2 = simu.copy()\\n simu2.mag.is_periodicity_t = False\\n\\n # Run simulations\\n out = Output(simu=simu)\\n simu.run()\\n\\n out2 = Output(simu=simu2)\\n simu2.run()\\n\\n # Plot the result\\n out.mag.B.plot_2D_Data(\\n \\\"time\\\",\\n \\\"angle[0]{°}\\\",\\n data_list=[out2.mag.B],\\n legend_list=[\\\"Periodic\\\", \\\"Full\\\"],\\n save_path=join(save_path, simu.name + \\\"_B_time.png\\\"),\\n is_show_fig=False,\\n **dict_2D\\n )\\n\\n out.mag.B.plot_2D_Data(\\n \\\"angle{°}\\\",\\n \\\"time[1]\\\",\\n data_list=[out2.mag.B],\\n legend_list=[\\\"Periodic\\\", \\\"Full\\\"],\\n save_path=join(save_path, simu.name + \\\"_B_space.png\\\"),\\n is_show_fig=False,\\n **dict_2D\\n )\\n\\n out.force.AGSF.plot_2D_Data(\\n \\\"wavenumber=[0,100]\\\",\\n \\\"time[0]\\\",\\n data_list=[out2.force.AGSF],\\n legend_list=[\\\"Periodic\\\", \\\"Full\\\"],\\n save_path=join(save_path, simu.name + \\\"_P_space_fft.png\\\"),\\n is_show_fig=False,\\n **dict_2D\\n )\\n\\n out.force.AGSF.plot_2D_Data(\\n \\\"freqs\\\",\\n \\\"angle[0]\\\",\\n data_list=[out2.force.AGSF],\\n legend_list=[\\\"Periodic\\\", \\\"Full\\\"],\\n save_path=join(save_path, simu.name + \\\"_P_fft2.png\\\"),\\n is_show_fig=False,\\n **dict_2D\\n )\\n\\n out.mag.Tem.plot_2D_Data(\\n \\\"time\\\",\\n data_list=[out2.mag.Tem],\\n legend_list=[\\\"Periodic\\\", \\\"Full\\\"],\\n save_path=join(save_path, simu.name + \\\"_Tem_time.png\\\"),\\n is_show_fig=False,\\n **dict_2D\\n )\\n\\n out.mag.Phi_wind_stator.plot_2D_Data(\\n \\\"time\\\",\\n \\\"phase\\\",\\n data_list=[out2.mag.Phi_wind_stator],\\n legend_list=[\\\"Periodic\\\", \\\"Full\\\"],\\n save_path=join(save_path, simu.name + \\\"_Phi_wind_stator_time.png\\\"),\\n is_show_fig=False,\\n **dict_2D\\n )\\n\\n # Compare both simu with B\\n Bflux = out.mag.B\\n arg_list = [\\\"time\\\"]\\n result = Bflux.get_rphiz_along(*arg_list)\\n Brad = result[\\\"radial\\\"]\\n time = result[\\\"time\\\"]\\n\\n # Check Flux spatio-temporal reconstruction full\\n Bflux2 = out2.mag.B\\n arg_list = [\\\"time\\\"]\\n result2 = Bflux2.get_rphiz_along(*arg_list)\\n Brad2 = result2[\\\"radial\\\"]\\n time = result2[\\\"time\\\"]\\n\\n assert_array_almost_equal(Brad, Brad2, decimal=2)\\n\\n # Compare both simu with AGSF\\n AGSF = out.force.AGSF\\n arg_list = [\\\"time\\\"]\\n result_AGSF = AGSF.get_rphiz_along(*arg_list)\\n Prad = result_AGSF[\\\"radial\\\"]\\n time = result_AGSF[\\\"time\\\"]\\n\\n AGSF2 = out2.force.AGSF\\n arg_list = [\\\"time\\\"]\\n result_AGSF2 = AGSF2.get_rphiz_along(*arg_list)\\n Prad2 = result_AGSF2[\\\"radial\\\"]\\n time = result_AGSF2[\\\"time\\\"]\\n\\n assert_array_almost_equal(Prad / 1000, Prad2 / 1000, decimal=0)\\n\\n return out, out2\",\n \"def comp_angle_magnet(self):\\n Rbo = self.get_Rbo()\\n W0 = self.comp_W0m()\\n Harc = self.comp_H_arc()\\n if self.is_outwards():\\n return float(2 * arctan(W0 / (2 * (Rbo + self.H1 - Harc))))\\n else:\\n return float(2 * arctan(W0 / (2 * (Rbo - self.H1 - Harc))))\\n\\n # if self.W0_is_rad:\\n # return self.W0\\n # else: # Convert W0 from m to rad\\n # Rbo = self.get_Rbo()\\n # return float(2 * arcsin(self.W0 / (2 * Rbo)))\",\n \"def _forces_moments(self, delta):\\n # assert delta.shape == (4,1)\\n da = delta[0]\\n de = delta[1]\\n dt = delta[2]\\n dr = delta[3]\\n\\n e0 = self._state[3]\\n e1 = self._state[4]\\n e2 = self._state[5]\\n e3 = self._state[6]\\n u = self._state[7]\\n v = self._state[8]\\n w = self._state[9]\\n p = self._state[10]\\n q = self._state[11]\\n r = self._state[12]\\n\\n self._Va = np.sqrt(u**2 + v**2 + w**2)\\n self._alpha = np.arctan(1.0*w/u)\\n self._beta = np.arcsin(1.0*v/self._Va)\\n\\n\\n\\n Fg = self.mass*self.gravity*np.array([2*(e1*e3-e2*e0),\\n 2*(e2*e3 + e1*e0),\\n e3**2 + e0**2 - e1**2 - e2**2,\\n ])\\n\\n # Fg = self.mass*self.gravity*np.array([2*(e1*e3 - e2*e0),\\n # 2*(e2*e3 + e1*e0),\\n # e3**2 + e0**2 - e1**2 - e2**2,\\n # ])\\n\\n M_e = 25\\n sig = lambda a: (1+np.exp(-M_e*(a-self.alpha0))+np.exp(M_e*(a+self.alpha0)))/((1+np.exp(-M_e*(a-self.alpha0)))*(1+np.exp(M_e*(a+self.alpha0))))\\n cla = lambda a: (1-sig(a))*(self.C_L_0+self.C_L_alpha*a)+sig(a)*(2*np.sign(a)*np.sin(a)**2*np.cos(a))\\n cda = lambda a: self.C_D_p + (self.C_L_0+self.C_L_alpha*a)**2/(np.pi*self.e*self.AR)\\n\\n cxa = lambda a: -(cda(a)) * np.cos(a) + (cla(a)) * np.sin(a)\\n\\n cxq = lambda a: -self.C_D_q * np.cos(a) +self.C_L_q * np.sin(a)\\n\\n cxde = lambda a: -self.C_D_delta_e * np.cos(a) + self.C_L_delta_e * np.sin(a)\\n\\n cza = lambda a: -(cda(a)) * np.sin(a) - (cla(a)) * np.cos(a)\\n\\n czq = lambda a: -self.C_D_q * np.sin(a) - self.C_L_q * np.cos(a)\\n\\n czde = lambda a: -self.C_D_delta_e * np.sin(a) - self.C_L_delta_e * np.cos(a)\\n\\n c = self.c/(2.0*self._Va)\\n b = self.b/(2.0*self._Va)\\n\\n\\n\\n one = 0.5*self.rho*self._Va**2*self.S_wing\\n # two = np.array([[1,0,0],[0,1,0],[0,0,1]])\\n three = np.array([[cxa(self._alpha)+cxq(self._alpha)*c*q+cxde(self._alpha)*de],\\n [self.C_Y_0+self.C_Y_beta*self._beta+self.C_Y_p*b*p+self.C_Y_r*b*r+self.C_Y_delta_a*da+self.C_Y_delta_r*dr],\\n [cza(self._alpha)+czq(self._alpha)*c*q+czde(self._alpha)*de]])\\n\\n Fa = np.squeeze(three) * one\\n # pdb.set_trace()\\n Fa = Fa.reshape((3,-1))\\n\\n F = Fg + Fa\\n #\\n # print(\\\"Fa:\\\",Fa)\\n\\n Fp = 0.5*self.rho*self.S_prop*self.C_prop*((self.k_motor*dt)**2-self._Va**2)\\n\\n # print(\\\"FP:\\\", Fp)\\n\\n fx = F[0] + Fp\\n # + 0.5*MAV.rho*self._Va**2*MAV.S_wing*(\\\\\\n # +cxa(self._alpha)\\\\\\n # + cxq(self._alpha)*c*q\\\\\\n # + cxde(self._alpha)*de\\n # )\\n\\n fy = F[1]\\n fz = F[2]\\n\\n # Moment time!!!\\n one = 0.5*self.rho*self._Va**2*self.S_wing\\n two = np.array([\\\\\\n [self.b*(self.C_ell_0+self.C_ell_beta*self._beta+self.C_ell_p*b*p+self.C_ell_r*b*r+self.C_ell_delta_a*da+self.C_ell_delta_r*dr)],\\n [self.c*(self.C_m_0+(self.C_m_alpha*self._alpha)+(self.C_m_q*c*q)+(self.C_m_delta_e*de))],\\n [self.b*(self.C_n_0+(self.C_n_beta*self._beta)+(self.C_n_p*b*p)+(self.C_n_r*b*r)+(self.C_n_delta_a*da)+(self.C_n_delta_r*dr))]\\n ])\\n Ma = one * np.squeeze(two)\\n # print(\\\"\\\\nMa:\\\", Ma)\\n # pdb.set_trace()\\n Ma = Ma.reshape((3,-1))\\n\\n size = Ma.shape[1]\\n\\n Mp = np.block([[np.ones(size)*-self.kTp*(self.kOmega*dt)**2],\\n [np.zeros(size)],\\n [np.zeros(size)]\\n ])\\n\\n M = Mp + Ma\\n\\n Mx = M[0]\\n My = M[1]\\n Mz = M[2]\\n\\n # self._forces[0] = fx\\n # self._forces[1] = fy\\n # self._forces[2] = fz\\n # pdb.set_trace()\\n # print(fx, fy, fz, Mx, My, Mz)\\n\\n return np.array([fx, fy, fz, Mx, My, Mz])\",\n \"def test_library_charges_dont_parameterize_molecule_because_of_incomplete_coverage(\\n self,\\n ):\\n molecules = [Molecule.from_file(get_data_file_path(\\\"molecules/toluene.sdf\\\"))]\\n top = Topology.from_molecules(molecules)\\n\\n # The library charges in the FF should not be able to fully cover toluene\\n ff = ForceField(\\n get_data_file_path(\\\"test_forcefields/test_forcefield.offxml\\\"),\\n xml_ethanol_library_charges_by_atom_ff,\\n )\\n # Delete the ToolkitAM1BCCHandler so the molecule won't get charges from anywhere\\n del ff._parameter_handlers[\\\"ToolkitAM1BCC\\\"]\\n with pytest.raises(\\n RuntimeError, match=\\\"Cc1ccccc1 could not be fully assigned charges\\\"\\n ):\\n omm_system = ff.create_openmm_system(top)\\n\\n # If we do NOT delete the ToolkiAM1BCCHandler, then toluene should be assigned some nonzero partial charges.\\n # The exact value will vary by toolkit, so we don't test that here.\\n ff = ForceField(\\n get_data_file_path(\\\"test_forcefields/test_forcefield.offxml\\\"),\\n xml_ethanol_library_charges_by_atom_ff,\\n )\\n omm_system = ff.create_openmm_system(top)\\n nonbondedForce = [\\n f for f in omm_system.getForces() if type(f) == NonbondedForce\\n ][0]\\n for particle_index in range(top.n_atoms):\\n q, _, _ = nonbondedForce.getParticleParameters(particle_index)\\n assert q != 0 * unit.elementary_charge\",\n \"def is_valid_angle(self, theta_step):\\n return not (self.angle % theta_step)\",\n \"def test_fractional_bondorder_invalid_interpolation_method(self):\\n mol = create_ethanol()\\n\\n forcefield = ForceField(\\n get_data_file_path(\\\"test_forcefields/test_forcefield.offxml\\\"), xml_ff_bo\\n )\\n forcefield.get_parameter_handler(\\n \\\"ProperTorsions\\\"\\n )._fractional_bondorder_interpolation = \\\"invalid method name\\\"\\n topology = Topology.from_molecules([mol])\\n\\n # If important, this can be a custom exception instead of a verbose ValidationError\\n with pytest.raises(\\n ValidationError,\\n match=\\\"given=invalid method name\\\",\\n ):\\n forcefield.create_openmm_system(\\n topology,\\n charge_from_molecules=[mol],\\n )\",\n \"def f_theta_omega(angles, times):\\n # gravity = 9.81\\n # arm_length = 0.1 \\n\\n # omega = angles[0]\\n # theta = angles[1]\\n # ftheta = omega\\n # fomega = -(gravity/arm_length) * np.sin(theta)\\n pass\",\n \"def is_pure_magnetic(self):\\n klist = [key for key in self.components if not self.component_is_zero(key)]\\n return all([key.startswith('magnetic') for key in klist])\",\n \"def test_charge_increment_model_forward_and_reverse_ethanol(self):\\n file_path = get_data_file_path(\\\"test_forcefields/test_forcefield.offxml\\\")\\n ff = ForceField(file_path, xml_charge_increment_model_ff_ethanol)\\n del ff._parameter_handlers[\\\"ToolkitAM1BCC\\\"]\\n top = Topology.from_molecules([create_ethanol(), create_reversed_ethanol()])\\n sys = ff.create_openmm_system(top)\\n nonbonded_force = [\\n force\\n for force in sys.getForces()\\n if isinstance(force, openmm.NonbondedForce)\\n ][0]\\n expected_charges = [\\n 0.2,\\n -0.15,\\n -0.05,\\n 0.0,\\n 0.0,\\n 0.0,\\n 0.0,\\n 0.0,\\n 0.0,\\n 0.0,\\n 0.0,\\n 0.0,\\n 0.0,\\n 0.0,\\n 0.0,\\n -0.05,\\n -0.15,\\n 0.2,\\n ] * openmm_unit.elementary_charge\\n for idx, expected_charge in enumerate(expected_charges):\\n charge, _, _ = nonbonded_force.getParticleParameters(idx)\\n assert (\\n abs(charge - expected_charge) < 1.0e-6 * openmm_unit.elementary_charge\\n )\",\n \"def test_float_input_angles(self):\\n decomposer = OneQubitEulerDecomposer(\\\"PSX\\\")\\n input_matrix = np.array(\\n [\\n [0.70710678, 0.70710678],\\n [0.70710678, -0.70710678],\\n ],\\n dtype=np.float64,\\n )\\n (theta, phi, lam) = decomposer.angles(input_matrix)\\n expected_theta = 1.5707963267948966\\n expected_phi = 0.0\\n expected_lam = 3.141592653589793\\n self.assertAlmostEqual(theta, expected_theta)\\n self.assertAlmostEqual(phi, expected_phi)\\n self.assertAlmostEqual(lam, expected_lam)\",\n \"def test_check_axis_angle():\\n a_list = [1, 0, 0, 0]\\n a = pr.check_axis_angle(a_list)\\n assert_array_almost_equal(a_list, a)\\n assert_equal(type(a), np.ndarray)\\n assert_equal(a.dtype, np.float64)\\n\\n random_state = np.random.RandomState(0)\\n a = np.empty(4)\\n a[:3] = pr.random_vector(random_state, 3)\\n a[3] = random_state.randn() * 4.0 * np.pi\\n a2 = pr.check_axis_angle(a)\\n pr.assert_axis_angle_equal(a, a2)\\n assert_almost_equal(np.linalg.norm(a2[:3]), 1.0)\\n assert_greater(a2[3], 0)\\n assert_greater(np.pi, a2[3])\\n\\n assert_raises_regexp(\\n ValueError, \\\"Expected axis and angle in array with shape\\\",\\n pr.check_axis_angle, np.zeros(3))\\n assert_raises_regexp(\\n ValueError, \\\"Expected axis and angle in array with shape\\\",\\n pr.check_axis_angle, np.zeros((3, 3)))\",\n \"def test_float_input_angles_and_phase(self):\\n decomposer = OneQubitEulerDecomposer(\\\"PSX\\\")\\n input_matrix = np.array(\\n [\\n [0.70710678, 0.70710678],\\n [0.70710678, -0.70710678],\\n ],\\n dtype=np.float64,\\n )\\n (theta, phi, lam, gamma) = decomposer.angles_and_phase(input_matrix)\\n expected_theta = 1.5707963267948966\\n expected_phi = 0.0\\n expected_lam = 3.141592653589793\\n expected_gamma = -0.7853981633974483\\n self.assertAlmostEqual(theta, expected_theta)\\n self.assertAlmostEqual(phi, expected_phi)\\n self.assertAlmostEqual(lam, expected_lam)\\n self.assertAlmostEqual(gamma, expected_gamma)\",\n \"def check_nonbonded(self, force0, force1):\\n\\n assert type(force0) == type(force1), \\\"Error: force0 and force1 must be the same type.\\\"\\n assert type(force0) == mm.NonbondedForce, \\\"Error: forces must be NonbondedForces\\\"\\n assert force0.getNumParticles() == force1.getNumParticles(), \\\"Error: Systems have %d and %d particles in NonbondedForce, respectively.\\\" % (force0.getNumParticles(), force1.getNumParticles())\\n\\n n_atoms = force0.getNumParticles()\\n\\n q, sigma, epsilon = force0.getParticleParameters(0)\\n #unit_q, unit_sigma, unit_epsilon = q.unit, sigma.unit, epsilon.unit\\n unit_q = u.elementary_charge\\n unit_sigma = u.angstrom\\n unit_epsilon = u.kilojoule_per_mole\\n\\n for k in range(n_atoms):\\n q0, sigma0, epsilon0 = force0.getParticleParameters(k)\\n q1, sigma1, epsilon1 = force1.getParticleParameters(k)\\n\\n q0, sigma0, epsilon0 = q0 / unit_q, sigma0 / unit_sigma, epsilon0 / unit_epsilon\\n q1, sigma1, epsilon1 = q1 / unit_q, sigma1 / unit_sigma, epsilon1 / unit_epsilon\\n\\n assert compare(q0, q1), \\\"Error: Particle %d has charges of %f and %f, respectively.\\\" % (k, q0, q1)\\n\\n if epsilon0 != 0.:\\n assert compare(sigma0, sigma1), \\\"Error: Particle %d has sigma of %f and %f angstroms, respectively.\\\" % (k, sigma0, sigma1)\\n else:\\n logger.info(\\\"Skipping comparison of sigma (%f, %f) on particle %d because epsilon has values %f, %f kJ/mol\\\" % (sigma0, sigma1, k, epsilon0, epsilon1))\\n\\n assert compare(epsilon0, epsilon1), \\\"Error: Particle %d has epsilon of %f and %f kJ/mol, respectively.\\\" % (k, epsilon0, epsilon1)\\n\\n n_exceptions = force0.getNumExceptions()\\n assert force0.getNumExceptions() == force1.getNumExceptions(), \\\"Error: Systems have %d and %d exceptions in NonbondedForce, respectively.\\\" % (force0.getNumExceptions(), force1.getNumExceptions())\\n\\n i0, i1, qq, sigma, epsilon = force0.getExceptionParameters(0)\\n unit_qq = u.elementary_charge**2\\n unit_sigma = u.angstrom\\n unit_epsilon = u.kilojoule_per_mole\\n\\n dict0, dict1 = {}, {}\\n for k in range(n_exceptions):\\n i0, i1, qq, sigma, epsilon = force0.getExceptionParameters(k)\\n i0, i1 = reorder_bonds(i0, i1)\\n dict0[i0, i1] = ((qq / unit_qq, sigma / unit_sigma, epsilon / unit_epsilon))\\n\\n i0, i1, qq, sigma, epsilon = force1.getExceptionParameters(k)\\n i0, i1 = reorder_bonds(i0, i1)\\n dict1[i0, i1] = ((qq / unit_qq, sigma / unit_sigma, epsilon / unit_epsilon))\\n\\n keys0 = set(dict0.keys())\\n keys1 = set(dict1.keys())\\n logger.info(\\\"Exceptions0 - Exceptions1 = %s\\\" % (keys0.difference(keys1)))\\n logger.info(\\\"Exceptions1 - Exceptions0 = %s\\\" % (keys1.difference(keys0)))\\n assert set(dict0.keys()) == set(dict1.keys()), \\\"Systems have different NonBondedForce Exceptions\\\"\\n\\n for k, parameter_name in enumerate([\\\"qq\\\", \\\"sigma\\\", \\\"epsilon\\\"]):\\n for (i0, i1) in dict0.keys():\\n val0 = dict0[i0, i1][k]\\n val1 = dict1[i0, i1][k]\\n if parameter_name == \\\"sigma\\\" and dict0[i0, i1][2] == 0.0 and dict1[i0, i1][2] == 0.0:\\n continue # If both epsilon parameters are zero, then sigma doesn't matter so skip the comparison.\\n if parameter_name ==\\\"sigma\\\":\\n assert compare(val0, val1), \\\"Error: NonBondedForce Exception, atom (%d, %d) has sigma values of %f and %f angstroms, respectively.\\\" % (i0, i1, parameter_name, val0, val1)\\n elif parameter_name==\\\"qq\\\":\\n assert compare(val0, val1), \\\"Error: NonBondedForce Exception atom (%d, %d) has squared charge values of %f and %f (elementary charge)**2, respectively.\\\" % (i0, i1, val0, val1)\\n else:\\n assert compare(val0, val1), \\\"Error: NonBondedForce Exception, atom (%d, %d) has epsilon values of %f and %f kJ/mol, respectively.\\\" % (i0, i1, val0, val1)\",\n \"def comp_angle_opening_magnet(self):\\n\\n if self.W1 > 0:\\n Rbo = self.get_Rbo()\\n return float(2 * arcsin(self.W1 / (2 * Rbo)))\\n else:\\n return self.comp_angle_magnet()\",\n \"def check_angles(self, force0, force1):\\n\\n assert type(force0) == type(force1), \\\"Error: force0 and force1 must be the same type.\\\"\\n assert type(force0) == mm.HarmonicAngleForce, \\\"Error: forces must be HarmonicAngleForces\\\"\\n\\n n_angles0 = force0.getNumAngles()\\n n_angles1 = force1.getNumAngles()\\n\\n dict0, dict1 = {}, {}\\n\\n i0, i1, i2, theta0, k0 = force0.getAngleParameters(0)\\n #unit_theta = theta0.unit\\n unit_theta = u.degrees\\n #unit_k = k0.unit\\n unit_k = u.kilojoules_per_mole/(u.degrees)**2\\n\\n for k in range(n_angles0):\\n i0, i1, i2, theta0, k0 = force0.getAngleParameters(k)\\n if (k0 / k0.unit) != 0.0: # Skip forces with strength 0.0\\n i0, i1, i2 = reorder_angles(i0, i1, i2)\\n dict0[i0, i1, i2] = ((theta0 / unit_theta, k0 / unit_k))\\n\\n for k in range(n_angles1):\\n i0, i1, i2, theta0, k0 = force1.getAngleParameters(k)\\n if (k0 / k0.unit) != 0.0: # Skip forces with strength 0.0\\n i0, i1, i2 = reorder_angles(i0, i1, i2)\\n dict1[i0, i1, i2] = ((theta0 / unit_theta, k0 / unit_k))\\n\\n keys0 = set(dict0.keys())\\n keys1 = set(dict1.keys())\\n logger.info(\\\"Angles0 - Angles1 = %s\\\" % (keys0.difference(keys1)))\\n logger.info(\\\"Angles1 - Angles0 = %s\\\" % (keys1.difference(keys0)))\\n diff_keys = keys0.symmetric_difference(keys1)\\n assert diff_keys == set(), \\\"Systems have different HarmonicAngleForce entries: extra keys are: \\\\n%s\\\" % diff_keys\\n\\n for k, parameter_name in enumerate([\\\"theta0\\\", \\\"k0\\\"]):\\n for (i0, i1, i2) in dict0.keys():\\n val0 = dict0[i0, i1, i2][k]\\n val1 = dict1[i0, i1, i2][k]\\n if parameter_name=='theta0':\\n assert compare(val0, val1), \\\"Error: Harmonic Angle (%d, %d, %d) has angle values of %f and %f degrees, respectively.\\\" % (i0, i1, i2, val0, val1)\\n else:\\n assert compare(val0, val1), \\\"Error: Harmonic Angle (%d, %d, %d) has force constant values of %f and %f kJ/(mol degree**2), respectively.\\\" % (i0, i1, i2, val0, val1)\",\n \"def isSecondOblateAxis(alpha1, alpha2, beta1, beta2, maxDist, maxTorsAngle): \\n a1 = np.asarray(alpha1)\\n a2 = np.asarray(alpha2)\\n b1 = np.asarray(beta1)\\n b2 = np.asarray(beta2)\\n #lent = alpha1 - beta1\\n adir = a2 - a1\\n bdir = b2 - b1\\n aLength = np.sqrt ( np.dot(adir, adir) )\\n bLength = np.sqrt ( np.dot(bdir, bdir) )\\n DotProdNormed = np.dot(adir, bdir) / ( aLength * bLength ) \\n maxTors = np.cos( np.radians( maxTorsAngle ))\\n if (abs(DotProdNormed) > maxTors):\\n # print beta1, beta2, \\\"not rectangular, angle = \\\", np.arccos(DotProdNormed)\\n return False\\n # print beta1, beta2, \\\"is rectangular.\\\" \\n # find nearest point to alpha mid on the potential beta axis by bisection\\n # midAlpha = [a2 + 0.5 * dAlph for a2, dAlph in zip(alpha2, dirAlpha)]\\n axisDist = minimalDistance(a1, a2, b1, b2)\\n# print \\\"Distance of\\\", a1, \\\"<->\\\", a2, \\\" to \\\", b1, \\\"<->\\\", b2, \\\"is\\\", axisDist\\n #midBeta = [b2 + 0.5 * dBeta for b2, dBeta in zip(beta2, dirBeta)]\\n if axisDist < maxDist:\\n # print b1, \\\"<->\\\", b2, \\\"is possible axis\\\"\\n return True\\n else:\\n # print b1, \\\"<->\\\", b2, \\\"is too far (\\\", axisDist ,\\\") from\\\", a1, \\\"<->\\\", a2, \\\", maximal allowed distance =\\\", maxDist\\n return False\",\n \"def test_axis_angle_from_compact_axis_angle():\\n ca = [0.0, 0.0, 0.0]\\n a = pr.axis_angle_from_compact_axis_angle(ca)\\n assert_array_almost_equal(a, np.array([1.0, 0.0, 0.0, 0.0]))\\n\\n random_state = np.random.RandomState(1)\\n for _ in range(5):\\n ca = pr.random_compact_axis_angle(random_state)\\n a = pr.axis_angle_from_compact_axis_angle(ca)\\n assert_almost_equal(np.linalg.norm(ca), a[3])\\n assert_array_almost_equal(ca[:3] / np.linalg.norm(ca), a[:3])\",\n \"def test_compact_axis_angle():\\n a = np.array([1.0, 0.0, 0.0, 0.0])\\n ca = pr.compact_axis_angle(a)\\n assert_array_almost_equal(ca, np.zeros(3))\\n\\n random_state = np.random.RandomState(0)\\n for _ in range(5):\\n a = pr.random_axis_angle(random_state)\\n ca = pr.compact_axis_angle(a)\\n assert_array_almost_equal(pr.norm_vector(ca), a[:3])\\n assert_almost_equal(np.linalg.norm(ca), a[3])\",\n \"def testCorrectForTwoAtomCellWithoutPeriodicityNEEDED(self):\\n\\t\\texpDist = 0.01*10\\n\\t\\tself._checkExpMatchesActual(expDist)\",\n \"def test_comp_magnetostrictive_tensor_1cell():\\n\\n # Physical quantities\\n dim = 2\\n Nt_tot = 1\\n\\n mu = 1\\n Be = np.array([[[mu / 2, 0]]])\\n He = np.array([[[-1 / 2, 0]]])\\n mue = np.array([[mu]])\\n\\n Me = np.reshape(Be / mue - He, (dim, 1, Nt_tot))\\n\\n alphaij = [[1, 0, 0], [1, 0, 0]]\\n\\n alpha1 = 1\\n alpha2 = 1\\n\\n # Computation\\n tensor = ForceTensor()\\n\\n tensor_comp = tensor.comp_magnetrosctrictive_tensor(\\n mue, Me, Nt_tot, alphaij\\n ) # Should be equal to -alpha1*mu*MM' - alpha2*mu*M²*I2\\n\\n assert tensor_comp[0, 0, 0] == -mu * (alpha1 + alpha2)\\n assert tensor_comp[0, 1, 0] == 0\\n assert tensor_comp[1, 0, 0] == 0\\n assert tensor_comp[1, 1, 0] == -mu * alpha2\\n\\n print(\\\"test_comp_magnetostrictive_tensor succeeded\\\")\\n\\n return True\",\n \"def _validate_mesh(self):\\n if not (np.abs(self.axis_u.dot(self.axis_v) < 1e-6) and #pylint: disable=no-member\\n np.abs(self.axis_v.dot(self.axis_w) < 1e-6) and #pylint: disable=no-member\\n np.abs(self.axis_w.dot(self.axis_u) < 1e-6)): #pylint: disable=no-member\\n raise ValueError('axis_u, axis_v, and axis_w must be orthogonal')\\n return True\",\n \"def check_these(phi, chi, omega):\\n #Calculate the leg position from these angles\\n self.getplatepos(phi, chi, omega)\\n #Make sure the legs are not in fault\\n self.check_limits()\\n return (not any(self.leg_fault))\",\n \"def test_get_partial_charges(self, force_field):\\n ethanol: Molecule = create_ethanol()\\n\\n ethanol_partial_charges = from_openmm(\\n self.get_partial_charges_from_create_openmm_system(ethanol, force_field)\\n )\\n\\n partial_charges = force_field.get_partial_charges(ethanol)\\n\\n assert (\\n ethanol_partial_charges - partial_charges < 1.0e-6 * unit.elementary_charge\\n ).all()\\n assert partial_charges.shape == (ethanol.n_atoms,)\",\n \"def test_Force_Tensor_compforce():\\n\\n # 'axes_dict' input\\n axes_dict = {\\n \\\"Time\\\": [0],\\n \\\"Angle\\\": [0],\\n }\\n\\n # 'output' input\\n\\n # Mesh object\\n\\n mesh = MeshMat()\\n mesh.cell[\\\"triangle3\\\"] = CellMat(nb_node_per_cell=3)\\n mesh.node = NodeMat()\\n\\n mesh.node.add_node(np.array([0, 0]))\\n mesh.node.add_node(np.array([0, 1]))\\n mesh.node.add_node(np.array([1, 0]))\\n\\n nodes_test = np.array([0, 1, 2])\\n mesh.add_cell(nodes_test, \\\"triangle3\\\")\\n\\n # Mag object\\n Time = Data1D(name=\\\"time\\\", values=[0], is_components=True)\\n indices_cell = [0]\\n Indices_Cell = Data1D(name=\\\"indice\\\", values=indices_cell, is_components=True)\\n axis_list = [Time, Indices_Cell]\\n\\n mu = 1\\n\\n B_elem = np.array([[[mu / 2, 0]]])\\n H_elem = np.array([[[1 / 2, 0]]])\\n mu_elem = np.array([[mu]])\\n\\n B_sol = build_solution_vector(\\n field=B_elem,\\n axis_list=axis_list,\\n name=\\\"Magnetic Flux Density\\\",\\n symbol=\\\"B\\\",\\n unit=\\\"T\\\",\\n )\\n H_sol = build_solution_vector(\\n field=H_elem,\\n axis_list=axis_list,\\n name=\\\"Magnetic Field\\\",\\n symbol=\\\"H\\\",\\n unit=\\\"A/m\\\",\\n )\\n mu_sol = build_solution_data(\\n field=mu_elem,\\n axis_list=axis_list,\\n name=\\\"Magnetic Permeability\\\",\\n symbol=\\\"mu\\\",\\n unit=\\\"H/m\\\",\\n )\\n\\n list_solution = [B_sol, H_sol, mu_sol]\\n\\n out_dict[\\\"meshsolution\\\"] = build_meshsolution(\\n list_solution=list_solution,\\n label=\\\"FEMM 2D Magnetostatic\\\",\\n list_mesh=meshFEMM,\\n group=groups,\\n )\",\n \"def check_validity(self,check_derivative=True,verbose=True):\\n is_valid = True\\n if self.f0(0.0)!=0.0:\\n is_valid = False\\n if verbose:\\n print(\\\"DynamicalSystem: Warning: The system does \\\"+\\n \\\"not satisfy f0(0)=0 (f(0)=\\\",self.f0(0.0),\\\")\\\")\\n if self.f1(1.0)!=1.0:\\n is_valid = False\\n if verbose:\\n print(\\\"DynamicalSystem: Warning: The system does \\\"+\\n \\\"not satisfy f0(1)=1 (f1(1)=\\\",self.f1(1.0),\\\")\\\")\\n if self.rho_max<self.rho_min:\\n is_valid = False\\n if verbose:\\n print(\\\"DynamicalSystem: Warning: The system does \\\"+\\n \\\"not satisfy rho_max>=rho_min (rho_min,rho_max=\\\",\\n rho_min,rho_max,\\\")\\\")\\n if check_derivative:\\n # Coarse check if the derivative is bounded below by some d>1\\n # Note it is sufficient to check the restricted ranges given\\n xs0 = np.linspace(0.0,self.rho_max,129)\\n xs1 = np.linspace(self.rho_min,1.0,129)\\n d = np.min(np.concatenate((self.df0(xs0),self.df1(xs1))))\\n if d<=1.0:\\n is_valid = False\\n if verbose:\\n print(\\\"DynamicalSystem: Warning: The system does \\\"+\\n \\\"not satisfy: d>1 (d<=\\\",d,\\\")\\\")\\n return is_valid\",\n \"def check_angle(self):\\n self.find_pixels()\\n alpha_theta=np.deg2rad(70)\\n alpha_phi=np.deg2rad(70)\\n extreme_values=self.compute_extreme_values(alpha_phi, alpha_theta)\\n x=np.linspace(extreme_values[0], extreme_values[1], self.number_of_pix[1])\\n y=np.linspace(extreme_values[2], extreme_values[3], self.number_of_pix[0])\\n phi_0=20\\n phi_0=np.deg2rad(phi_0)\\n j, diff=self.compute_phi(\\\"find_orient.png\\\")\\n print \\\"j=\\\", j\\n print \\\"diff=\\\", diff\",\n \"def test_field():\\n\\n # Using mesh with radius 10 nm (nmag ex. 1)\\n mesh = from_geofile(os.path.join(MODULE_DIR, \\\"sphere1.geo\\\"))\\n S3 = df.VectorFunctionSpace(mesh, \\\"Lagrange\\\", 1)\\n m_function = df.interpolate(df.Constant((1, 0, 0)), S3)\\n m = Field(S3, m_function)\\n\\n demag = Demag()\\n demag.setup(m, Field(df.FunctionSpace(mesh, 'DG', 0), Ms), unit_length=1e-9)\\n\\n # Compute demag field\\n H_demag = demag.compute_field()\\n H_demag.shape = (3, -1)\\n x, y, z = H_demag[0], H_demag[1], H_demag[2]\\n\\n print \\\"Max values in direction:\\\"\\n print \\\"x: %g, y: %g, z: %g\\\" % (max(x), max(y), max(z))\\n print \\\"Min values in direction:\\\"\\n print \\\"x: %g, y: %g, z: %g\\\" % (min(x), min(y), min(z))\\n\\n x, y, z = average(x), average(y), average(z)\\n print \\\"Average values in direction\\\"\\n print \\\"x: %g, y: %g, z: %g\\\" % (x, y, z)\\n\\n # Compute relative erros\\n x = abs((x + 1./3*Ms)/Ms)\\n y = abs(y/Ms)\\n z = abs(z/Ms)\\n\\n print \\\"Relative error:\\\"\\n print \\\"x: %g, y: %g, z: %g\\\" % (x, y, z)\\n assert x < TOL, \\\"x-average is %g, should be -1/3.\\\" % x\\n assert y < TOL, \\\"y-average is %g, should be zero.\\\" % y\\n assert z < TOL, \\\"z-average is %g, should be zero.\\\" % z\",\n \"def read_force_field(ff_file, units=\\\"Angstrom\\\", fragment_id=AtomicData.atomic_number):\\n fh = open(ff_file)\\n line = fh.readline()\\n # read number of atoms\\n nat = int(line.split()[0])\\n # skip comment\\n fh.readline()\\n #\\n atomlist = []\\n atomtypes = []\\n partial_charges = []\\n lattice_vectors = []\\n for i in xrange(nat+3):\\n # read nat atoms and at most 3 lattice vectors\\n line = fh.readline()\\n if not line:\\n # end of file reached\\n break\\n words = line.split()\\n x,y,z = map(float, words[1:4])\\n if units == \\\"Angstrom\\\":\\n x,y,z = map(lambda c: c/AtomicData.bohr_to_angs, [x,y,z])\\n if words[0] == \\\"Tv\\\":\\n lattice_vectors.append( [x,y,z] )\\n continue\\n atno = fragment_id(words[0])\\n atomlist.append((atno, [x,y,z]))\\n atomtypes.append(int(words[4]))\\n if len(words) > 5:\\n # 6th column contains partial charges\\n partial_charges.append( float(words[5]) )\\n else:\\n partial_charges.append( 0.0 ) \\n fh.close()\\n if lattice_vectors == []:\\n print \\\"No lattice vectors found\\\"\\n # no lattice vectors were provided\\n # HACK: By setting a lattice vectors to 0, we tell\\n # the function 'build_force_field' that we do not want\\n # a periodic calculation in this direction.\\n # If all lattice vectors are 0, only the atoms in the central\\n # unit cell are included (number of replica cells == 0)\\n lattice_vectors = [ [0.0, 0.0, 0.0],\\n [0.0, 0.0, 0.0],\\n [0.0, 0.0, 0.0] ]\\n\\n assert len(lattice_vectors) == 3, \\\"Need 3 lattice vectors, got %d!\\\" % len(lattice_vectors)\\n return atomlist, atomtypes, partial_charges, lattice_vectors\",\n \"def test_assign_charges_to_molecule_in_parts_using_multiple_library_charges(self):\\n ff = ForceField(\\n get_data_file_path(\\\"test_forcefields/test_forcefield.offxml\\\"),\\n xml_ethanol_library_charges_in_parts_ff,\\n )\\n\\n molecules = [\\n Molecule.from_file(get_data_file_path(\\\"molecules/ethanol.sdf\\\")),\\n Molecule.from_file(get_data_file_path(\\\"molecules/ethanol_reordered.sdf\\\")),\\n ]\\n top = Topology.from_molecules(molecules)\\n omm_system = ff.create_openmm_system(top)\\n nonbondedForce = [\\n f for f in omm_system.getForces() if type(f) == NonbondedForce\\n ][0]\\n expected_charges = [\\n -0.2,\\n -0.1,\\n 0.3,\\n 0.08,\\n -0.02,\\n -0.02,\\n -0.02,\\n -0.01,\\n -0.01,\\n -0.2,\\n 0.3,\\n -0.1,\\n 0.08,\\n -0.02,\\n -0.02,\\n -0.02,\\n -0.01,\\n -0.01,\\n ] * openmm_unit.elementary_charge\\n for particle_index, expected_charge in enumerate(expected_charges):\\n q, _, _ = nonbondedForce.getParticleParameters(particle_index)\\n assert q == expected_charge\",\n \"def test_get_moment_of_inertia_tensor(self):\\n symbols = ['O', 'C', 'C', 'H', 'H', 'H', 'H', 'H', 'H']\\n coords = np.array([[1.28706525, 0.52121353, 0.04219198],\\n [0.39745682, -0.35265044, -0.63649234],\\n [0.36441173, -1.68197093, 0.08682400],\\n [-0.59818222, 0.10068325, -0.65235399],\\n [0.74799641, -0.48357798, -1.66461710],\\n [0.03647269, -1.54932006, 1.12314420],\\n [-0.31340646, -2.38081353, -0.41122551],\\n [1.36475837, -2.12581592, 0.12433596],\\n [2.16336803, 0.09985803, 0.03295192]], np.float64)\\n tensor = get_moment_of_inertia_tensor(coords=coords, symbols=symbols)\\n expected_tensor = [[50.24197604, -15.43600683, -3.07977736],\\n [-15.43600683, 22.20416597, 2.5935549],\\n [-3.07977736, 2.5935549, 55.49144794]]\\n np.testing.assert_almost_equal(tensor, expected_tensor)\",\n \"def test_fractional_bondorder_multiple_same_mol(self):\\n\\n mol = create_ethanol()\\n mol2 = create_reversed_ethanol()\\n\\n forcefield = ForceField(\\n get_data_file_path(\\\"test_forcefields/test_forcefield.offxml\\\"),\\n xml_ff_bo,\\n )\\n topology = Topology.from_molecules([mol, mol2])\\n\\n with pytest.raises(ValueError):\\n forcefield.create_openmm_system(\\n topology,\\n charge_from_molecules=[mol],\\n partial_bond_orders_from_molecules=[mol, mol2],\\n )\",\n \"def test_conversions_matrix_axis_angle_continuous():\\n for angle in np.arange(3.1, 3.2, 0.01):\\n a = np.array([1.0, 0.0, 0.0, angle])\\n R = pr.matrix_from_axis_angle(a)\\n pr.assert_rotation_matrix(R)\\n\\n a2 = pr.axis_angle_from_matrix(R)\\n pr.assert_axis_angle_equal(a, a2)\\n\\n R2 = pr.matrix_from_axis_angle(a2)\\n assert_array_almost_equal(R, R2)\\n pr.assert_rotation_matrix(R2)\",\n \"def ft_ext_force(self):\\r\\n return self._arm.ft_ext_force\",\n \"def check_proper_torsions(self, force0, force1, bond_force0, bond_force1):\\n\\n assert type(force0) == type(force1), \\\"Error: force0 and force1 must be the same type.\\\"\\n assert type(force0) == mm.PeriodicTorsionForce, \\\"Error: forces must be PeriodicTorsionForce\\\"\\n\\n bond_set0 = get_symmetrized_bond_set(bond_force0)\\n bond_set1 = get_symmetrized_bond_set(bond_force1)\\n\\n # Build list of atoms to help make output more useful\\n atoms0 = [ atom for atom in self.simulation0.topology.atoms() ]\\n atoms1 = [ atom for atom in self.simulation1.topology.atoms() ]\\n\\n\\n # Check torsions for equivalent\\n\\n if force0.getNumTorsions() == 0 and force1.getNumTorsions() == 0:\\n return # Must leave now, otherwise try to access torsions that don't exist.\\n\\n F = force0 if force0.getNumTorsions() > 0 else force1 # Either force0 or force1 is nonempty, so find that one.\\n i0, i1, i2, i3, per, phase, k0 = F.getTorsionParameters(0)\\n #phase_unit, k0_unit = phase.unit, k0.unit\\n k0_unit = u.kilojoules_per_mole\\n phase_unit = u.degrees\\n\\n dict0, dict1 = {}, {}\\n for k in range(force0.getNumTorsions()):\\n i0, i1, i2, i3, per, phase, k0 = force0.getTorsionParameters(k)\\n if not is_proper(i0, i1, i2, i3, bond_set0):\\n continue\\n\\n i0, i1, i2, i3 = reorder_proper_torsions(i0, i1, i2, i3)\\n\\n phase, k0 = phase / phase_unit, k0 / k0_unit\\n if k0 == 0.0:\\n continue\\n\\n if not (i0, i1, i2, i3) in dict0:\\n dict0[i0, i1, i2, i3] = []\\n\\n dict0[i0, i1, i2, i3].append((per, phase, k0))\\n\\n for k in range(force1.getNumTorsions()):\\n i0, i1, i2, i3, per, phase, k0 = force1.getTorsionParameters(k)\\n if not is_proper(i0, i1, i2, i3, bond_set1):\\n continue\\n\\n i0, i1, i2, i3 = reorder_proper_torsions(i0, i1, i2, i3)\\n\\n phase, k0 = phase / phase_unit, k0 / k0_unit\\n if k0 == 0.0:\\n continue\\n\\n if not (i0, i1, i2, i3) in dict1:\\n dict1[i0, i1, i2, i3] = []\\n\\n dict1[i0, i1, i2, i3].append((per, phase, k0))\\n\\n keys0 = set(dict0.keys())\\n keys1 = set(dict1.keys())\\n diff_keys = keys0.symmetric_difference(keys1)\\n\\n logger.info(\\\"Propers0 - Propers1 = %s\\\" % (keys0.difference(keys1)))\\n logger.info(\\\"Propers1 - Propers0 = %s\\\" % (keys1.difference(keys0)))\\n assert diff_keys == set(), \\\"Systems have different (proper) PeriodicTorsionForce entries: extra keys are: \\\\n%s\\\" % diff_keys\\n\\n for (i0, i1, i2, i3) in dict0.keys():\\n # Store strings for printing debug info\\n torsion_atoms0 = '%s - %s - %s - %s' % (atoms0[i0].name, atoms0[i1].name, atoms0[i2].name, atoms0[i3].name )\\n torsion_atoms1 = '%s - %s - %s - %s' % (atoms1[i0].name, atoms1[i1].name, atoms1[i2].name, atoms1[i3].name )\\n\\n # Proceed to check\\n entries0 = dict0[i0, i1, i2, i3]\\n entries1 = dict1[i0, i1, i2, i3]\\n if len(entries0) != len(entries1):\\n print(\\\"Compared torsion involving atoms '%s' with that involving atoms '%s': \\\" % (torsion_atoms0, torsion_atoms1))\\n raise Exception(\\\"Error: (proper) PeriodicTorsionForce entry (atoms %d, %d, %d, %d) has different numbers of terms (%d and %d, respectively).\\\" % (i0, i1, i2, i3, len(entries0), len(entries1)))\\n\\n subdict0 = dict(((per, reduce_precision(phase)), k0) for (per, phase, k0) in entries0)\\n subdict1 = dict(((per, reduce_precision(phase)), k0) for (per, phase, k0) in entries1)\\n\\n if set(subdict0.keys()) != set(subdict1.keys()):\\n print(\\\"Compared torsion involving atoms '%s' with that involving atoms '%s': \\\" % (torsion_atoms0, torsion_atoms1))\\n print(\\\"Keys for system0: '%s'; keys for system1: '%s'\\\" % (subdict0.keys(), subdict1.keys() ) )\\n raise Exception(\\\"Error: (proper) PeriodicTorsionForce entry (atoms %d, %d, %d, %d) has different terms.\\\" % (i0, i1, i2, i3) )\\n\\n for (per, phase) in subdict0.keys():\\n val0 = subdict0[per, phase]\\n val1 = subdict1[per, phase]\\n if not compare(val0, val1):\\n print(\\\"Compared torsion involving atoms '%s' with that involving atoms '%s': \\\" % (torsion_atoms0, torsion_atoms1))\\n raise Exception( \\\"Error: (proper) PeriodicTorsionForce (atoms %d, %d, %d, %d, periodicity %d, phase %f degrees) has barrier height values of %f and %f kJ/mol, respectively.\\\" % (i0, i1, i2, i3, per, phase, val0, val1) )\",\n \"def test_run_mantel_test_no_cdm(self):\\r\\n self.assertRaises(ValueError, run_mantel_test, 'partial_mantel',\\r\\n [self.fp1, self.fp2], [self.dm1,\\r\\n self.dm2], self.num_perms,\\r\\n 'two sided', self.comment, self.alpha)\",\n \"def test_euler_angles_1q_hard_thetas(self, gate):\\n self.check_one_qubit_euler_angles(Operator(gate))\",\n \"def test_maf(self):\\n # Flipping the strand\\n self.assertAlmostEqual(self.g.maf(), 8 / 18)\",\n \"def is_valid(self):\\n return (4 * (self.a ** 3) + 27 * (self.b ** 2)) % self.fp != 0\",\n \"def CalcForce_aeroframe_DEP(V, CoefMatrix, x, rho, g):\\r\\n\\r\\n #Compute aero forces\\r\\n # here x must be of the form (alpha, beta, p, q, r, da, dr, de) (last one punctualy used)\\r\\n # set non dim for p,q,r\\r\\n nonDim=np.ones(7)\\r\\n nonDim[2]=g.b/(2*V)\\r\\n nonDim[3]=g.c/(2*V)\\r\\n nonDim[4]=g.b/(2*V)\\r\\n # F=np.dot(CoefMatrix,x[0:7]) # commented form, modification to account for symmetric drag increase of side slip\\r\\n F=np.zeros((3))\\r\\n M=np.zeros((3))\\r\\n xsym=np.copy(x[0:-1])\\r\\n xsym[1]=abs(xsym[1]) # make beta always positive since derivatives have already correct sign for drag and lift only\\r\\n xsym[-3]=abs(xsym[-3]) # make ailerons deflection always positive for drag increase and lift decrease\\r\\n xsym[-1]=abs(xsym[-1]) # make rudder deflection always positive for drag increase and lift decrease\\r\\n F[0]=np.dot(CoefMatrix[0],xsym)\\r\\n F[1]=np.dot(CoefMatrix[1],x[0:-1]) #side force\\r\\n F[2]=np.dot(CoefMatrix[2],xsym)\\r\\n M=np.dot(CoefMatrix[3:6,:],x[0:-1])\\r\\n# print(\\\"Printing moment coeff\\\")\\r\\n# print(M)\\r\\n\\r\\n \\r\\n #No need to project\\r\\n# alpha=x[0]\\r\\n# beta=x[1]\\r\\n# H=np.array([[math.cos(alpha)*math.sin(beta), -math.cos(alpha)*math.sin(beta), -math.sin(alpha)],[math.sin(beta), math.cos(beta), 0],[math.sin(alpha)*math.cos(beta), -math.sin(alpha)*math.sin(beta), math.cos(alpha)]])\\r\\n if V<=71 :\\r\\n Fbody=np.array([-F[0]-g.Cd0_fl,F[1],-F[2]-g.CL0_fl]) # add alpha=0 coefficients\\r\\n Moment=M+np.array([0,x[-1]*g.Cm_de+g.Cm0_fl,0])\\r\\n else:\\r\\n Fbody=np.array([-F[0]-g.Cd0,F[1],-F[2]-g.CL0]) # add alpha=0 coefficients\\r\\n Moment=M+np.array([0,x[-1]*g.Cm_de+g.Cm0,0])\\r\\n \\r\\n\\r\\n Fbody=0.5*V**2.0*rho*g.S*Fbody\\r\\n Moment=0.5*V**2.0*rho*g.S*g.b*Moment\\r\\n \\r\\n return np.append(Fbody, Moment)\",\n \"def test_force(self):\\n group = hoomd.group.all()\\n\\n # compute forces\\n f = azplugins.restrain.plane(group=group, point=(0,0,0), normal=(1,0,0), k=2.0)\\n hoomd.run(1)\\n np.testing.assert_array_almost_equal(f.forces[0].force, (-2.,0,0))\\n np.testing.assert_array_almost_equal(f.forces[1].force, ( 2.,0,0))\\n np.testing.assert_array_almost_equal(f.forces[2].force, ( 6.,0,0))\\n self.assertAlmostEqual(f.forces[0].energy, 1.)\\n self.assertAlmostEqual(f.forces[1].energy, 1.)\\n self.assertAlmostEqual(f.forces[2].energy, 9.)\\n np.testing.assert_array_almost_equal(f.forces[0].virial, (-2.,0,0,0,0,0))\\n np.testing.assert_array_almost_equal(f.forces[1].virial, (-2.,0,4.,0,0,0))\\n np.testing.assert_array_almost_equal(f.forces[2].virial, (12.,0,0,0,0,0))\\n\\n # change the spring constant\\n f.set_params(k=1.0)\\n hoomd.run(1)\\n np.testing.assert_array_almost_equal(f.forces[0].force, (-1.,0,0))\\n np.testing.assert_array_almost_equal(f.forces[1].force, ( 1.,0,0))\\n np.testing.assert_array_almost_equal(f.forces[2].force, ( 3.,0,0))\\n self.assertAlmostEqual(f.forces[0].energy, 0.5)\\n self.assertAlmostEqual(f.forces[1].energy, 0.5)\\n self.assertAlmostEqual(f.forces[2].energy, 4.5)\\n\\n # shift the plane down\\n f.set_params(point=(-1,0,0))\\n hoomd.run(1)\\n np.testing.assert_array_almost_equal(f.forces[0].force, (-2.,0,0))\\n np.testing.assert_array_almost_equal(f.forces[1].force, ( 0.,0,0))\\n np.testing.assert_array_almost_equal(f.forces[2].force, ( 2.,0,0))\\n self.assertAlmostEqual(f.forces[0].energy, 2.0)\\n self.assertAlmostEqual(f.forces[1].energy, 0.0)\\n self.assertAlmostEqual(f.forces[2].energy, 2.0)\\n\\n # rotate the plane so that only particle 1 is off the line\\n f.set_params(point=(0,0,0), normal=(0,0,1))\\n hoomd.run(1)\\n np.testing.assert_array_almost_equal(f.forces[0].force, (0,0,0))\\n np.testing.assert_array_almost_equal(f.forces[1].force, (0,0,-2))\\n np.testing.assert_array_almost_equal(f.forces[2].force, (0,0,0))\\n self.assertAlmostEqual(f.forces[0].energy, 0.0)\\n self.assertAlmostEqual(f.forces[1].energy, 2.0)\\n self.assertAlmostEqual(f.forces[2].energy, 0.0)\",\n \"def calculate_allowable_angles(self, angular_resolution=0.01, visualize=0, optimized=False):\\n #Could be optimized more, if required.\\n \\n if visualize:\\n pylab.ion() #Turns interaction on (?)\\n print \\\"Calculation started\\\"\\n\\n if angular_resolution < self.ANGULAR_RESOLUTION_MIN:\\n warnings.warn(\\\"Requested too small angular resolution. Using %s\\\" % self.ANGULAR_RESOLUTION_MIN)\\n angular_resolution = self.ANGULAR_RESOLUTION_MIN\\n\\n #We do not need to look at more than the motor step size in phi, since the sample rotational\\n # motor does the rest.\\n self.phi_range = 0.99 * (self.sample_motor_step_size / 2)\\n #Arbitrary max ranges here. TODO: User setting?\\n self.chi_range = pi/8\\n self.omega_range = pi/6\\n\\n #Make the lists\\n self.phi_list = array([-self.phi_range, 0, self.phi_range])\\n self.phi_list = np.append(np.arange(-self.phi_range, self.phi_range, angular_resolution), (self.phi_range) )\\n self.chi_list = np.arange(-self.chi_range, self.chi_range, angular_resolution)\\n self.omega_list = np.arange(-self.omega_range, self.omega_range, angular_resolution)\\n\\n #Create the allowed angle map, all false\\n self.allowed = np.zeros( (self.phi_list.size, self.chi_list.size, self.omega_list.size), dtype=np.bool )\\n\\n #Make sure the limits are calculated\\n self.calculate_leg_xy_limits()\\n\\n\\n #Loop through all the angles\\n for i_phi in range(self.phi_list.size):\\n phi = self.phi_list[i_phi]\\n print 'Calculating phi = %s' % phi\\n was_anything_in_line = False\\n for i_chi in range(self.chi_list.size):\\n chi = self.chi_list[i_chi]\\n was_allowed = False\\n for i_omega in range(self.omega_list.size):\\n omega = self.omega_list[i_omega]\\n\\n #Calcualte the leg position from these angles\\n self.getplatepos(phi, chi, omega)\\n #Make sure the legs are not in fault\\n self.check_limits()\\n allowed = not any(self.leg_fault)\\n #Save it\\n self.allowed[i_phi, i_chi, i_omega] = allowed\\n if optimized:\\n #Check that we have reached an unallowed section, to speed calculation\\n if allowed: was_allowed = True\\n if was_allowed and (not allowed):\\n break #All other omega values in this chi will be false. Exit to the next line\\n #(end of omega loop)\\n\\n if optimized:\\n #Is there anything allowed in this chi line?\\n anything_in_line = any(self.allowed[i_phi, i_chi, :])\\n #Once we reach a completely disallowed line, all others after will be too\\n if anything_in_line: was_anything_in_line = True\\n if was_anything_in_line and (not anything_in_line):\\n break #we don't need to look at the remaining lines.\\n #(end of chi loop)\\n #(end of phi loop)\\n\\n print \\\"Done!\\\"\\n \\n if visualize==1:\\n #2D Animated plot\\n for i_phi in range(self.phi_list.size):\\n phi = self.phi_list[i_phi]\\n #Here we are still in the phi loop\\n if visualize:\\n pylab.figure(0)\\n pylab.imshow(self.allowed[i_phi, :, :], interpolation='nearest', extent=(-self.omega_range, self.omega_range, -self.chi_range, self.chi_range))\\n pylab.xlabel(\\\"Omega\\\")\\n pylab.ylabel(\\\"Chi\\\")\\n pylab.title(\\\"Allowable angles for phi=%s\\\" % phi)\\n pylab.draw()\\n time.sleep(0.2)\\n pylab.draw()\\n time.sleep(1)\\n pylab.ion()\\n \\n\\n if visualize==2:\\n #Single 3D plot of allowed angles.\\n mlab.clf() #Clear figure\\n mlab.contour3d(self.allowed.astype(float), contours=[0.5])\\n mlab.xlabel(\\\"Phi\\\")\\n mlab.ylabel(\\\"Chi\\\")\\n mlab.zlabel(\\\"Omega\\\")\\n mlab.axes()\\n mlab.show()\\n\\n #Done calculating\\n return None\",\n \"def check_doa(geometry, doa):\\n if doa < 0:\\n return False\\n if geometry == \\\"linear\\\" and doa > 180:\\n return False\\n if geometry == \\\"circular\\\" and doa >= 360:\\n return False\\n return True\",\n \"def HFincidentAngle(self,PFC, MHD):\\n xyz = PFC.centers\\n r,z,phi = tools.xyz2cyl(xyz[:,0],xyz[:,1],xyz[:,2])\\n BNorms = MHD.Bfield_pointcloud(PFC.ep, r, z, phi, PFC.powerDir, normal=True)\\n PFC.bdotn = np.multiply(PFC.norms, BNorms).sum(1)\\n return\",\n \"def force_12(alpha, r1, r2, R_particle, eps_particle, k, eps_out, eps_in,\\n fiber_radius, nmin, nmax, kzimax, E0_mod, nmin_sc, nmax_sc, case):\\n\\n dr = 1 / k * 1e-5\\n dz = dr\\n dtheta = 1e-5\\n\\n p1 = dipole_moment(1, r1, r2, R_particle, eps_particle, k, eps_out, eps_in,\\n fiber_radius, nmin, nmax, kzimax,\\n E0_mod, nmin_sc, nmax_sc, case)\\n p1c = p1.conjugate()\\n\\n # Fr\\n if alpha == 0:\\n r1plusdr = r1 + np.array([dr, 0, 0])\\n r1minusdr = r1 - np.array([dr, 0, 0])\\n Eplusr = total_loc_efield(1, r1plusdr, r2, k, case, nmin, nmax, kzimax,\\n fiber_radius, eps_out, eps_in, E0_mod,\\n nmin_sc, nmax_sc, R_particle, eps_particle)\\n Eminusr = total_loc_efield(1, r1minusdr, r2, k, case, nmin, nmax, kzimax,\\n fiber_radius, eps_out, eps_in, E0_mod,\\n nmin_sc, nmax_sc, R_particle, eps_particle)\\n grad_r = (Eplusr - Eminusr) / (2 * dr)\\n\\n return(0.5 * np.dot(p1c, grad_r).real)\\n # Ftheta\\n elif alpha == 1:\\n r1plusdtheta = r1 + np.array([0, dtheta, 0])\\n r1minusdtheta = r1 - np.array([0, dtheta, 0])\\n\\n Eplustheta = total_loc_efield(1, r1plusdtheta, r2, k, case, nmin, nmax, kzimax,\\n fiber_radius, eps_out, eps_in, E0_mod,\\n nmin_sc, nmax_sc, R_particle, eps_particle)\\n Eminustheta = total_loc_efield(1, r1minusdtheta, r2, k, case, nmin, nmax, kzimax,\\n fiber_radius, eps_out, eps_in, E0_mod,\\n nmin_sc, nmax_sc, R_particle, eps_particle)\\n grad_theta = (Eplustheta - Eminustheta) / (r1[0] * 2 * dtheta)\\n\\n return(0.5 * np.dot(p1c, grad_theta).real)\\n # Fz\\n elif alpha == 2:\\n r1plusdz = r1 + np.array([0, 0, dz])\\n r1minusdz = r1 - np.array([0, 0, dz])\\n\\n Eplusz = total_loc_efield(1, r1plusdz, r2, k, case, nmin, nmax, kzimax,\\n fiber_radius, eps_out, eps_in, E0_mod,\\n nmin_sc, nmax_sc, R_particle, eps_particle)\\n Eminusz = total_loc_efield(1, r1minusdz, r2, k, case, nmin, nmax, kzimax,\\n fiber_radius, eps_out, eps_in, E0_mod,\\n nmin_sc, nmax_sc, R_particle, eps_particle)\\n grad_z = (Eplusz - Eminusz) / (2 * dz)\\n\\n return(0.5 * np.dot(p1c, grad_z).real)\\n else:\\n print('alpha is out of range!')\\n return(0)\",\n \"def checkForwardBackwardUnity(self):\\n if round(self.alpha[-1,-1] - self.beta[0, 0], 7) != 0:\\n print('')\\n raise BaumWelchForwardBackwardDifference(self.alpha[-1,-1], self.beta[0,0])\",\n \"def check_improper_torsions(self, force0, force1, bond_force0, bond_force1):\\n\\n assert type(force0) == type(force1), \\\"Error: force0 and force1 must be the same type.\\\"\\n assert type(force0) == mm.PeriodicTorsionForce, \\\"Error: forces must be PeriodicTorsionForce\\\"\\n\\n bond_set0 = get_symmetrized_bond_set(bond_force0)\\n bond_set1 = get_symmetrized_bond_set(bond_force1)\\n\\n if force0.getNumTorsions() == 0 and force1.getNumTorsions() == 0:\\n return # Must leave now, otherwise try to access torsions that don't exist.\\n\\n F = force0 if force0.getNumTorsions() > 0 else force1 # Either force0 or force1 is nonempty, so find that one.\\n i0, i1, i2, i3, per, phase, k0 = F.getTorsionParameters(0)\\n #phase_unit, k0_unit = phase.unit, k0.unit\\n k0_unit = u.kilojoules_per_mole\\n phase_unit = u.degrees\\n\\n dict0, dict1 = {}, {}\\n for k in range(force0.getNumTorsions()):\\n i0, i1, i2, i3, per, phase, k0 = force0.getTorsionParameters(k)\\n if not is_improper(i0, i1, i2, i3, bond_set0):\\n continue\\n\\n i0, i1, i2, i3 = reorder_improper_torsions(i0, i1, i2, i3, bond_set0)\\n\\n phase, k0 = phase / phase_unit, k0 / k0_unit\\n if k0 == 0.0:\\n continue\\n\\n if not (i0, i1, i2, i3) in dict0:\\n dict0[i0, i1, i2, i3] = []\\n\\n dict0[i0, i1, i2, i3].append((per, phase, k0))\\n\\n for k in range(force1.getNumTorsions()):\\n i0, i1, i2, i3, per, phase, k0 = force1.getTorsionParameters(k)\\n if not is_improper(i0, i1, i2, i3, bond_set1):\\n continue\\n\\n i0, i1, i2, i3 = reorder_improper_torsions(i0, i1, i2, i3, bond_set0)\\n\\n phase, k0 = phase / phase_unit, k0 / k0_unit\\n if k0 == 0.0:\\n continue\\n\\n if not (i0, i1, i2, i3) in dict1:\\n dict1[i0, i1, i2, i3] = []\\n\\n dict1[i0, i1, i2, i3].append((per, phase, k0))\\n\\n keys0 = set(dict0.keys())\\n keys1 = set(dict1.keys())\\n diff_keys = keys0.symmetric_difference(keys1)\\n\\n logger.info(\\\"Impropers0 - Impropers1 = %s\\\" % (keys0.difference(keys1)))\\n logger.info(\\\"Impropers1 - Impropers0 = %s\\\" % (keys1.difference(keys0)))\\n assert diff_keys == set(), \\\"Systems have different (improper) PeriodicTorsionForce entries: extra keys are: \\\\n%s\\\" % diff_keys\\n\\n for (i0, i1, i2, i3) in dict0.keys():\\n entries0 = dict0[i0, i1, i2, i3]\\n entries1 = dict1[i0, i1, i2, i3]\\n assert len(entries0) == len(entries1), \\\"Error: (improper) PeriodicTorsionForce entry (%d, %d, %d, %d) has different numbers of terms (%d and %d, respectively).\\\" % (i0, i1, i2, i3, len(entries0), len(entries1))\\n\\n subdict0 = dict(((per, reduce_precision(phase)), k0) for (per, phase, k0) in entries0)\\n subdict1 = dict(((per, reduce_precision(phase)), k0) for (per, phase, k0) in entries1)\\n\\n assert set(subdict0.keys()) == set(subdict1.keys()), \\\"Error: (improper) PeriodicTorsionForce entry (%d, %d, %d, %d) has different terms.\\\" % (i0, i1, i2, i3)\\n\\n for (per, phase) in subdict0.keys():\\n val0 = subdict0[per, phase]\\n val1 = subdict1[per, phase]\\n assert compare(val0, val1), \\\"Error: (improper) PeriodicTorsionForce (atoms %d, %d, %d, %d, periodicity %d, phase %f degrees) has barrier height values of %f and %f kJ/mol, respectively.\\\" % (i0, i1, i2, i3, per, phase, val0, val1)\",\n \"def read_forces(self, fname):\\n outfile = open(fname)\\n lines = outfile.readlines()\\n outfile.close()\\n nats = len(self.atoms)\\n forces = np.zeros((nats, 3), float)\\n infinite_force=\\\"*****\\\"\\n if 'mozyme' in self.str_params['job_type'].lower():\\n for i, line in enumerate(lines):\\n if line.find('FINAL POINT AND DERIVATIVES') != -1:\\n for j in range(nats):\\n gline = lines[i + j + 5]\\n pre_force=gline[8:35]\\n if(infinite_force in pre_force):\\n forces[j] = [999999999.9999,999999999.9999,999999999.9999]\\n else:\\n forces[j] = [float( pre_force[0:9].strip()),float( pre_force[9:18].strip()),float( pre_force[18:27].strip())]\\n else:\\n for i, line in enumerate(lines):\\n if line.find('GRADIENT\\\\n') != -1:\\n for j in range(nats * 3):\\n gline = lines[i + j + 1]\\n pre_force=gline[49:62]\\n if(infinite_force in pre_force):\\n forces[int(j/3), int(j%3)] =999999999.9999\\n else:\\n forces[int(j/3), int(j%3)] = float(pre_force)\\n break\\n#do not change unit for mopac\\n forces *= - (kcal / mol)\\n return forces\",\n \"def test_remove_translational_rotational_dof(positions):\\n class DummyTimeStep:\\n def __init__(self, positions):\\n self.positions = positions\\n self.n_atoms = len(positions)\\n ts = DummyTimeStep(positions=positions)\\n\\n transform = RemoveTransRotDOF(\\n center_atom_idx=0,\\n axis_atom_idx=2,\\n plane_atom_idx=3,\\n axis='z',\\n plane='xz'\\n )\\n ts = transform(ts)\\n\\n # The center atom is at the origin.\\n assert np.allclose(ts.positions[transform._center_atom_idx], 0.0)\\n\\n # The axis atom is on the expected axis.\\n expected_axis_atom_position = transform.axis * np.linalg.norm(\\n positions[transform._axis_atom_idx] - positions[transform._center_atom_idx])\\n assert np.allclose(ts.positions[transform._axis_atom_idx], expected_axis_atom_position)\\n\\n # The plane atom is orthogonal to the plane normal.\\n assert np.allclose(np.dot(ts.positions[transform._plane_atom_idx], transform.plane), 0.0)\\n\\n # The constrained atom indices is correct.\\n expected = np.array([0, 1, 2, 6, 7, 10])\\n assert np.all(transform.constrained_dof_indices == expected)\",\n \"def magnetisation(field):\\n norm_field = df.Field(field.mesh, dim=1, value=(field.norm.array != 0))\\n volume = df.integral(norm_field * df.dV, direction='xyz')\\n return df.integral(field * df.dV / volume, direction='xyz')\",\n \"def validate_pmf(pmf, ops):\\n validate_normalization(pmf, ops)\\n validate_probabilities(pmf, ops)\\n return True\",\n \"def diwire_dfm(pl):\\n\\t# check angle\\n\\ttake3 = takeNGenerator(pl.points, 3)\\n\\tvalid = reduce(lambda flag, p: flag and (getAngle(*p) <= 135), take3, True)\\n\\t# check distance\\n\\ttake2 = takeNGenerator(pl.points, 2)\\n\\tvalid = reduce(lambda flag, p: flag and (\\n\\t\\tgetDistance(*p) >= 12), take2, valid)\\n\\tif valid:\\n\\t\\treturn True\\n\\telse:\\n\\t\\treturn False\",\n \"def _determine_extra_angles(self, angle_force, reference_topology, growth_indices):\\n from simtk import openmm\\n import itertools\\n from openeye import oechem, oeomega\\n\\n if len(growth_indices)==0:\\n return\\n angle_force_constant = 400.0*unit.kilojoules_per_mole/unit.radians**2\\n atoms = list(reference_topology.atoms())\\n growth_indices = list(growth_indices)\\n #get residue from first atom\\n residue = atoms[growth_indices[0].idx].residue\\n try:\\n oemol = FFAllAngleGeometryEngine._oemol_from_residue(residue)\\n except Exception as e:\\n print(\\\"Could not generate an oemol from the residue.\\\")\\n print(e)\\n\\n #get the omega geometry of the molecule:\\n\\n omega = oeomega.OEOmega()\\n omega.SetMaxConfs(1)\\n omega.SetStrictStereo(False) #TODO: fix stereochem\\n omega(oemol)\\n\\n #we now have the residue as an oemol. Time to find the relevant angles.\\n #There's no equivalent to OEGetTorsions, so first find atoms that are relevant\\n #TODO: find out if that's really true\\n aromatic_pred = oechem.OEIsAromaticAtom()\\n heavy_pred = oechem.OEIsHeavy()\\n angle_criteria = oechem.OEAndAtom(aromatic_pred, heavy_pred)\\n\\n #get all heavy aromatic atoms:\\n #TODO: do this more efficiently\\n heavy_aromatics = list(oemol.GetAtoms(angle_criteria))\\n for atom in heavy_aromatics:\\n #bonded_atoms = [bonded_atom for bonded_atom in list(atom.GetAtoms()) if bonded_atom in heavy_aromatics]\\n bonded_atoms = list(atom.GetAtoms())\\n for angle_atoms in itertools.combinations(bonded_atoms, 2):\\n angle = oechem.OEGetAngle(oemol, angle_atoms[0], atom, angle_atoms[1])\\n atom_indices = [angle_atoms[0].GetData(\\\"topology_index\\\"), atom.GetData(\\\"topology_index\\\"), angle_atoms[1].GetData(\\\"topology_index\\\")]\\n angle_radians = angle*unit.radian\\n growth_idx = self._calculate_growth_idx(atom_indices, growth_indices)\\n #If this is a CustomAngleForce, we need to pass the parameters as a list, and it will have the growth_idx parameter.\\n #If it's a regular HarmonicAngleForce, there is no growth_index and the parameters are passed separately.\\n if isinstance(angle_force, openmm.CustomAngleForce):\\n angle_force.addAngle(atom_indices[0], atom_indices[1], atom_indices[2], [angle_radians, angle_force_constant, growth_idx])\\n elif isinstance(angle_force, openmm.HarmonicAngleForce):\\n angle_force.addAngle(atom_indices[0], atom_indices[1], atom_indices[2], angle_radians, angle_force_constant)\\n else:\\n raise ValueError(\\\"Angle force must be either CustomAngleForce or HarmonicAngleForce\\\")\\n return angle_force\",\n \"def test_norm_compact_axis_angle():\\n a = np.array([np.pi, 0.0, 0.0])\\n n = pr.norm_compact_axis_angle(a)\\n assert_array_almost_equal(a, n)\\n\\n a = np.array([0.0, np.pi, 0.0])\\n n = pr.norm_compact_axis_angle(a)\\n assert_array_almost_equal(a, n)\\n\\n a = np.array([0.0, 0.0, np.pi])\\n n = pr.norm_compact_axis_angle(a)\\n assert_array_almost_equal(a, n)\\n\\n random_state = np.random.RandomState(0)\\n for _ in range(5):\\n a = pr.random_compact_axis_angle(random_state)\\n axis = a / np.linalg.norm(a)\\n angle = random_state.uniform(-20.0, -10.0 + 2.0 * np.pi)\\n a = axis * angle\\n n = pr.norm_compact_axis_angle(a)\\n for angle_offset in np.arange(0.0, 10.1 * np.pi, 2.0 * np.pi):\\n a = axis * (angle + angle_offset)\\n n2 = pr.norm_compact_axis_angle(a)\\n assert_array_almost_equal(n, n2)\",\n \"def backward_phi(self):\\n for f in self.component_fields:\\n f.require_grid_space()\",\n \"def isAcute(trpl):\\n vd = vectorFormat(trpl)\\n if angle_between(*vd) < np.pi/2:\\n return True\\n else:\\n return False\",\n \"def mod_check(x, y):\\r\\n if (as_tensor_variable(x).dtype in complex_dtypes or\\r\\n as_tensor_variable(y).dtype in complex_dtypes):\\r\\n # Currently forbidden.\\r\\n raise scal.Mod.complex_error\\r\\n else:\\r\\n return mod(x, y)\",\n \"def test_norm_axis_angle():\\n a = np.array([1.0, 0.0, 0.0, np.pi])\\n n = pr.norm_axis_angle(a)\\n assert_array_almost_equal(a, n)\\n\\n a = np.array([0.0, 1.0, 0.0, np.pi])\\n n = pr.norm_axis_angle(a)\\n assert_array_almost_equal(a, n)\\n\\n a = np.array([0.0, 0.0, 1.0, np.pi])\\n n = pr.norm_axis_angle(a)\\n assert_array_almost_equal(a, n)\\n\\n random_state = np.random.RandomState(0)\\n for _ in range(5):\\n a = pr.random_axis_angle(random_state)\\n angle = random_state.uniform(-20.0, -10.0 + 2.0 * np.pi)\\n a[3] = angle\\n n = pr.norm_axis_angle(a)\\n for angle_offset in np.arange(0.0, 10.1 * np.pi, 2.0 * np.pi):\\n a[3] = angle + angle_offset\\n n2 = pr.norm_axis_angle(a)\\n assert_array_almost_equal(n, n2)\",\n \"def assert_no_error(self): \\r\\n Nx = self['Nx']\\r\\n Nt = self.m.Nt\\r\\n L, T = self.problem['L T'.split()]\\r\\n L = L/2 # only half the domain used (symmetry)\\r\\n x = np.linspace(0, L, Nx+1) # Mesh points in space \\r\\n t = np.linspace(0, T, Nt+1) # Mesh points in time\\r\\n \\r\\n for n in range(len(t)):\\r\\n u_e = self.problem.u_exact(x, t[n])\\r\\n diff = np.abs(self.f.u[n,:] - u_e).max()\\r\\n print 'diff:', diff\\r\\n tol = 1E-13\\r\\n assert diff < tol\",\n \"def _is_trivial_angle(rad: float, atol: float) -> bool:\\n return abs(rad) < atol or abs(abs(rad) - np.pi / 4) < atol\",\n \"def assertAngle(self, angle: float):\\n assert isinstance(angle, float), f\\\"bad angle instance, type of angle is {type(angle)}\\\"\\n assert -180 <= angle <= 180\",\n \"def test_fractional_bondorder_from_molecule(\\n self,\\n get_molecule,\\n k_torsion_interpolated,\\n k_bond_interpolated,\\n length_bond_interpolated,\\n central_atoms,\\n ):\\n mol = get_molecule()\\n forcefield = ForceField(\\n get_data_file_path(\\\"test_forcefields/test_forcefield.offxml\\\"), xml_ff_bo\\n )\\n topology = Topology.from_molecules(mol)\\n\\n omm_system = forcefield.create_openmm_system(\\n topology,\\n charge_from_molecules=[mol],\\n partial_bond_orders_from_molecules=[mol],\\n )\\n\\n # Verify that the assigned bond parameters were correctly interpolated\\n off_bond_force = [\\n force\\n for force in omm_system.getForces()\\n if isinstance(force, openmm.HarmonicBondForce)\\n ][0]\\n\\n for idx in range(off_bond_force.getNumBonds()):\\n params = off_bond_force.getBondParameters(idx)\\n\\n atom1, atom2 = params[0], params[1]\\n atom1_mol, atom2_mol = central_atoms\\n\\n if ((atom1 == atom1_mol) and (atom2 == atom2_mol)) or (\\n (atom1 == atom2_mol) and (atom2 == atom1_mol)\\n ):\\n k = params[-1]\\n length = params[-2]\\n assert_almost_equal(k / k.unit, k_bond_interpolated)\\n assert_almost_equal(length / length.unit, length_bond_interpolated)\\n\\n # Verify that the assigned torsion parameters were correctly interpolated\\n off_torsion_force = [\\n force\\n for force in omm_system.getForces()\\n if isinstance(force, openmm.PeriodicTorsionForce)\\n ][0]\\n\\n for idx in range(off_torsion_force.getNumTorsions()):\\n params = off_torsion_force.getTorsionParameters(idx)\\n\\n atom2, atom3 = params[1], params[2]\\n atom2_mol, atom3_mol = central_atoms\\n\\n if ((atom2 == atom2_mol) and (atom3 == atom3_mol)) or (\\n (atom2 == atom3_mol) and (atom3 == atom2_mol)\\n ):\\n k = params[-1]\\n assert_almost_equal(k / k.unit, k_torsion_interpolated)\",\n \"def test_get_principal_moments_of_inertia(self):\\n numbers = [6, 6, 8, 1, 1, 1, 1, 1, 1]\\n coords = np.array([[1.235366, -0.257231, -0.106315],\\n [0.083698, 0.554942, 0.046628],\\n [-1.210594, -0.239505, -0.021674],\\n [0.132571, 1.119728, 0.987719],\\n [0.127795, 1.278999, -0.769346],\\n [-1.272620, -0.962700, 0.798216],\\n [-2.074974, 0.426198, 0.055846],\\n [-1.275744, -0.785745, -0.965493],\\n [1.241416, -0.911257, 0.593856]], np.float64)\\n principal_moments_of_inertia = get_principal_moments_of_inertia(coords=coords, numbers=numbers)[0]\\n expected_principal_moments_of_inertia = [60.98026894, 53.83156297, 14.48858465]\\n for moment, expected_moment in zip(principal_moments_of_inertia, expected_principal_moments_of_inertia):\\n self.assertAlmostEqual(moment, expected_moment)\\n\\n symbols = ['N', 'O', 'O'] # test a linear molecule\\n coords = np.array([[0.000000, 0.000000, 1.106190],\\n [0.000000, 0.000000, -0.072434],\\n [0.000000, 0.000000, -1.191782]], np.float64)\\n with self.assertRaises(InputError):\\n get_principal_moments_of_inertia(coords=coords, numbers=numbers)\\n principal_moments_of_inertia, axes = get_principal_moments_of_inertia(coords=coords, symbols=symbols)\\n expected_principal_moments_of_inertia = [39.4505153, 39.4505153, 0.0]\\n expected_axes = [[1, 0, 0], [0, 1, 0], [0, 0, 1]]\\n for moment, expected_moment in zip(principal_moments_of_inertia, expected_principal_moments_of_inertia):\\n self.assertAlmostEqual(moment, expected_moment)\\n for axis, expected_axis in zip(axes, expected_axes):\\n for entry, expected_entry in zip(axis, expected_axis):\\n self.assertAlmostEqual(entry, expected_entry)\\n self.assertIsInstance(principal_moments_of_inertia, tuple)\\n self.assertIsInstance(axes, tuple)\",\n \"def test_angle_angle_explicit(pcff):\\n\\n expected = {\\n \\\"K\\\": \\\"3.5475\\\",\\n \\\"reference\\\": \\\"1\\\",\\n \\\"Theta10\\\": \\\"107.6600\\\",\\n \\\"Theta20\\\": \\\"105.8500\\\",\\n }\\n\\n i = \\\"h\\\"\\n j = \\\"c\\\"\\n k = \\\"h\\\"\\n l = \\\"n+\\\" # noqa: E741\\n ptype, key, form, parameters = pcff.angle_angle_parameters(i, j, k, l)\\n assert ptype == \\\"explicit\\\"\\n assert key == (\\\"h\\\", \\\"c\\\", \\\"h\\\", \\\"n+\\\")\\n assert parameters == expected\",\n \"def test_t(self):\\n assert np.isclose(self.stepper.t, self.final_t)\",\n \"def test_charge_increment_model_one_less_ci_than_tagged_atom(self):\\n # Make a FF from each OFFXML string\\n file_path = get_data_file_path(\\\"test_forcefields/test_forcefield.offxml\\\")\\n ff1 = ForceField(file_path, xml_charge_increment_model_ff_one_less_ci)\\n del ff1._parameter_handlers[\\\"ToolkitAM1BCC\\\"]\\n ff2 = ForceField(file_path, xml_charge_increment_model_ff_no_missing_cis)\\n del ff2._parameter_handlers[\\\"ToolkitAM1BCC\\\"]\\n top = Topology.from_molecules([create_ethanol()])\\n # Make a system from each FF\\n sys1 = ff2.create_openmm_system(top)\\n sys2 = ff2.create_openmm_system(top)\\n # Extract the nonbonded force from each system\\n nonbonded_force1 = [\\n force\\n for force in sys1.getForces()\\n if isinstance(force, openmm.NonbondedForce)\\n ][0]\\n nonbonded_force2 = [\\n force\\n for force in sys2.getForces()\\n if isinstance(force, openmm.NonbondedForce)\\n ][0]\\n\\n # Ensure that the systems both have the correct charges assigned\\n expected_charges = [\\n 0.17,\\n -0.18,\\n -0.04,\\n 0.01,\\n 0.01,\\n 0.01,\\n 0.01,\\n 0.01,\\n 0.0,\\n ] * openmm_unit.elementary_charge\\n for idx, expected_charge in enumerate(expected_charges):\\n charge1, _, _ = nonbonded_force1.getParticleParameters(idx)\\n charge2, _, _ = nonbonded_force2.getParticleParameters(idx)\\n assert (\\n abs(charge1 - expected_charge) < 1.0e-6 * openmm_unit.elementary_charge\\n )\\n assert charge1 == charge2\",\n \"def check_extension(sim_par, base_mof, mobile_mof, emap, emap_atom_list, new_structure):\\n emap_max = [emap[-1][0], emap[-1][1], emap[-1][2]]\\n emap_min = [emap[0][0], emap[0][1], emap[0][2]]\\n\\n energy_limit = sim_par['atom_energy_limit']\\n ext_cut_off = sim_par['ext_cut_off']\\n\\n rotation_info = new_structure['rotation']\\n first_point = new_structure['first_point']\\n translation_vector = Coor(new_structure['translation_vector'])\\n\\n Quat = Quaternion([0, 1, 1, 1])\\n\\n packing_factor = Packing.factor(mobile_mof.uc_size, ext_cut_off)\\n uc_vectors = Packing.uc_vectors(mobile_mof.uc_size, mobile_mof.uc_angle)\\n trans_vec = Packing.translation_vectors(packing_factor, uc_vectors)\\n packed_coors = Packing.uc_coors(trans_vec, packing_factor, uc_vectors, mobile_mof.atom_coors)\\n\\n x_angle = rotation_info[0]\\n y_angle = rotation_info[1]\\n z_angle = rotation_info[2]\\n\\n collision = False\\n for unit_cell in packed_coors:\\n\\n if not collision:\\n\\n for coor_index, coor in enumerate(unit_cell):\\n\\n if not collision:\\n\\n new_coor = Coor(coor)\\n Q = Quaternion([1, new_coor.x, new_coor.y, new_coor.z]) # Might be a better way to do this\\n Q = Quat.rotation(Q.xyz(), [0, 0, 0], [1, 0, 0], x_angle)\\n Q = Quat.rotation(Q.xyz(), [0, 0, 0], [0, 1, 0], y_angle)\\n Q = Quat.rotation(Q.xyz(), [0, 0, 0], [0, 0, 1], z_angle)\\n new_coor = Coor(Q.xyz())\\n\\n new_coor += translation_vector\\n pbc_coor = new_coor.pbc(base_mof.uc_size, base_mof.uc_angle, base_mof.frac_ucv)\\n\\n atom_name = mobile_mof.atom_names[coor_index]\\n atom_index = energy_map_atom_index(atom_name, emap_atom_list)\\n\\n point_energy = trilinear_interpolate(pbc_coor.xyz(), atom_index, emap, emap_max, emap_min)\\n\\n if point_energy < energy_limit:\\n continue\\n else:\\n collision = True\\n break\\n else:\\n break\\n else:\\n break\\n\\n return collision\",\n \"def search_base_angles(self, motor_positions):\\n\\n # Errore nelle soluzioni\\n err = [0, 0, 0]\\n\\n # Angolo di inizio ricerca\\n # Se gia' eseguita una conversione suo i valori precedenti\\n if self.isLastAnglesValid:\\n self.alpha_start = list(self.alpha)\\n else:\\n # Angolo minimo di partenza ( -alpha_limit )\\n # TO_CHECK: perche' parto da una configurazione sicuramente errata? -10?\\n self.alpha_start = [self.alpha_limit_r, self.alpha_limit_r, self.alpha_limit_r]\\n\\n # Angoli presunti\\n # self.temp = list(self.alpha_start)\\n alpha = list(self.alpha_start)\\n\\n # Altezze reali degli attuatori\\n height = [self.real_height + motor_positions[0],\\n self.real_height + motor_positions[1],\\n self.real_height + motor_positions[2]]\\n\\n # Trovo il mediano tra 0-1-2\\n '''\\n if any([all([motor_positions[0] > motor_positions[1], motor_positions[0] < motor_positions[2]]),\\n all([motor_positions[0] < motor_positions[1], motor_positions[0] > motor_positions[2]])]):\\n is_0_median = True\\n is_1_median = False\\n is_2_median = False\\n else:\\n is_0_median = False\\n if any([all([motor_positions[1] > motor_positions[2], motor_positions[1] < motor_positions[0]]),\\n all([motor_positions[1] < motor_positions[2], motor_positions[1] > motor_positions[0]])]):\\n is_0_median = False\\n is_1_median = True\\n is_2_median = False\\n else:\\n is_1_median = False\\n if any([all([motor_positions[2] > motor_positions[1], motor_positions[2] < motor_positions[0]]),\\n all([motor_positions[2] < motor_positions[1], motor_positions[2] > motor_positions[0]])]):\\n is_0_median = False\\n is_1_median = False\\n is_2_median = True\\n else:\\n is_2_median = False\\n '''\\n\\n # Incrementi degli angoli\\n # TO_CHECK: perche' quattro? L'ultimo e' di backup?\\n step_alpha_base = 0.1 * Kinematic.M_TO_RAD\\n step_alpha = [step_alpha_base, step_alpha_base, step_alpha_base]\\n\\n # Numero di cicli eseguiti\\n self.cycles = 0\\n\\n # Calcolo la condizione iniziale\\n d1 = self.distance_12(alpha, height)\\n err[0] = d1 - self.base_length\\n step_alpha[1] = err[0] * self.ke * step_alpha_base\\n\\n d2 = self.distance_23(alpha, height)\\n err[1] = d2 - self.base_length\\n step_alpha[2] = err[1] * self.ke * step_alpha_base\\n\\n d3 = self.distance_13(alpha, height)\\n err[2] = d3 - self.base_length\\n step_alpha[0] = err[2] * self.ke * step_alpha_base\\n\\n i = 0\\n while i < self.cycle_limit:\\n\\n i += 1\\n\\n # Incremento alfa1 ed azzero alfa2\\n alpha[0] += step_alpha[0]\\n alpha[1] = self.alpha_start[1]\\n\\n j = 0\\n\\n while j < self.cycle_limit:\\n\\n j += 1\\n\\n # self.next_iteration(alpha, step_alpha, i, j, n, err)\\n self.cycles += 1\\n\\n if self.cycles > self.cycle_limit:\\n logging.error(\\\"Maximum number of cycles executed, no solution found!\\\")\\n return False\\n\\n # Incremento alfa1 ed azzero alfa2\\n alpha[1] += step_alpha[1]\\n\\n # Se supero l'angolo limite\\n # Partendo da -10 ( -0.17 ), non devo superare 10 ( 0.17 )\\n if alpha[1] > -self.alpha_limit_r:\\n\\n # Angolo non trovato\\n step_alpha[1] = step_alpha_base\\n step_alpha[0] = err[0] * step_alpha_base * self.ke\\n self.alpha_start[1] = -self.alpha_limit_r - 2 * step_alpha[1]\\n break\\n\\n d1 = self.distance_12(alpha, height)\\n err[0] = d1 - self.base_length\\n step_alpha[1] = err[0] * self.ke * step_alpha_base\\n\\n if abs(err[0]) < self.err_limit:\\n\\n # Trovato il minimo\\n self.alpha_start[1] = alpha[1]\\n step_alpha[1] = step_alpha_base\\n\\n n = 0\\n while n < self.cycle_limit:\\n\\n n += 1\\n\\n # self.next_iteration(alpha, step_alpha, i, j, n, err)\\n self.cycles += 1\\n\\n if self.cycles > self.cycle_limit:\\n logging.error(\\\"Maximum number of cycles executed, no solution found!\\\")\\n return False\\n\\n alpha[2] += step_alpha[2]\\n d2 = self.distance_23(alpha, height)\\n err[1] = d2 - self.base_length\\n step_alpha[2] = err[1] * self.ke * step_alpha_base\\n\\n if abs(err[1]) < self.err_limit:\\n\\n step_alpha[2] = step_alpha_base\\n d3 = self.distance_13(alpha, height)\\n err[2] = d3 - self.base_length\\n step_alpha[0] = err[2] * self.ke * step_alpha_base\\n\\n if abs(err[2]) < self.err_limit:\\n\\n # Trovatas la soluzione\\n self.alpha = list(alpha)\\n return True\\n\\n # NEXT j!!!\\n break\\n\\n # Next i!!!\\n break\",\n \"def alchemical_forces(self):\\n return self._cpp_obj._forces * self._cpp_obj.norm_value\",\n \"def test_integrate_wontfix(self):\\n ans_flam = 8.8608168e-09 * (u.erg / (u.cm * u.cm * u.s))\\n assert_quantity_allclose(\\n self.sp.integrate(wavelengths=self.w, flux_unit='flam',\\n integration_type='analytical'), ans_flam)\",\n \"def test_non_integral_validation(self):\",\n \"def test_non_integral_validation(self):\",\n \"def is_valid(self):\\n posit1 = (self.mean_v > 0) & (self.kappa_y > 0) & (self.eta_y > 0)\\n posit2 = (self.kappa_s > 0) & (self.eta_s > 0)\\n return posit1 & posit2 & self.feller()\",\n \"def _validate_axes(self):\\n if not (\\n np.abs(self.axis_u.dot(self.axis_v) < 1e-6)\\n and np.abs(self.axis_v.dot(self.axis_w) < 1e-6)\\n and np.abs(self.axis_w.dot(self.axis_u) < 1e-6)\\n ):\\n raise ValueError(\\\"axis_u, axis_v, and axis_w must be orthogonal\\\")\\n return True\",\n \"def modify_openmm_forces(self, *args, **kwargs):\\n raise NotImplementedError()\",\n \"def validate_magvar(mv):\\n result = VALID\\n mag_var = None\\n try:\\n mag_var = float(mv)\\n if (mag_var > 360) or (mag_var < -360):\\n result = NOT_VALID\\n except ValueError:\\n try:\\n prefix = mv[0]\\n if REGEX_MAGVAR_DD.match(mv[1:]): # Check if there are only numbers > 0, eg. 1.5, not -1.5\\n mag_var = float(mv[1:])\\n if prefix == 'W':\\n result = -mag_var\\n elif prefix == 'E':\\n result = mag_var\\n else:\\n result = NOT_VALID\\n else:\\n result = NOT_VALID\\n\\n if (mag_var != None) and ((mag_var > 360) or (mag_var < -360)):\\n result = NOT_VALID \\n \\n except ValueError:\\n result = NOT_VALID\\n mag_var = None\\n\\n return result, mag_var\",\n \"def test_norm_angle():\\n random_state = np.random.RandomState(0)\\n a_norm = random_state.uniform(-np.pi, np.pi, size=(100,))\\n for b in np.linspace(-10.0 * np.pi, 10.0 * np.pi, 11):\\n a = a_norm + b\\n assert_array_almost_equal(pr.norm_angle(a), a_norm)\\n\\n assert_almost_equal(pr.norm_angle(-np.pi), np.pi)\\n assert_almost_equal(pr.norm_angle(np.pi), np.pi)\",\n \"def test_run_mantel_correlogram_invaid_input(self):\\r\\n self.assertRaises(ValueError, run_mantel_correlogram, [self.fp1],\\r\\n [self.dm1, self.dm3], self.num_perms, None, self.alpha)\",\n \"def comp_axes(self, machine, N0=None):\\n if self.time is None and N0 is None:\\n raise InputError(\\\"ERROR: time and N0 can't be both None\\\")\\n\\n # Get machine pole pair number\\n p = machine.get_pole_pair_number()\\n\\n # Get electrical fundamental frequency\\n f_elec = self.comp_felec()\\n\\n # Airgap radius\\n Rag = machine.comp_Rgap_mec()\\n\\n # Setup normalizations for time and angle axes\\n norm_time = {\\n \\\"elec_order\\\": f_elec,\\n \\\"mech_order\\\": f_elec / p,\\n }\\n if N0 is not None:\\n norm_time[\\\"angle_rotor\\\"] = 1 / (360 * N0 / 60)\\n\\n norm_angle = {\\\"space_order\\\": p, \\\"distance\\\": 1 / Rag}\\n\\n # Create time axis\\n if self.time is None:\\n # Create time axis as a DataLinspace\\n Time = DataLinspace(\\n name=\\\"time\\\",\\n unit=\\\"s\\\",\\n initial=0,\\n final=60 / N0 * self.Nrev,\\n number=self.Nt_tot,\\n include_endpoint=False,\\n normalizations=norm_time,\\n )\\n else:\\n # Load time data\\n time = self.time.get_data()\\n self.Nt_tot = len(time)\\n Time = Data1D(name=\\\"time\\\", unit=\\\"s\\\", values=time, normalizations=norm_time)\\n\\n # Create angle axis\\n if self.angle is None:\\n # Create angle axis as a DataLinspace\\n Angle = DataLinspace(\\n name=\\\"angle\\\",\\n unit=\\\"rad\\\",\\n initial=0,\\n final=2 * pi,\\n number=self.Na_tot,\\n include_endpoint=False,\\n normalizations=norm_angle,\\n )\\n else:\\n # Load angle data\\n angle = self.angle.get_data()\\n self.Na_tot = len(angle)\\n Angle = Data1D(\\n name=\\\"angle\\\", unit=\\\"rad\\\", values=angle, normalizations=norm_angle\\n )\\n\\n return Time, Angle\",\n \"def update_forces(self):\\n\\n pass\",\n \"def test_magmom(convcell_cr: PhonopyAtoms):\\n symprec = 1e-5\\n symmetry_nonspin = Symmetry(convcell_cr, symprec=symprec)\\n atom_map_nonspin = symmetry_nonspin.get_map_atoms()\\n len_sym_nonspin = len(symmetry_nonspin.symmetry_operations[\\\"rotations\\\"])\\n\\n spin = [1, -1]\\n cell_withspin = convcell_cr.copy()\\n cell_withspin.magnetic_moments = spin\\n symmetry_withspin = Symmetry(cell_withspin, symprec=symprec)\\n atom_map_withspin = symmetry_withspin.get_map_atoms()\\n len_sym_withspin = len(symmetry_withspin.symmetry_operations[\\\"rotations\\\"])\\n\\n broken_spin = [1, -2]\\n cell_brokenspin = convcell_cr.copy()\\n cell_brokenspin = convcell_cr.copy()\\n cell_brokenspin.magnetic_moments = broken_spin\\n symmetry_brokenspin = Symmetry(cell_brokenspin, symprec=symprec)\\n atom_map_brokenspin = symmetry_brokenspin.get_map_atoms()\\n len_sym_brokenspin = len(symmetry_brokenspin.symmetry_operations[\\\"rotations\\\"])\\n\\n assert (atom_map_nonspin == atom_map_withspin).all()\\n assert (atom_map_nonspin != atom_map_brokenspin).any()\\n assert len_sym_nonspin == len_sym_withspin\\n assert len_sym_nonspin != len_sym_brokenspin\",\n \"def test_run_mantel_test_invaid_input(self):\\r\\n self.assertRaises(ValueError, run_mantel_test, 'mantel',\\r\\n [self.fp1,\\r\\n self.fp2], [\\r\\n self.dm1], self.num_perms, 'two sided',\\r\\n None, self.alpha)\",\n \"def test_abs_magnitude_graph_missing_velocity_returns_exception():\\n from space_rocks.views.plot_magnitude import graph_abs_magnitude\\n\\n test_mag = [1, 2, 3, 4, 5]\\n test_neo_names = [\\\"ceres\\\", \\\"phobos\\\", \\\"deimos\\\", \\\"asteroid x\\\", \\\"it was earth all along!!\\\"]\\n\\n with pytest.raises(UnknownAxisException):\\n graph_abs_magnitude(test_mag, [], test_neo_names)\",\n \"def test_charge_increment_model_net_charge(self):\\n file_path = get_data_file_path(\\\"test_forcefields/test_forcefield.offxml\\\")\\n ff = ForceField(file_path, xml_charge_increment_model_ff_net_charge)\\n del ff._parameter_handlers[\\\"ToolkitAM1BCC\\\"]\\n\\n acetate = create_acetate()\\n top = acetate.to_topology()\\n\\n sys = ff.create_openmm_system(top)\\n nonbonded_force = [\\n force\\n for force in sys.getForces()\\n if isinstance(force, openmm.NonbondedForce)\\n ][0]\\n expected_charges = [\\n 0,\\n 0.15,\\n -0.2,\\n -0.95,\\n 0,\\n 0,\\n 0,\\n ] * openmm_unit.elementary_charge\\n for idx, expected_charge in enumerate(expected_charges):\\n charge, _, _ = nonbonded_force.getParticleParameters(idx)\\n assert (\\n abs(charge - expected_charge) < 1.0e-6 * openmm_unit.elementary_charge\\n )\",\n \"def bode(system, mn=0.001, mx=1000, npts=100, title=\\\"\\\", xlim=False, ylim=False, sv=False,\\n disp3db=False, lowcut=None, magnitude=True, angle=True, freqaxis=\\\"rad\\\"):\\n # Condition system input to ensure proper execution\\n system = _sys_condition(system, False)\\n\\n # Condition min and max freq terms\\n degrees = False\\n if freqaxis.lower().find(\\\"deg\\\") != -1: # degrees requested\\n degrees = True\\n # Scale Degrees to Radians for calculation\\n mn = 2 * _np.pi * mn\\n mx = 2 * _np.pi * mx\\n mn = _np.log10(mn) # find the _exponent value\\n mx = _np.log10(mx) # find the _exponent value\\n\\n # Generate the frequency range to calculate over\\n wover = _np.logspace(mn, mx, npts)\\n\\n # Calculate the bode system\\n w, mag, ang = _sig.bode(system, wover)\\n\\n def _plot(plot_title, y_label):\\n _plt.title(plot_title)\\n _plt.ylabel(y_label)\\n if degrees: # Plot in degrees\\n _plt.plot(w / (2 * _np.pi), ang)\\n _plt.xlabel(\\\"Frequency (Hz)\\\")\\n else: # Plot in radians\\n _plt.plot(w, ang)\\n _plt.xlabel(\\\"Frequency (rad/sec)\\\")\\n _plt.xscale(\\\"log\\\")\\n _plt.grid(which=\\\"both\\\")\\n if xlim:\\n _plt.xlim(xlim)\\n if ylim:\\n _plt.ylim(ylim)\\n if sv:\\n _plt.savefig(title + \\\".png\\\")\\n\\n # Plot Magnitude\\n if magnitude:\\n magTitle = \\\"Magnitude \\\" + title\\n _plot(magTitle, \\\"Magnitude (DB)\\\")\\n if disp3db:\\n _plt.axhline(-3)\\n if lowcut is not None:\\n _plt.axhline(lowcut)\\n _plt.show()\\n\\n # Plot Angle\\n if angle:\\n angTitle = \\\"Angle \\\" + title\\n _plot(angTitle, \\\"Angle (degrees)\\\")\\n _plt.show()\",\n \"def check_openmm_requirements(cls, combine_nonbonded_forces: bool) -> None:\",\n \"def test_calculate_angle():\\n r1 = np.array([0, 0, -1])\\n r2 = np.array([0, 0, 0])\\n r3 = np.array([1, 0, 0])\\n\\n expected_angle = 90\\n calculated_angle = molecool.calculate_angle(r1, r2, r3, degrees = True)\\n\\n assert expected_angle == calculated_angle\",\n \"def intf_ANGLE(E):\\n if ( not E.The.StackSize() >= 3\\n or not inc.point_formatted_LST(E.The,1)\\n or not inc.point_formatted_LST(E.The,2)\\n or not inc.point_formatted_LST(E.The,3) ):\\n print(\\\"Input Error: angle\\\")\\n print(intf_ANGLE.__doc__)\\n return # Without doing much of anything.\\n import math\\n Cobject= E.The.StackPop()\\n #C= map(lambda x:x.val, Cobject.val) # Should now be a list of floats.\\n C= [x.val for x in Cobject.val] # Should now be a list of floats.\\n Bobject= E.The.StackPop()\\n #B= map(lambda x:x.val, Bobject.val) # Should now be a list of floats.\\n B= [x.val for x in Bobject.val] # Should now be a list of floats.\\n Aobject= E.The.StackPop()\\n #A= map(lambda x:x.val, Aobject.val) # Should now be a list of floats.\\n A= [x.val for x in Aobject.val] # Should now be a list of floats.\\n v1= [ A[0]-B[0], A[1]-B[1], A[2]-B[2] ]\\n v2= [ C[0]-B[0], C[1]-B[1], C[2]-B[2] ]\\n v1mag= math.sqrt( v1[0]*v1[0] + v1[1]*v1[1] + v1[2]*v1[2] )\\n v2mag= math.sqrt( v2[0]*v2[0] + v2[1]*v2[1] + v2[2]*v2[2] )\\n try:\\n v1norm= [x/v1mag for x in v1]\\n v2norm= [x/v2mag for x in v2]\\n dotprod= v1norm[0]*v2norm[0] + v1norm[1]*v2norm[1] + v1norm[2]*v2norm[2]\\n a= math.acos(dotprod) * 180 / math.pi\\n except ZeroDivisionError:\\n print(\\\"The supplied points are not distinct or have some other math problem.\\\")\\n return\\n d= objectifier.StackOB_VAL(a) # Can't be just regular Python ints.\\n E.The.StackPush(d)\",\n \"def validate(self, mesh, mod):\\n return True\",\n \"def _assert_validity_of_inputs(self):\\n for item in [\\\"frequency\\\", \\\"Dt\\\", \\\"gain\\\", \\\"gain_imu\\\", \\\"gain_marg\\\"]:\\n if isinstance(self.__getattribute__(item), bool):\\n raise TypeError(f\\\"Parameter '{item}' must be numeric.\\\")\\n if not isinstance(self.__getattribute__(item), (int, float)):\\n raise TypeError(f\\\"Parameter '{item}' is not a non-zero number.\\\")\\n if self.__getattribute__(item) <= 0.0:\\n raise ValueError(f\\\"Parameter '{item}' must be a non-zero number.\\\")\\n if self.q0 is not None:\\n if not isinstance(self.q0, (list, tuple, np.ndarray)):\\n raise TypeError(f\\\"Parameter 'q0' must be an array. Got {type(self.q0)}.\\\")\\n self.q0 = np.copy(self.q0)\\n if self.q0.shape != (4,):\\n raise ValueError(f\\\"Parameter 'q0' must be an array of shape (4,). It is {self.q0.shape}.\\\")\\n if not np.allclose(np.linalg.norm(self.q0), 1.0):\\n raise ValueError(f\\\"Parameter 'q0' must be a versor (norm equal to 1.0). Its norm is equal to {np.linalg.norm(self.q0)}.\\\")\",\n \"def _validate_mass(mass):\\n if not isinstance(mass, u.unyt_array):\\n warnings.warn(\\\"Masses are assumed to be g/mol\\\")\\n mass *= u.gram / u.mol\\n elif mass.units.dimensions != (u.gram / u.mol).units.dimensions:\\n warnings.warn(\\\"Masses are assumed to be g/mol\\\")\\n mass = mass.value * u.gram / u.mol\\n else:\\n pass\\n\\n return mass\",\n \"def validPeriod(period):\\r\\n try:\\r\\n i = float(period)\\r\\n except ValueError:\\r\\n return False\\r\\n else:\\r\\n if i>0:\\r\\n return True\\r\\n else:\\r\\n return False\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6782517","0.60290766","0.6012614","0.58263516","0.5755218","0.56247103","0.5583029","0.5559526","0.55149376","0.54994637","0.5498538","0.54675615","0.5454319","0.5441296","0.54299664","0.5414825","0.54081666","0.53792536","0.53736025","0.53621024","0.53515375","0.53283983","0.5313582","0.52788335","0.52713114","0.52639693","0.52491915","0.5234739","0.5207955","0.52076775","0.5205681","0.52032745","0.5200479","0.5196229","0.5188782","0.5181477","0.51761025","0.51702726","0.51663613","0.5149821","0.5137424","0.51326257","0.5121441","0.5118666","0.5115106","0.51075286","0.50986934","0.50828606","0.5076498","0.5068054","0.5064371","0.5052289","0.5045481","0.5029751","0.502165","0.501995","0.501671","0.5014008","0.5013348","0.5008663","0.5004863","0.4997364","0.49961182","0.4994588","0.49930862","0.4990433","0.49886075","0.49873614","0.49832216","0.4976222","0.4975676","0.49720764","0.49685812","0.49644545","0.4961677","0.49615753","0.49554002","0.4947107","0.49419823","0.49419823","0.49383","0.49357596","0.4933915","0.49194428","0.49189922","0.49182934","0.49176553","0.49053872","0.48981214","0.48929605","0.489012","0.4889063","0.4887974","0.4887202","0.48868167","0.4885007","0.48828778","0.4881935","0.4879436","0.4878991"],"string":"[\n \"0.6782517\",\n \"0.60290766\",\n \"0.6012614\",\n \"0.58263516\",\n \"0.5755218\",\n \"0.56247103\",\n \"0.5583029\",\n \"0.5559526\",\n \"0.55149376\",\n \"0.54994637\",\n \"0.5498538\",\n \"0.54675615\",\n \"0.5454319\",\n \"0.5441296\",\n \"0.54299664\",\n \"0.5414825\",\n \"0.54081666\",\n \"0.53792536\",\n \"0.53736025\",\n \"0.53621024\",\n \"0.53515375\",\n \"0.53283983\",\n \"0.5313582\",\n \"0.52788335\",\n \"0.52713114\",\n \"0.52639693\",\n \"0.52491915\",\n \"0.5234739\",\n \"0.5207955\",\n \"0.52076775\",\n \"0.5205681\",\n \"0.52032745\",\n \"0.5200479\",\n \"0.5196229\",\n \"0.5188782\",\n \"0.5181477\",\n \"0.51761025\",\n \"0.51702726\",\n \"0.51663613\",\n \"0.5149821\",\n \"0.5137424\",\n \"0.51326257\",\n \"0.5121441\",\n \"0.5118666\",\n \"0.5115106\",\n \"0.51075286\",\n \"0.50986934\",\n \"0.50828606\",\n \"0.5076498\",\n \"0.5068054\",\n \"0.5064371\",\n \"0.5052289\",\n \"0.5045481\",\n \"0.5029751\",\n \"0.502165\",\n \"0.501995\",\n \"0.501671\",\n \"0.5014008\",\n \"0.5013348\",\n \"0.5008663\",\n \"0.5004863\",\n \"0.4997364\",\n \"0.49961182\",\n \"0.4994588\",\n \"0.49930862\",\n \"0.4990433\",\n \"0.49886075\",\n \"0.49873614\",\n \"0.49832216\",\n \"0.4976222\",\n \"0.4975676\",\n \"0.49720764\",\n \"0.49685812\",\n \"0.49644545\",\n \"0.4961677\",\n \"0.49615753\",\n \"0.49554002\",\n \"0.4947107\",\n \"0.49419823\",\n \"0.49419823\",\n \"0.49383\",\n \"0.49357596\",\n \"0.4933915\",\n \"0.49194428\",\n \"0.49189922\",\n \"0.49182934\",\n \"0.49176553\",\n \"0.49053872\",\n \"0.48981214\",\n \"0.48929605\",\n \"0.489012\",\n \"0.4889063\",\n \"0.4887974\",\n \"0.4887202\",\n \"0.48868167\",\n \"0.4885007\",\n \"0.48828778\",\n \"0.4881935\",\n \"0.4879436\",\n \"0.4878991\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.56348616"},"document_rank":{"kind":"string","value":"5"}}},{"rowIdx":24999,"cells":{"query":{"kind":"string","value":"Validation of the implementaiton of periodic angle axis in Magnetic (MagFEMM) and Force (ForceMT) modules"},"document":{"kind":"string","value":"def test_FEMM_periodicity_time():\n\n SPMSM_015 = load(join(DATA_DIR, \"Machine\", \"SPMSM_015.json\"))\n\n assert SPMSM_015.comp_periodicity() == (9, False, 9, True)\n\n simu = Simu1(name=\"test_FEMM_periodicity_time\", machine=SPMSM_015)\n\n # Definition of the enforced output of the electrical module\n I0_rms = 250 / sqrt(2)\n Phi0 = 140 * pi / 180 # Maximum Torque Per Amp\n\n Id_ref = (I0_rms * exp(1j * Phi0)).real\n Iq_ref = (I0_rms * exp(1j * Phi0)).imag\n\n simu.input = InputCurrent(\n Id_ref=Id_ref,\n Iq_ref=Iq_ref,\n Na_tot=252 * 9,\n Nt_tot=4 * 9,\n N0=1000,\n )\n\n # Definition of the magnetic simulation: with periodicity\n simu.mag = MagFEMM(\n type_BH_stator=1,\n type_BH_rotor=1,\n is_periodicity_a=True,\n is_periodicity_t=True,\n nb_worker=cpu_count(),\n Kmesh_fineness=2,\n )\n simu.force = ForceMT()\n\n # Definition of the magnetic simulation: no periodicity\n simu2 = simu.copy()\n simu2.mag.is_periodicity_t = False\n\n # Run simulations\n out = Output(simu=simu)\n simu.run()\n\n out2 = Output(simu=simu2)\n simu2.run()\n\n # Plot the result\n out.mag.B.plot_2D_Data(\n \"time\",\n \"angle[0]{°}\",\n data_list=[out2.mag.B],\n legend_list=[\"Periodic\", \"Full\"],\n save_path=join(save_path, simu.name + \"_B_time.png\"),\n is_show_fig=False,\n **dict_2D\n )\n\n out.mag.B.plot_2D_Data(\n \"angle{°}\",\n \"time[1]\",\n data_list=[out2.mag.B],\n legend_list=[\"Periodic\", \"Full\"],\n save_path=join(save_path, simu.name + \"_B_space.png\"),\n is_show_fig=False,\n **dict_2D\n )\n\n out.force.AGSF.plot_2D_Data(\n \"wavenumber=[0,100]\",\n \"time[0]\",\n data_list=[out2.force.AGSF],\n legend_list=[\"Periodic\", \"Full\"],\n save_path=join(save_path, simu.name + \"_P_space_fft.png\"),\n is_show_fig=False,\n **dict_2D\n )\n\n out.force.AGSF.plot_2D_Data(\n \"freqs\",\n \"angle[0]\",\n data_list=[out2.force.AGSF],\n legend_list=[\"Periodic\", \"Full\"],\n save_path=join(save_path, simu.name + \"_P_fft2.png\"),\n is_show_fig=False,\n **dict_2D\n )\n\n out.mag.Tem.plot_2D_Data(\n \"time\",\n data_list=[out2.mag.Tem],\n legend_list=[\"Periodic\", \"Full\"],\n save_path=join(save_path, simu.name + \"_Tem_time.png\"),\n is_show_fig=False,\n **dict_2D\n )\n\n out.mag.Phi_wind_stator.plot_2D_Data(\n \"time\",\n \"phase\",\n data_list=[out2.mag.Phi_wind_stator],\n legend_list=[\"Periodic\", \"Full\"],\n save_path=join(save_path, simu.name + \"_Phi_wind_stator_time.png\"),\n is_show_fig=False,\n **dict_2D\n )\n\n # Compare both simu with B\n Bflux = out.mag.B\n arg_list = [\"time\"]\n result = Bflux.get_rphiz_along(*arg_list)\n Brad = result[\"radial\"]\n time = result[\"time\"]\n\n # Check Flux spatio-temporal reconstruction full\n Bflux2 = out2.mag.B\n arg_list = [\"time\"]\n result2 = Bflux2.get_rphiz_along(*arg_list)\n Brad2 = result2[\"radial\"]\n time = result2[\"time\"]\n\n assert_array_almost_equal(Brad, Brad2, decimal=2)\n\n # Compare both simu with AGSF\n AGSF = out.force.AGSF\n arg_list = [\"time\"]\n result_AGSF = AGSF.get_rphiz_along(*arg_list)\n Prad = result_AGSF[\"radial\"]\n time = result_AGSF[\"time\"]\n\n AGSF2 = out2.force.AGSF\n arg_list = [\"time\"]\n result_AGSF2 = AGSF2.get_rphiz_along(*arg_list)\n Prad2 = result_AGSF2[\"radial\"]\n time = result_AGSF2[\"time\"]\n\n assert_array_almost_equal(Prad / 1000, Prad2 / 1000, decimal=0)\n\n return out, out2"},"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 test_FEMM_periodicity_angle():\n\n SPMSM_015 = load(join(DATA_DIR, \"Machine\", \"SPMSM_015.json\"))\n\n assert SPMSM_015.comp_periodicity() == (9, False, 9, True)\n\n simu = Simu1(name=\"test_FEMM_periodicity_angle\", machine=SPMSM_015)\n\n # Definition of the enforced output of the electrical module\n I0_rms = 250 / sqrt(2)\n Phi0 = 140 * pi / 180 # Maximum Torque Per Amp\n\n Id_ref = (I0_rms * exp(1j * Phi0)).real\n Iq_ref = (I0_rms * exp(1j * Phi0)).imag\n\n simu.input = InputCurrent(\n Id_ref=Id_ref,\n Iq_ref=Iq_ref,\n Na_tot=252 * 9,\n Nt_tot=4 * 9,\n N0=1000,\n )\n\n # Definition of the magnetic simulation: with periodicity\n simu.mag = MagFEMM(\n type_BH_stator=1,\n type_BH_rotor=1,\n is_periodicity_a=True,\n is_periodicity_t=False,\n nb_worker=cpu_count(),\n Kmesh_fineness=2,\n )\n simu.force = ForceMT()\n\n # Definition of the magnetic simulation: no periodicity\n # Definition of the magnetic simulation: no periodicity\n simu2 = simu.copy()\n simu2.mag.is_periodicity_a = False\n\n simu2.force = ForceMT()\n\n # Run simulations\n out = Output(simu=simu)\n simu.run()\n\n out2 = Output(simu=simu2)\n simu2.run()\n\n # Plot the result\n out.mag.B.plot_2D_Data(\n \"time\",\n \"angle[0]{°}\",\n data_list=[out2.mag.B],\n legend_list=[\"Periodic\", \"Full\"],\n save_path=join(save_path, simu.name + \"_B_time.png\"),\n is_show_fig=False,\n **dict_2D\n )\n\n out.mag.B.plot_2D_Data(\n \"angle{°}\",\n \"time[1]\",\n data_list=[out2.mag.B],\n legend_list=[\"Periodic\", \"Full\"],\n save_path=join(save_path, simu.name + \"_B_space.png\"),\n is_show_fig=False,\n **dict_2D\n )\n\n out.force.AGSF.plot_2D_Data(\n \"wavenumber=[0,100]\",\n \"time[0]\",\n data_list=[out2.force.AGSF],\n legend_list=[\"Periodic\", \"Full\"],\n save_path=join(save_path, simu.name + \"_P_space_fft.png\"),\n is_show_fig=False,\n **dict_2D\n )\n\n out.force.AGSF.plot_2D_Data(\n \"freqs\",\n \"angle[0]\",\n data_list=[out2.force.AGSF],\n legend_list=[\"Periodic\", \"Full\"],\n save_path=join(save_path, simu.name + \"_P_fft2.png\"),\n is_show_fig=False,\n **dict_2D\n )\n\n out.mag.Tem.plot_2D_Data(\n \"time\",\n data_list=[out2.mag.Tem],\n legend_list=[\"Periodic\", \"Full\"],\n save_path=join(save_path, simu.name + \"_Tem_time.png\"),\n is_show_fig=False,\n **dict_2D\n )\n\n out.mag.Phi_wind_stator.plot_2D_Data(\n \"time\",\n \"phase\",\n data_list=[out2.mag.Phi_wind_stator],\n legend_list=[\"Periodic\", \"Full\"],\n save_path=join(save_path, simu.name + \"_Phi_wind_stator_time.png\"),\n is_show_fig=False,\n **dict_2D\n )\n\n # Compare both simu\n Bflux = out.mag.B\n arg_list = [\"angle\"]\n result = Bflux.get_rphiz_along(*arg_list)\n Brad = result[\"radial\"]\n angle = result[\"angle\"]\n\n Bflux2 = out2.mag.B\n arg_list = [\"angle\"]\n result2 = Bflux2.get_rphiz_along(*arg_list)\n Brad2 = result2[\"radial\"]\n\n assert_array_almost_equal(Brad, Brad2, decimal=1)\n\n return out, out2","def test_mag_form_fac_case1():\n ion = MagneticFormFactor('Fe')\n formfac, _temp = ion.calc_mag_form_fac()[0], ion.calc_mag_form_fac()[1:]\n del _temp\n assert (abs(np.sum(formfac) - 74.155233575216599) < 1e-12)","def test_mag_form_fac():\n ion = MagneticFormFactor('Fe')\n formfac, _temp = ion.calc_mag_form_fac(q=1.)[0], ion.calc_mag_form_fac(q=1.)[1:]\n del _temp\n assert (abs(formfac - 0.932565) < 1e-6)","def test_mag_form_fac_case2():\n ion = MagneticFormFactor('Fe')\n formfac, _temp = ion.calc_mag_form_fac(qrange=[0, 2])[0], ion.calc_mag_form_fac(qrange=[0, 2])[1:]\n del _temp\n assert (abs(np.sum(formfac) - 74.155233575216599) < 1e-12)","def test_library_charges_monatomic_ions(self, monatomic_ion, formal_charge):\n ff = ForceField(\n get_data_file_path(\"test_forcefields/test_forcefield.offxml\"),\n get_data_file_path(\"test_forcefields/ion_charges.offxml\"),\n )\n mol = Molecule.from_smiles(\"[{}]\".format(monatomic_ion))\n omm_system = ff.create_openmm_system(mol.to_topology())\n\n nonbondedForce = [\n f for f in omm_system.getForces() if type(f) == NonbondedForce\n ][0]\n q, _, _ = nonbondedForce.getParticleParameters(0)\n assert q == formal_charge","def test_FEMM_periodicity_time_no_periodicity_a():\n\n SPMSM_015 = load(join(DATA_DIR, \"Machine\", \"SPMSM_015.json\"))\n\n assert SPMSM_015.comp_periodicity() == (9, False, 9, True)\n\n simu = Simu1(name=\"test_FEMM_periodicity_time_no_periodicity_a\", machine=SPMSM_015)\n\n # Definition of the enforced output of the electrical module\n I0_rms = 250 / sqrt(2)\n Phi0 = 140 * pi / 180 # Maximum Torque Per Amp\n\n Id_ref = (I0_rms * exp(1j * Phi0)).real\n Iq_ref = (I0_rms * exp(1j * Phi0)).imag\n\n simu.input = InputCurrent(\n Id_ref=Id_ref,\n Iq_ref=Iq_ref,\n Na_tot=252 * 9,\n Nt_tot=4 * 9,\n N0=1000,\n )\n\n # Definition of the magnetic simulation: with periodicity\n simu.mag = MagFEMM(\n type_BH_stator=1,\n type_BH_rotor=1,\n is_periodicity_a=False,\n is_periodicity_t=True,\n nb_worker=cpu_count(),\n Kmesh_fineness=2,\n )\n simu.force = ForceMT()\n\n # Definition of the magnetic simulation: no periodicity\n simu2 = simu.copy()\n simu2.mag.is_periodicity_t = False\n\n # Run simulations\n out = Output(simu=simu)\n simu.run()\n\n out2 = Output(simu=simu2)\n simu2.run()\n\n # Plot the result\n out.mag.B.plot_2D_Data(\n \"time\",\n \"angle[0]{°}\",\n data_list=[out2.mag.B],\n legend_list=[\"Periodic\", \"Full\"],\n save_path=join(save_path, simu.name + \"_B_time.png\"),\n is_show_fig=False,\n **dict_2D\n )\n\n out.mag.B.plot_2D_Data(\n \"angle{°}\",\n \"time[1]\",\n data_list=[out2.mag.B],\n legend_list=[\"Periodic\", \"Full\"],\n save_path=join(save_path, simu.name + \"_B_space.png\"),\n is_show_fig=False,\n **dict_2D\n )\n\n out.force.AGSF.plot_2D_Data(\n \"wavenumber=[0,100]\",\n \"time[0]\",\n data_list=[out2.force.AGSF],\n legend_list=[\"Periodic\", \"Full\"],\n save_path=join(save_path, simu.name + \"_P_space_fft.png\"),\n is_show_fig=False,\n **dict_2D\n )\n\n out.force.AGSF.plot_2D_Data(\n \"freqs\",\n \"angle[0]\",\n data_list=[out2.force.AGSF],\n legend_list=[\"Periodic\", \"Full\"],\n save_path=join(save_path, simu.name + \"_P_fft2.png\"),\n is_show_fig=False,\n **dict_2D\n )\n\n out.mag.Tem.plot_2D_Data(\n \"time\",\n data_list=[out2.mag.Tem],\n legend_list=[\"Periodic\", \"Full\"],\n save_path=join(save_path, simu.name + \"_Tem_time.png\"),\n is_show_fig=False,\n **dict_2D\n )\n\n out.mag.Phi_wind_stator.plot_2D_Data(\n \"time\",\n \"phase\",\n data_list=[out2.mag.Phi_wind_stator],\n legend_list=[\"Periodic\", \"Full\"],\n save_path=join(save_path, simu.name + \"_Phi_wind_stator_time.png\"),\n is_show_fig=False,\n **dict_2D\n )\n\n Bflux = out.mag.B\n arg_list = [\"time\"]\n result = Bflux.get_rphiz_along(*arg_list)\n Brad = result[\"radial\"]\n time = result[\"time\"]\n\n Bflux2 = out2.mag.B\n arg_list = [\"time\"]\n result2 = Bflux2.get_rphiz_along(*arg_list)\n Brad2 = result2[\"radial\"]\n time2 = result2[\"time\"]\n\n # Compare both simu\n assert_array_almost_equal((Brad - Brad2) / Brad2, 0, decimal=2)\n assert_array_almost_equal(time, time2, decimal=6)\n\n AGSF = out.force.AGSF\n arg_list = [\"time\"]\n result_AGSF = AGSF.get_rphiz_along(*arg_list)\n Prad = result_AGSF[\"radial\"]\n time3 = result_AGSF[\"time\"]\n\n AGSF2 = out2.force.AGSF\n arg_list = [\"time\"]\n result_AGSF2 = AGSF2.get_rphiz_along(*arg_list)\n Prad2 = result_AGSF2[\"radial\"]\n time4 = result_AGSF2[\"time\"]\n\n # Compare both simu\n assert_array_almost_equal((Prad - Prad2) / Prad2, 0, decimal=2)\n assert_array_almost_equal(time3, time4, decimal=6)\n\n return out, out2","def check(self, X):\n if (np.min(X) < -90.) or (np.max(X) > 90.):\n print \"Warning: X may be defined in degrees instead of radians\"","def check_force_parameters(self, skipImpropers = False):\n self.check_bonds(self.bond_force0, self.bond_force1)\n self.check_angles(self.angle_force0, self.angle_force1)\n self.check_nonbonded(self.nonbonded_force0, self.nonbonded_force1)\n self.check_proper_torsions(self.torsion_force0, self.torsion_force1, self.bond_force0, self.bond_force1)\n if not skipImpropers:\n self.check_improper_torsions(self.torsion_force0, self.torsion_force1, self.bond_force0, self.bond_force1)\n logger.info(\"Note: skipping degenerate impropers with < 4 atoms.\")","def test_assign_charges_using_library_charges_by_single_atoms(self):\n ff = ForceField(\n get_data_file_path(\"test_forcefields/test_forcefield.offxml\"),\n xml_ethanol_library_charges_by_atom_ff,\n )\n\n molecules = [\n Molecule.from_file(get_data_file_path(\"molecules/ethanol.sdf\")),\n Molecule.from_file(get_data_file_path(\"molecules/ethanol_reordered.sdf\")),\n ]\n top = Topology.from_molecules(molecules)\n omm_system = ff.create_openmm_system(top)\n nonbondedForce = [\n f for f in omm_system.getForces() if type(f) == NonbondedForce\n ][0]\n expected_charges = [\n -0.2,\n -0.1,\n 0.3,\n 0.08,\n -0.02,\n -0.02,\n -0.02,\n -0.01,\n -0.01,\n -0.2,\n 0.3,\n -0.1,\n 0.08,\n -0.02,\n -0.02,\n -0.02,\n -0.01,\n -0.01,\n ] * openmm_unit.elementary_charge\n for particle_index, expected_charge in enumerate(expected_charges):\n q, _, _ = nonbondedForce.getParticleParameters(particle_index)\n assert q == expected_charge","def test_check_compact_axis_angle():\n a_list = [0, 0, 0]\n a = pr.check_compact_axis_angle(a_list)\n assert_array_almost_equal(a_list, a)\n assert_equal(type(a), np.ndarray)\n assert_equal(a.dtype, np.float64)\n\n random_state = np.random.RandomState(0)\n a = pr.norm_vector(pr.random_vector(random_state, 3))\n a *= np.pi + random_state.randn() * 4.0 * np.pi\n a2 = pr.check_compact_axis_angle(a)\n pr.assert_compact_axis_angle_equal(a, a2)\n assert_greater(np.linalg.norm(a2), 0)\n assert_greater(np.pi, np.linalg.norm(a2))\n\n assert_raises_regexp(\n ValueError, \"Expected axis and angle in array with shape\",\n pr.check_compact_axis_angle, np.zeros(4))\n assert_raises_regexp(\n ValueError, \"Expected axis and angle in array with shape\",\n pr.check_compact_axis_angle, np.zeros((3, 3)))","def comp_angle_magnet(self):\n Rbo = self.get_Rbo()\n W0 = self.comp_W0m()\n Harc = self.comp_H_arc()\n if self.is_outwards():\n return float(2 * arctan(W0 / (2 * (Rbo + self.H1 - Harc))))\n else:\n return float(2 * arctan(W0 / (2 * (Rbo - self.H1 - Harc))))\n\n # if self.W0_is_rad:\n # return self.W0\n # else: # Convert W0 from m to rad\n # Rbo = self.get_Rbo()\n # return float(2 * arcsin(self.W0 / (2 * Rbo)))","def _forces_moments(self, delta):\n # assert delta.shape == (4,1)\n da = delta[0]\n de = delta[1]\n dt = delta[2]\n dr = delta[3]\n\n e0 = self._state[3]\n e1 = self._state[4]\n e2 = self._state[5]\n e3 = self._state[6]\n u = self._state[7]\n v = self._state[8]\n w = self._state[9]\n p = self._state[10]\n q = self._state[11]\n r = self._state[12]\n\n self._Va = np.sqrt(u**2 + v**2 + w**2)\n self._alpha = np.arctan(1.0*w/u)\n self._beta = np.arcsin(1.0*v/self._Va)\n\n\n\n Fg = self.mass*self.gravity*np.array([2*(e1*e3-e2*e0),\n 2*(e2*e3 + e1*e0),\n e3**2 + e0**2 - e1**2 - e2**2,\n ])\n\n # Fg = self.mass*self.gravity*np.array([2*(e1*e3 - e2*e0),\n # 2*(e2*e3 + e1*e0),\n # e3**2 + e0**2 - e1**2 - e2**2,\n # ])\n\n M_e = 25\n sig = lambda a: (1+np.exp(-M_e*(a-self.alpha0))+np.exp(M_e*(a+self.alpha0)))/((1+np.exp(-M_e*(a-self.alpha0)))*(1+np.exp(M_e*(a+self.alpha0))))\n cla = lambda a: (1-sig(a))*(self.C_L_0+self.C_L_alpha*a)+sig(a)*(2*np.sign(a)*np.sin(a)**2*np.cos(a))\n cda = lambda a: self.C_D_p + (self.C_L_0+self.C_L_alpha*a)**2/(np.pi*self.e*self.AR)\n\n cxa = lambda a: -(cda(a)) * np.cos(a) + (cla(a)) * np.sin(a)\n\n cxq = lambda a: -self.C_D_q * np.cos(a) +self.C_L_q * np.sin(a)\n\n cxde = lambda a: -self.C_D_delta_e * np.cos(a) + self.C_L_delta_e * np.sin(a)\n\n cza = lambda a: -(cda(a)) * np.sin(a) - (cla(a)) * np.cos(a)\n\n czq = lambda a: -self.C_D_q * np.sin(a) - self.C_L_q * np.cos(a)\n\n czde = lambda a: -self.C_D_delta_e * np.sin(a) - self.C_L_delta_e * np.cos(a)\n\n c = self.c/(2.0*self._Va)\n b = self.b/(2.0*self._Va)\n\n\n\n one = 0.5*self.rho*self._Va**2*self.S_wing\n # two = np.array([[1,0,0],[0,1,0],[0,0,1]])\n three = np.array([[cxa(self._alpha)+cxq(self._alpha)*c*q+cxde(self._alpha)*de],\n [self.C_Y_0+self.C_Y_beta*self._beta+self.C_Y_p*b*p+self.C_Y_r*b*r+self.C_Y_delta_a*da+self.C_Y_delta_r*dr],\n [cza(self._alpha)+czq(self._alpha)*c*q+czde(self._alpha)*de]])\n\n Fa = np.squeeze(three) * one\n # pdb.set_trace()\n Fa = Fa.reshape((3,-1))\n\n F = Fg + Fa\n #\n # print(\"Fa:\",Fa)\n\n Fp = 0.5*self.rho*self.S_prop*self.C_prop*((self.k_motor*dt)**2-self._Va**2)\n\n # print(\"FP:\", Fp)\n\n fx = F[0] + Fp\n # + 0.5*MAV.rho*self._Va**2*MAV.S_wing*(\\\n # +cxa(self._alpha)\\\n # + cxq(self._alpha)*c*q\\\n # + cxde(self._alpha)*de\n # )\n\n fy = F[1]\n fz = F[2]\n\n # Moment time!!!\n one = 0.5*self.rho*self._Va**2*self.S_wing\n two = np.array([\\\n [self.b*(self.C_ell_0+self.C_ell_beta*self._beta+self.C_ell_p*b*p+self.C_ell_r*b*r+self.C_ell_delta_a*da+self.C_ell_delta_r*dr)],\n [self.c*(self.C_m_0+(self.C_m_alpha*self._alpha)+(self.C_m_q*c*q)+(self.C_m_delta_e*de))],\n [self.b*(self.C_n_0+(self.C_n_beta*self._beta)+(self.C_n_p*b*p)+(self.C_n_r*b*r)+(self.C_n_delta_a*da)+(self.C_n_delta_r*dr))]\n ])\n Ma = one * np.squeeze(two)\n # print(\"\\nMa:\", Ma)\n # pdb.set_trace()\n Ma = Ma.reshape((3,-1))\n\n size = Ma.shape[1]\n\n Mp = np.block([[np.ones(size)*-self.kTp*(self.kOmega*dt)**2],\n [np.zeros(size)],\n [np.zeros(size)]\n ])\n\n M = Mp + Ma\n\n Mx = M[0]\n My = M[1]\n Mz = M[2]\n\n # self._forces[0] = fx\n # self._forces[1] = fy\n # self._forces[2] = fz\n # pdb.set_trace()\n # print(fx, fy, fz, Mx, My, Mz)\n\n return np.array([fx, fy, fz, Mx, My, Mz])","def test_library_charges_dont_parameterize_molecule_because_of_incomplete_coverage(\n self,\n ):\n molecules = [Molecule.from_file(get_data_file_path(\"molecules/toluene.sdf\"))]\n top = Topology.from_molecules(molecules)\n\n # The library charges in the FF should not be able to fully cover toluene\n ff = ForceField(\n get_data_file_path(\"test_forcefields/test_forcefield.offxml\"),\n xml_ethanol_library_charges_by_atom_ff,\n )\n # Delete the ToolkitAM1BCCHandler so the molecule won't get charges from anywhere\n del ff._parameter_handlers[\"ToolkitAM1BCC\"]\n with pytest.raises(\n RuntimeError, match=\"Cc1ccccc1 could not be fully assigned charges\"\n ):\n omm_system = ff.create_openmm_system(top)\n\n # If we do NOT delete the ToolkiAM1BCCHandler, then toluene should be assigned some nonzero partial charges.\n # The exact value will vary by toolkit, so we don't test that here.\n ff = ForceField(\n get_data_file_path(\"test_forcefields/test_forcefield.offxml\"),\n xml_ethanol_library_charges_by_atom_ff,\n )\n omm_system = ff.create_openmm_system(top)\n nonbondedForce = [\n f for f in omm_system.getForces() if type(f) == NonbondedForce\n ][0]\n for particle_index in range(top.n_atoms):\n q, _, _ = nonbondedForce.getParticleParameters(particle_index)\n assert q != 0 * unit.elementary_charge","def is_valid_angle(self, theta_step):\n return not (self.angle % theta_step)","def test_fractional_bondorder_invalid_interpolation_method(self):\n mol = create_ethanol()\n\n forcefield = ForceField(\n get_data_file_path(\"test_forcefields/test_forcefield.offxml\"), xml_ff_bo\n )\n forcefield.get_parameter_handler(\n \"ProperTorsions\"\n )._fractional_bondorder_interpolation = \"invalid method name\"\n topology = Topology.from_molecules([mol])\n\n # If important, this can be a custom exception instead of a verbose ValidationError\n with pytest.raises(\n ValidationError,\n match=\"given=invalid method name\",\n ):\n forcefield.create_openmm_system(\n topology,\n charge_from_molecules=[mol],\n )","def f_theta_omega(angles, times):\n # gravity = 9.81\n # arm_length = 0.1 \n\n # omega = angles[0]\n # theta = angles[1]\n # ftheta = omega\n # fomega = -(gravity/arm_length) * np.sin(theta)\n pass","def is_pure_magnetic(self):\n klist = [key for key in self.components if not self.component_is_zero(key)]\n return all([key.startswith('magnetic') for key in klist])","def test_charge_increment_model_forward_and_reverse_ethanol(self):\n file_path = get_data_file_path(\"test_forcefields/test_forcefield.offxml\")\n ff = ForceField(file_path, xml_charge_increment_model_ff_ethanol)\n del ff._parameter_handlers[\"ToolkitAM1BCC\"]\n top = Topology.from_molecules([create_ethanol(), create_reversed_ethanol()])\n sys = ff.create_openmm_system(top)\n nonbonded_force = [\n force\n for force in sys.getForces()\n if isinstance(force, openmm.NonbondedForce)\n ][0]\n expected_charges = [\n 0.2,\n -0.15,\n -0.05,\n 0.0,\n 0.0,\n 0.0,\n 0.0,\n 0.0,\n 0.0,\n 0.0,\n 0.0,\n 0.0,\n 0.0,\n 0.0,\n 0.0,\n -0.05,\n -0.15,\n 0.2,\n ] * openmm_unit.elementary_charge\n for idx, expected_charge in enumerate(expected_charges):\n charge, _, _ = nonbonded_force.getParticleParameters(idx)\n assert (\n abs(charge - expected_charge) < 1.0e-6 * openmm_unit.elementary_charge\n )","def test_float_input_angles(self):\n decomposer = OneQubitEulerDecomposer(\"PSX\")\n input_matrix = np.array(\n [\n [0.70710678, 0.70710678],\n [0.70710678, -0.70710678],\n ],\n dtype=np.float64,\n )\n (theta, phi, lam) = decomposer.angles(input_matrix)\n expected_theta = 1.5707963267948966\n expected_phi = 0.0\n expected_lam = 3.141592653589793\n self.assertAlmostEqual(theta, expected_theta)\n self.assertAlmostEqual(phi, expected_phi)\n self.assertAlmostEqual(lam, expected_lam)","def test_check_axis_angle():\n a_list = [1, 0, 0, 0]\n a = pr.check_axis_angle(a_list)\n assert_array_almost_equal(a_list, a)\n assert_equal(type(a), np.ndarray)\n assert_equal(a.dtype, np.float64)\n\n random_state = np.random.RandomState(0)\n a = np.empty(4)\n a[:3] = pr.random_vector(random_state, 3)\n a[3] = random_state.randn() * 4.0 * np.pi\n a2 = pr.check_axis_angle(a)\n pr.assert_axis_angle_equal(a, a2)\n assert_almost_equal(np.linalg.norm(a2[:3]), 1.0)\n assert_greater(a2[3], 0)\n assert_greater(np.pi, a2[3])\n\n assert_raises_regexp(\n ValueError, \"Expected axis and angle in array with shape\",\n pr.check_axis_angle, np.zeros(3))\n assert_raises_regexp(\n ValueError, \"Expected axis and angle in array with shape\",\n pr.check_axis_angle, np.zeros((3, 3)))","def test_float_input_angles_and_phase(self):\n decomposer = OneQubitEulerDecomposer(\"PSX\")\n input_matrix = np.array(\n [\n [0.70710678, 0.70710678],\n [0.70710678, -0.70710678],\n ],\n dtype=np.float64,\n )\n (theta, phi, lam, gamma) = decomposer.angles_and_phase(input_matrix)\n expected_theta = 1.5707963267948966\n expected_phi = 0.0\n expected_lam = 3.141592653589793\n expected_gamma = -0.7853981633974483\n self.assertAlmostEqual(theta, expected_theta)\n self.assertAlmostEqual(phi, expected_phi)\n self.assertAlmostEqual(lam, expected_lam)\n self.assertAlmostEqual(gamma, expected_gamma)","def check_nonbonded(self, force0, force1):\n\n assert type(force0) == type(force1), \"Error: force0 and force1 must be the same type.\"\n assert type(force0) == mm.NonbondedForce, \"Error: forces must be NonbondedForces\"\n assert force0.getNumParticles() == force1.getNumParticles(), \"Error: Systems have %d and %d particles in NonbondedForce, respectively.\" % (force0.getNumParticles(), force1.getNumParticles())\n\n n_atoms = force0.getNumParticles()\n\n q, sigma, epsilon = force0.getParticleParameters(0)\n #unit_q, unit_sigma, unit_epsilon = q.unit, sigma.unit, epsilon.unit\n unit_q = u.elementary_charge\n unit_sigma = u.angstrom\n unit_epsilon = u.kilojoule_per_mole\n\n for k in range(n_atoms):\n q0, sigma0, epsilon0 = force0.getParticleParameters(k)\n q1, sigma1, epsilon1 = force1.getParticleParameters(k)\n\n q0, sigma0, epsilon0 = q0 / unit_q, sigma0 / unit_sigma, epsilon0 / unit_epsilon\n q1, sigma1, epsilon1 = q1 / unit_q, sigma1 / unit_sigma, epsilon1 / unit_epsilon\n\n assert compare(q0, q1), \"Error: Particle %d has charges of %f and %f, respectively.\" % (k, q0, q1)\n\n if epsilon0 != 0.:\n assert compare(sigma0, sigma1), \"Error: Particle %d has sigma of %f and %f angstroms, respectively.\" % (k, sigma0, sigma1)\n else:\n logger.info(\"Skipping comparison of sigma (%f, %f) on particle %d because epsilon has values %f, %f kJ/mol\" % (sigma0, sigma1, k, epsilon0, epsilon1))\n\n assert compare(epsilon0, epsilon1), \"Error: Particle %d has epsilon of %f and %f kJ/mol, respectively.\" % (k, epsilon0, epsilon1)\n\n n_exceptions = force0.getNumExceptions()\n assert force0.getNumExceptions() == force1.getNumExceptions(), \"Error: Systems have %d and %d exceptions in NonbondedForce, respectively.\" % (force0.getNumExceptions(), force1.getNumExceptions())\n\n i0, i1, qq, sigma, epsilon = force0.getExceptionParameters(0)\n unit_qq = u.elementary_charge**2\n unit_sigma = u.angstrom\n unit_epsilon = u.kilojoule_per_mole\n\n dict0, dict1 = {}, {}\n for k in range(n_exceptions):\n i0, i1, qq, sigma, epsilon = force0.getExceptionParameters(k)\n i0, i1 = reorder_bonds(i0, i1)\n dict0[i0, i1] = ((qq / unit_qq, sigma / unit_sigma, epsilon / unit_epsilon))\n\n i0, i1, qq, sigma, epsilon = force1.getExceptionParameters(k)\n i0, i1 = reorder_bonds(i0, i1)\n dict1[i0, i1] = ((qq / unit_qq, sigma / unit_sigma, epsilon / unit_epsilon))\n\n keys0 = set(dict0.keys())\n keys1 = set(dict1.keys())\n logger.info(\"Exceptions0 - Exceptions1 = %s\" % (keys0.difference(keys1)))\n logger.info(\"Exceptions1 - Exceptions0 = %s\" % (keys1.difference(keys0)))\n assert set(dict0.keys()) == set(dict1.keys()), \"Systems have different NonBondedForce Exceptions\"\n\n for k, parameter_name in enumerate([\"qq\", \"sigma\", \"epsilon\"]):\n for (i0, i1) in dict0.keys():\n val0 = dict0[i0, i1][k]\n val1 = dict1[i0, i1][k]\n if parameter_name == \"sigma\" and dict0[i0, i1][2] == 0.0 and dict1[i0, i1][2] == 0.0:\n continue # If both epsilon parameters are zero, then sigma doesn't matter so skip the comparison.\n if parameter_name ==\"sigma\":\n assert compare(val0, val1), \"Error: NonBondedForce Exception, atom (%d, %d) has sigma values of %f and %f angstroms, respectively.\" % (i0, i1, parameter_name, val0, val1)\n elif parameter_name==\"qq\":\n assert compare(val0, val1), \"Error: NonBondedForce Exception atom (%d, %d) has squared charge values of %f and %f (elementary charge)**2, respectively.\" % (i0, i1, val0, val1)\n else:\n assert compare(val0, val1), \"Error: NonBondedForce Exception, atom (%d, %d) has epsilon values of %f and %f kJ/mol, respectively.\" % (i0, i1, val0, val1)","def comp_angle_opening_magnet(self):\n\n if self.W1 > 0:\n Rbo = self.get_Rbo()\n return float(2 * arcsin(self.W1 / (2 * Rbo)))\n else:\n return self.comp_angle_magnet()","def check_angles(self, force0, force1):\n\n assert type(force0) == type(force1), \"Error: force0 and force1 must be the same type.\"\n assert type(force0) == mm.HarmonicAngleForce, \"Error: forces must be HarmonicAngleForces\"\n\n n_angles0 = force0.getNumAngles()\n n_angles1 = force1.getNumAngles()\n\n dict0, dict1 = {}, {}\n\n i0, i1, i2, theta0, k0 = force0.getAngleParameters(0)\n #unit_theta = theta0.unit\n unit_theta = u.degrees\n #unit_k = k0.unit\n unit_k = u.kilojoules_per_mole/(u.degrees)**2\n\n for k in range(n_angles0):\n i0, i1, i2, theta0, k0 = force0.getAngleParameters(k)\n if (k0 / k0.unit) != 0.0: # Skip forces with strength 0.0\n i0, i1, i2 = reorder_angles(i0, i1, i2)\n dict0[i0, i1, i2] = ((theta0 / unit_theta, k0 / unit_k))\n\n for k in range(n_angles1):\n i0, i1, i2, theta0, k0 = force1.getAngleParameters(k)\n if (k0 / k0.unit) != 0.0: # Skip forces with strength 0.0\n i0, i1, i2 = reorder_angles(i0, i1, i2)\n dict1[i0, i1, i2] = ((theta0 / unit_theta, k0 / unit_k))\n\n keys0 = set(dict0.keys())\n keys1 = set(dict1.keys())\n logger.info(\"Angles0 - Angles1 = %s\" % (keys0.difference(keys1)))\n logger.info(\"Angles1 - Angles0 = %s\" % (keys1.difference(keys0)))\n diff_keys = keys0.symmetric_difference(keys1)\n assert diff_keys == set(), \"Systems have different HarmonicAngleForce entries: extra keys are: \\n%s\" % diff_keys\n\n for k, parameter_name in enumerate([\"theta0\", \"k0\"]):\n for (i0, i1, i2) in dict0.keys():\n val0 = dict0[i0, i1, i2][k]\n val1 = dict1[i0, i1, i2][k]\n if parameter_name=='theta0':\n assert compare(val0, val1), \"Error: Harmonic Angle (%d, %d, %d) has angle values of %f and %f degrees, respectively.\" % (i0, i1, i2, val0, val1)\n else:\n assert compare(val0, val1), \"Error: Harmonic Angle (%d, %d, %d) has force constant values of %f and %f kJ/(mol degree**2), respectively.\" % (i0, i1, i2, val0, val1)","def isSecondOblateAxis(alpha1, alpha2, beta1, beta2, maxDist, maxTorsAngle): \n a1 = np.asarray(alpha1)\n a2 = np.asarray(alpha2)\n b1 = np.asarray(beta1)\n b2 = np.asarray(beta2)\n #lent = alpha1 - beta1\n adir = a2 - a1\n bdir = b2 - b1\n aLength = np.sqrt ( np.dot(adir, adir) )\n bLength = np.sqrt ( np.dot(bdir, bdir) )\n DotProdNormed = np.dot(adir, bdir) / ( aLength * bLength ) \n maxTors = np.cos( np.radians( maxTorsAngle ))\n if (abs(DotProdNormed) > maxTors):\n # print beta1, beta2, \"not rectangular, angle = \", np.arccos(DotProdNormed)\n return False\n # print beta1, beta2, \"is rectangular.\" \n # find nearest point to alpha mid on the potential beta axis by bisection\n # midAlpha = [a2 + 0.5 * dAlph for a2, dAlph in zip(alpha2, dirAlpha)]\n axisDist = minimalDistance(a1, a2, b1, b2)\n# print \"Distance of\", a1, \"<->\", a2, \" to \", b1, \"<->\", b2, \"is\", axisDist\n #midBeta = [b2 + 0.5 * dBeta for b2, dBeta in zip(beta2, dirBeta)]\n if axisDist < maxDist:\n # print b1, \"<->\", b2, \"is possible axis\"\n return True\n else:\n # print b1, \"<->\", b2, \"is too far (\", axisDist ,\") from\", a1, \"<->\", a2, \", maximal allowed distance =\", maxDist\n return False","def test_axis_angle_from_compact_axis_angle():\n ca = [0.0, 0.0, 0.0]\n a = pr.axis_angle_from_compact_axis_angle(ca)\n assert_array_almost_equal(a, np.array([1.0, 0.0, 0.0, 0.0]))\n\n random_state = np.random.RandomState(1)\n for _ in range(5):\n ca = pr.random_compact_axis_angle(random_state)\n a = pr.axis_angle_from_compact_axis_angle(ca)\n assert_almost_equal(np.linalg.norm(ca), a[3])\n assert_array_almost_equal(ca[:3] / np.linalg.norm(ca), a[:3])","def test_compact_axis_angle():\n a = np.array([1.0, 0.0, 0.0, 0.0])\n ca = pr.compact_axis_angle(a)\n assert_array_almost_equal(ca, np.zeros(3))\n\n random_state = np.random.RandomState(0)\n for _ in range(5):\n a = pr.random_axis_angle(random_state)\n ca = pr.compact_axis_angle(a)\n assert_array_almost_equal(pr.norm_vector(ca), a[:3])\n assert_almost_equal(np.linalg.norm(ca), a[3])","def testCorrectForTwoAtomCellWithoutPeriodicityNEEDED(self):\n\t\texpDist = 0.01*10\n\t\tself._checkExpMatchesActual(expDist)","def _validate_mesh(self):\n if not (np.abs(self.axis_u.dot(self.axis_v) < 1e-6) and #pylint: disable=no-member\n np.abs(self.axis_v.dot(self.axis_w) < 1e-6) and #pylint: disable=no-member\n np.abs(self.axis_w.dot(self.axis_u) < 1e-6)): #pylint: disable=no-member\n raise ValueError('axis_u, axis_v, and axis_w must be orthogonal')\n return True","def test_comp_magnetostrictive_tensor_1cell():\n\n # Physical quantities\n dim = 2\n Nt_tot = 1\n\n mu = 1\n Be = np.array([[[mu / 2, 0]]])\n He = np.array([[[-1 / 2, 0]]])\n mue = np.array([[mu]])\n\n Me = np.reshape(Be / mue - He, (dim, 1, Nt_tot))\n\n alphaij = [[1, 0, 0], [1, 0, 0]]\n\n alpha1 = 1\n alpha2 = 1\n\n # Computation\n tensor = ForceTensor()\n\n tensor_comp = tensor.comp_magnetrosctrictive_tensor(\n mue, Me, Nt_tot, alphaij\n ) # Should be equal to -alpha1*mu*MM' - alpha2*mu*M²*I2\n\n assert tensor_comp[0, 0, 0] == -mu * (alpha1 + alpha2)\n assert tensor_comp[0, 1, 0] == 0\n assert tensor_comp[1, 0, 0] == 0\n assert tensor_comp[1, 1, 0] == -mu * alpha2\n\n print(\"test_comp_magnetostrictive_tensor succeeded\")\n\n return True","def check_these(phi, chi, omega):\n #Calculate the leg position from these angles\n self.getplatepos(phi, chi, omega)\n #Make sure the legs are not in fault\n self.check_limits()\n return (not any(self.leg_fault))","def test_get_partial_charges(self, force_field):\n ethanol: Molecule = create_ethanol()\n\n ethanol_partial_charges = from_openmm(\n self.get_partial_charges_from_create_openmm_system(ethanol, force_field)\n )\n\n partial_charges = force_field.get_partial_charges(ethanol)\n\n assert (\n ethanol_partial_charges - partial_charges < 1.0e-6 * unit.elementary_charge\n ).all()\n assert partial_charges.shape == (ethanol.n_atoms,)","def test_Force_Tensor_compforce():\n\n # 'axes_dict' input\n axes_dict = {\n \"Time\": [0],\n \"Angle\": [0],\n }\n\n # 'output' input\n\n # Mesh object\n\n mesh = MeshMat()\n mesh.cell[\"triangle3\"] = CellMat(nb_node_per_cell=3)\n mesh.node = NodeMat()\n\n mesh.node.add_node(np.array([0, 0]))\n mesh.node.add_node(np.array([0, 1]))\n mesh.node.add_node(np.array([1, 0]))\n\n nodes_test = np.array([0, 1, 2])\n mesh.add_cell(nodes_test, \"triangle3\")\n\n # Mag object\n Time = Data1D(name=\"time\", values=[0], is_components=True)\n indices_cell = [0]\n Indices_Cell = Data1D(name=\"indice\", values=indices_cell, is_components=True)\n axis_list = [Time, Indices_Cell]\n\n mu = 1\n\n B_elem = np.array([[[mu / 2, 0]]])\n H_elem = np.array([[[1 / 2, 0]]])\n mu_elem = np.array([[mu]])\n\n B_sol = build_solution_vector(\n field=B_elem,\n axis_list=axis_list,\n name=\"Magnetic Flux Density\",\n symbol=\"B\",\n unit=\"T\",\n )\n H_sol = build_solution_vector(\n field=H_elem,\n axis_list=axis_list,\n name=\"Magnetic Field\",\n symbol=\"H\",\n unit=\"A/m\",\n )\n mu_sol = build_solution_data(\n field=mu_elem,\n axis_list=axis_list,\n name=\"Magnetic Permeability\",\n symbol=\"mu\",\n unit=\"H/m\",\n )\n\n list_solution = [B_sol, H_sol, mu_sol]\n\n out_dict[\"meshsolution\"] = build_meshsolution(\n list_solution=list_solution,\n label=\"FEMM 2D Magnetostatic\",\n list_mesh=meshFEMM,\n group=groups,\n )","def check_validity(self,check_derivative=True,verbose=True):\n is_valid = True\n if self.f0(0.0)!=0.0:\n is_valid = False\n if verbose:\n print(\"DynamicalSystem: Warning: The system does \"+\n \"not satisfy f0(0)=0 (f(0)=\",self.f0(0.0),\")\")\n if self.f1(1.0)!=1.0:\n is_valid = False\n if verbose:\n print(\"DynamicalSystem: Warning: The system does \"+\n \"not satisfy f0(1)=1 (f1(1)=\",self.f1(1.0),\")\")\n if self.rho_max<self.rho_min:\n is_valid = False\n if verbose:\n print(\"DynamicalSystem: Warning: The system does \"+\n \"not satisfy rho_max>=rho_min (rho_min,rho_max=\",\n rho_min,rho_max,\")\")\n if check_derivative:\n # Coarse check if the derivative is bounded below by some d>1\n # Note it is sufficient to check the restricted ranges given\n xs0 = np.linspace(0.0,self.rho_max,129)\n xs1 = np.linspace(self.rho_min,1.0,129)\n d = np.min(np.concatenate((self.df0(xs0),self.df1(xs1))))\n if d<=1.0:\n is_valid = False\n if verbose:\n print(\"DynamicalSystem: Warning: The system does \"+\n \"not satisfy: d>1 (d<=\",d,\")\")\n return is_valid","def check_angle(self):\n self.find_pixels()\n alpha_theta=np.deg2rad(70)\n alpha_phi=np.deg2rad(70)\n extreme_values=self.compute_extreme_values(alpha_phi, alpha_theta)\n x=np.linspace(extreme_values[0], extreme_values[1], self.number_of_pix[1])\n y=np.linspace(extreme_values[2], extreme_values[3], self.number_of_pix[0])\n phi_0=20\n phi_0=np.deg2rad(phi_0)\n j, diff=self.compute_phi(\"find_orient.png\")\n print \"j=\", j\n print \"diff=\", diff","def test_field():\n\n # Using mesh with radius 10 nm (nmag ex. 1)\n mesh = from_geofile(os.path.join(MODULE_DIR, \"sphere1.geo\"))\n S3 = df.VectorFunctionSpace(mesh, \"Lagrange\", 1)\n m_function = df.interpolate(df.Constant((1, 0, 0)), S3)\n m = Field(S3, m_function)\n\n demag = Demag()\n demag.setup(m, Field(df.FunctionSpace(mesh, 'DG', 0), Ms), unit_length=1e-9)\n\n # Compute demag field\n H_demag = demag.compute_field()\n H_demag.shape = (3, -1)\n x, y, z = H_demag[0], H_demag[1], H_demag[2]\n\n print \"Max values in direction:\"\n print \"x: %g, y: %g, z: %g\" % (max(x), max(y), max(z))\n print \"Min values in direction:\"\n print \"x: %g, y: %g, z: %g\" % (min(x), min(y), min(z))\n\n x, y, z = average(x), average(y), average(z)\n print \"Average values in direction\"\n print \"x: %g, y: %g, z: %g\" % (x, y, z)\n\n # Compute relative erros\n x = abs((x + 1./3*Ms)/Ms)\n y = abs(y/Ms)\n z = abs(z/Ms)\n\n print \"Relative error:\"\n print \"x: %g, y: %g, z: %g\" % (x, y, z)\n assert x < TOL, \"x-average is %g, should be -1/3.\" % x\n assert y < TOL, \"y-average is %g, should be zero.\" % y\n assert z < TOL, \"z-average is %g, should be zero.\" % z","def read_force_field(ff_file, units=\"Angstrom\", fragment_id=AtomicData.atomic_number):\n fh = open(ff_file)\n line = fh.readline()\n # read number of atoms\n nat = int(line.split()[0])\n # skip comment\n fh.readline()\n #\n atomlist = []\n atomtypes = []\n partial_charges = []\n lattice_vectors = []\n for i in xrange(nat+3):\n # read nat atoms and at most 3 lattice vectors\n line = fh.readline()\n if not line:\n # end of file reached\n break\n words = line.split()\n x,y,z = map(float, words[1:4])\n if units == \"Angstrom\":\n x,y,z = map(lambda c: c/AtomicData.bohr_to_angs, [x,y,z])\n if words[0] == \"Tv\":\n lattice_vectors.append( [x,y,z] )\n continue\n atno = fragment_id(words[0])\n atomlist.append((atno, [x,y,z]))\n atomtypes.append(int(words[4]))\n if len(words) > 5:\n # 6th column contains partial charges\n partial_charges.append( float(words[5]) )\n else:\n partial_charges.append( 0.0 ) \n fh.close()\n if lattice_vectors == []:\n print \"No lattice vectors found\"\n # no lattice vectors were provided\n # HACK: By setting a lattice vectors to 0, we tell\n # the function 'build_force_field' that we do not want\n # a periodic calculation in this direction.\n # If all lattice vectors are 0, only the atoms in the central\n # unit cell are included (number of replica cells == 0)\n lattice_vectors = [ [0.0, 0.0, 0.0],\n [0.0, 0.0, 0.0],\n [0.0, 0.0, 0.0] ]\n\n assert len(lattice_vectors) == 3, \"Need 3 lattice vectors, got %d!\" % len(lattice_vectors)\n return atomlist, atomtypes, partial_charges, lattice_vectors","def test_assign_charges_to_molecule_in_parts_using_multiple_library_charges(self):\n ff = ForceField(\n get_data_file_path(\"test_forcefields/test_forcefield.offxml\"),\n xml_ethanol_library_charges_in_parts_ff,\n )\n\n molecules = [\n Molecule.from_file(get_data_file_path(\"molecules/ethanol.sdf\")),\n Molecule.from_file(get_data_file_path(\"molecules/ethanol_reordered.sdf\")),\n ]\n top = Topology.from_molecules(molecules)\n omm_system = ff.create_openmm_system(top)\n nonbondedForce = [\n f for f in omm_system.getForces() if type(f) == NonbondedForce\n ][0]\n expected_charges = [\n -0.2,\n -0.1,\n 0.3,\n 0.08,\n -0.02,\n -0.02,\n -0.02,\n -0.01,\n -0.01,\n -0.2,\n 0.3,\n -0.1,\n 0.08,\n -0.02,\n -0.02,\n -0.02,\n -0.01,\n -0.01,\n ] * openmm_unit.elementary_charge\n for particle_index, expected_charge in enumerate(expected_charges):\n q, _, _ = nonbondedForce.getParticleParameters(particle_index)\n assert q == expected_charge","def test_get_moment_of_inertia_tensor(self):\n symbols = ['O', 'C', 'C', 'H', 'H', 'H', 'H', 'H', 'H']\n coords = np.array([[1.28706525, 0.52121353, 0.04219198],\n [0.39745682, -0.35265044, -0.63649234],\n [0.36441173, -1.68197093, 0.08682400],\n [-0.59818222, 0.10068325, -0.65235399],\n [0.74799641, -0.48357798, -1.66461710],\n [0.03647269, -1.54932006, 1.12314420],\n [-0.31340646, -2.38081353, -0.41122551],\n [1.36475837, -2.12581592, 0.12433596],\n [2.16336803, 0.09985803, 0.03295192]], np.float64)\n tensor = get_moment_of_inertia_tensor(coords=coords, symbols=symbols)\n expected_tensor = [[50.24197604, -15.43600683, -3.07977736],\n [-15.43600683, 22.20416597, 2.5935549],\n [-3.07977736, 2.5935549, 55.49144794]]\n np.testing.assert_almost_equal(tensor, expected_tensor)","def test_fractional_bondorder_multiple_same_mol(self):\n\n mol = create_ethanol()\n mol2 = create_reversed_ethanol()\n\n forcefield = ForceField(\n get_data_file_path(\"test_forcefields/test_forcefield.offxml\"),\n xml_ff_bo,\n )\n topology = Topology.from_molecules([mol, mol2])\n\n with pytest.raises(ValueError):\n forcefield.create_openmm_system(\n topology,\n charge_from_molecules=[mol],\n partial_bond_orders_from_molecules=[mol, mol2],\n )","def test_conversions_matrix_axis_angle_continuous():\n for angle in np.arange(3.1, 3.2, 0.01):\n a = np.array([1.0, 0.0, 0.0, angle])\n R = pr.matrix_from_axis_angle(a)\n pr.assert_rotation_matrix(R)\n\n a2 = pr.axis_angle_from_matrix(R)\n pr.assert_axis_angle_equal(a, a2)\n\n R2 = pr.matrix_from_axis_angle(a2)\n assert_array_almost_equal(R, R2)\n pr.assert_rotation_matrix(R2)","def ft_ext_force(self):\r\n return self._arm.ft_ext_force","def check_proper_torsions(self, force0, force1, bond_force0, bond_force1):\n\n assert type(force0) == type(force1), \"Error: force0 and force1 must be the same type.\"\n assert type(force0) == mm.PeriodicTorsionForce, \"Error: forces must be PeriodicTorsionForce\"\n\n bond_set0 = get_symmetrized_bond_set(bond_force0)\n bond_set1 = get_symmetrized_bond_set(bond_force1)\n\n # Build list of atoms to help make output more useful\n atoms0 = [ atom for atom in self.simulation0.topology.atoms() ]\n atoms1 = [ atom for atom in self.simulation1.topology.atoms() ]\n\n\n # Check torsions for equivalent\n\n if force0.getNumTorsions() == 0 and force1.getNumTorsions() == 0:\n return # Must leave now, otherwise try to access torsions that don't exist.\n\n F = force0 if force0.getNumTorsions() > 0 else force1 # Either force0 or force1 is nonempty, so find that one.\n i0, i1, i2, i3, per, phase, k0 = F.getTorsionParameters(0)\n #phase_unit, k0_unit = phase.unit, k0.unit\n k0_unit = u.kilojoules_per_mole\n phase_unit = u.degrees\n\n dict0, dict1 = {}, {}\n for k in range(force0.getNumTorsions()):\n i0, i1, i2, i3, per, phase, k0 = force0.getTorsionParameters(k)\n if not is_proper(i0, i1, i2, i3, bond_set0):\n continue\n\n i0, i1, i2, i3 = reorder_proper_torsions(i0, i1, i2, i3)\n\n phase, k0 = phase / phase_unit, k0 / k0_unit\n if k0 == 0.0:\n continue\n\n if not (i0, i1, i2, i3) in dict0:\n dict0[i0, i1, i2, i3] = []\n\n dict0[i0, i1, i2, i3].append((per, phase, k0))\n\n for k in range(force1.getNumTorsions()):\n i0, i1, i2, i3, per, phase, k0 = force1.getTorsionParameters(k)\n if not is_proper(i0, i1, i2, i3, bond_set1):\n continue\n\n i0, i1, i2, i3 = reorder_proper_torsions(i0, i1, i2, i3)\n\n phase, k0 = phase / phase_unit, k0 / k0_unit\n if k0 == 0.0:\n continue\n\n if not (i0, i1, i2, i3) in dict1:\n dict1[i0, i1, i2, i3] = []\n\n dict1[i0, i1, i2, i3].append((per, phase, k0))\n\n keys0 = set(dict0.keys())\n keys1 = set(dict1.keys())\n diff_keys = keys0.symmetric_difference(keys1)\n\n logger.info(\"Propers0 - Propers1 = %s\" % (keys0.difference(keys1)))\n logger.info(\"Propers1 - Propers0 = %s\" % (keys1.difference(keys0)))\n assert diff_keys == set(), \"Systems have different (proper) PeriodicTorsionForce entries: extra keys are: \\n%s\" % diff_keys\n\n for (i0, i1, i2, i3) in dict0.keys():\n # Store strings for printing debug info\n torsion_atoms0 = '%s - %s - %s - %s' % (atoms0[i0].name, atoms0[i1].name, atoms0[i2].name, atoms0[i3].name )\n torsion_atoms1 = '%s - %s - %s - %s' % (atoms1[i0].name, atoms1[i1].name, atoms1[i2].name, atoms1[i3].name )\n\n # Proceed to check\n entries0 = dict0[i0, i1, i2, i3]\n entries1 = dict1[i0, i1, i2, i3]\n if len(entries0) != len(entries1):\n print(\"Compared torsion involving atoms '%s' with that involving atoms '%s': \" % (torsion_atoms0, torsion_atoms1))\n raise Exception(\"Error: (proper) PeriodicTorsionForce entry (atoms %d, %d, %d, %d) has different numbers of terms (%d and %d, respectively).\" % (i0, i1, i2, i3, len(entries0), len(entries1)))\n\n subdict0 = dict(((per, reduce_precision(phase)), k0) for (per, phase, k0) in entries0)\n subdict1 = dict(((per, reduce_precision(phase)), k0) for (per, phase, k0) in entries1)\n\n if set(subdict0.keys()) != set(subdict1.keys()):\n print(\"Compared torsion involving atoms '%s' with that involving atoms '%s': \" % (torsion_atoms0, torsion_atoms1))\n print(\"Keys for system0: '%s'; keys for system1: '%s'\" % (subdict0.keys(), subdict1.keys() ) )\n raise Exception(\"Error: (proper) PeriodicTorsionForce entry (atoms %d, %d, %d, %d) has different terms.\" % (i0, i1, i2, i3) )\n\n for (per, phase) in subdict0.keys():\n val0 = subdict0[per, phase]\n val1 = subdict1[per, phase]\n if not compare(val0, val1):\n print(\"Compared torsion involving atoms '%s' with that involving atoms '%s': \" % (torsion_atoms0, torsion_atoms1))\n raise Exception( \"Error: (proper) PeriodicTorsionForce (atoms %d, %d, %d, %d, periodicity %d, phase %f degrees) has barrier height values of %f and %f kJ/mol, respectively.\" % (i0, i1, i2, i3, per, phase, val0, val1) )","def test_run_mantel_test_no_cdm(self):\r\n self.assertRaises(ValueError, run_mantel_test, 'partial_mantel',\r\n [self.fp1, self.fp2], [self.dm1,\r\n self.dm2], self.num_perms,\r\n 'two sided', self.comment, self.alpha)","def test_euler_angles_1q_hard_thetas(self, gate):\n self.check_one_qubit_euler_angles(Operator(gate))","def test_maf(self):\n # Flipping the strand\n self.assertAlmostEqual(self.g.maf(), 8 / 18)","def is_valid(self):\n return (4 * (self.a ** 3) + 27 * (self.b ** 2)) % self.fp != 0","def CalcForce_aeroframe_DEP(V, CoefMatrix, x, rho, g):\r\n\r\n #Compute aero forces\r\n # here x must be of the form (alpha, beta, p, q, r, da, dr, de) (last one punctualy used)\r\n # set non dim for p,q,r\r\n nonDim=np.ones(7)\r\n nonDim[2]=g.b/(2*V)\r\n nonDim[3]=g.c/(2*V)\r\n nonDim[4]=g.b/(2*V)\r\n # F=np.dot(CoefMatrix,x[0:7]) # commented form, modification to account for symmetric drag increase of side slip\r\n F=np.zeros((3))\r\n M=np.zeros((3))\r\n xsym=np.copy(x[0:-1])\r\n xsym[1]=abs(xsym[1]) # make beta always positive since derivatives have already correct sign for drag and lift only\r\n xsym[-3]=abs(xsym[-3]) # make ailerons deflection always positive for drag increase and lift decrease\r\n xsym[-1]=abs(xsym[-1]) # make rudder deflection always positive for drag increase and lift decrease\r\n F[0]=np.dot(CoefMatrix[0],xsym)\r\n F[1]=np.dot(CoefMatrix[1],x[0:-1]) #side force\r\n F[2]=np.dot(CoefMatrix[2],xsym)\r\n M=np.dot(CoefMatrix[3:6,:],x[0:-1])\r\n# print(\"Printing moment coeff\")\r\n# print(M)\r\n\r\n \r\n #No need to project\r\n# alpha=x[0]\r\n# beta=x[1]\r\n# H=np.array([[math.cos(alpha)*math.sin(beta), -math.cos(alpha)*math.sin(beta), -math.sin(alpha)],[math.sin(beta), math.cos(beta), 0],[math.sin(alpha)*math.cos(beta), -math.sin(alpha)*math.sin(beta), math.cos(alpha)]])\r\n if V<=71 :\r\n Fbody=np.array([-F[0]-g.Cd0_fl,F[1],-F[2]-g.CL0_fl]) # add alpha=0 coefficients\r\n Moment=M+np.array([0,x[-1]*g.Cm_de+g.Cm0_fl,0])\r\n else:\r\n Fbody=np.array([-F[0]-g.Cd0,F[1],-F[2]-g.CL0]) # add alpha=0 coefficients\r\n Moment=M+np.array([0,x[-1]*g.Cm_de+g.Cm0,0])\r\n \r\n\r\n Fbody=0.5*V**2.0*rho*g.S*Fbody\r\n Moment=0.5*V**2.0*rho*g.S*g.b*Moment\r\n \r\n return np.append(Fbody, Moment)","def test_force(self):\n group = hoomd.group.all()\n\n # compute forces\n f = azplugins.restrain.plane(group=group, point=(0,0,0), normal=(1,0,0), k=2.0)\n hoomd.run(1)\n np.testing.assert_array_almost_equal(f.forces[0].force, (-2.,0,0))\n np.testing.assert_array_almost_equal(f.forces[1].force, ( 2.,0,0))\n np.testing.assert_array_almost_equal(f.forces[2].force, ( 6.,0,0))\n self.assertAlmostEqual(f.forces[0].energy, 1.)\n self.assertAlmostEqual(f.forces[1].energy, 1.)\n self.assertAlmostEqual(f.forces[2].energy, 9.)\n np.testing.assert_array_almost_equal(f.forces[0].virial, (-2.,0,0,0,0,0))\n np.testing.assert_array_almost_equal(f.forces[1].virial, (-2.,0,4.,0,0,0))\n np.testing.assert_array_almost_equal(f.forces[2].virial, (12.,0,0,0,0,0))\n\n # change the spring constant\n f.set_params(k=1.0)\n hoomd.run(1)\n np.testing.assert_array_almost_equal(f.forces[0].force, (-1.,0,0))\n np.testing.assert_array_almost_equal(f.forces[1].force, ( 1.,0,0))\n np.testing.assert_array_almost_equal(f.forces[2].force, ( 3.,0,0))\n self.assertAlmostEqual(f.forces[0].energy, 0.5)\n self.assertAlmostEqual(f.forces[1].energy, 0.5)\n self.assertAlmostEqual(f.forces[2].energy, 4.5)\n\n # shift the plane down\n f.set_params(point=(-1,0,0))\n hoomd.run(1)\n np.testing.assert_array_almost_equal(f.forces[0].force, (-2.,0,0))\n np.testing.assert_array_almost_equal(f.forces[1].force, ( 0.,0,0))\n np.testing.assert_array_almost_equal(f.forces[2].force, ( 2.,0,0))\n self.assertAlmostEqual(f.forces[0].energy, 2.0)\n self.assertAlmostEqual(f.forces[1].energy, 0.0)\n self.assertAlmostEqual(f.forces[2].energy, 2.0)\n\n # rotate the plane so that only particle 1 is off the line\n f.set_params(point=(0,0,0), normal=(0,0,1))\n hoomd.run(1)\n np.testing.assert_array_almost_equal(f.forces[0].force, (0,0,0))\n np.testing.assert_array_almost_equal(f.forces[1].force, (0,0,-2))\n np.testing.assert_array_almost_equal(f.forces[2].force, (0,0,0))\n self.assertAlmostEqual(f.forces[0].energy, 0.0)\n self.assertAlmostEqual(f.forces[1].energy, 2.0)\n self.assertAlmostEqual(f.forces[2].energy, 0.0)","def calculate_allowable_angles(self, angular_resolution=0.01, visualize=0, optimized=False):\n #Could be optimized more, if required.\n \n if visualize:\n pylab.ion() #Turns interaction on (?)\n print \"Calculation started\"\n\n if angular_resolution < self.ANGULAR_RESOLUTION_MIN:\n warnings.warn(\"Requested too small angular resolution. Using %s\" % self.ANGULAR_RESOLUTION_MIN)\n angular_resolution = self.ANGULAR_RESOLUTION_MIN\n\n #We do not need to look at more than the motor step size in phi, since the sample rotational\n # motor does the rest.\n self.phi_range = 0.99 * (self.sample_motor_step_size / 2)\n #Arbitrary max ranges here. TODO: User setting?\n self.chi_range = pi/8\n self.omega_range = pi/6\n\n #Make the lists\n self.phi_list = array([-self.phi_range, 0, self.phi_range])\n self.phi_list = np.append(np.arange(-self.phi_range, self.phi_range, angular_resolution), (self.phi_range) )\n self.chi_list = np.arange(-self.chi_range, self.chi_range, angular_resolution)\n self.omega_list = np.arange(-self.omega_range, self.omega_range, angular_resolution)\n\n #Create the allowed angle map, all false\n self.allowed = np.zeros( (self.phi_list.size, self.chi_list.size, self.omega_list.size), dtype=np.bool )\n\n #Make sure the limits are calculated\n self.calculate_leg_xy_limits()\n\n\n #Loop through all the angles\n for i_phi in range(self.phi_list.size):\n phi = self.phi_list[i_phi]\n print 'Calculating phi = %s' % phi\n was_anything_in_line = False\n for i_chi in range(self.chi_list.size):\n chi = self.chi_list[i_chi]\n was_allowed = False\n for i_omega in range(self.omega_list.size):\n omega = self.omega_list[i_omega]\n\n #Calcualte the leg position from these angles\n self.getplatepos(phi, chi, omega)\n #Make sure the legs are not in fault\n self.check_limits()\n allowed = not any(self.leg_fault)\n #Save it\n self.allowed[i_phi, i_chi, i_omega] = allowed\n if optimized:\n #Check that we have reached an unallowed section, to speed calculation\n if allowed: was_allowed = True\n if was_allowed and (not allowed):\n break #All other omega values in this chi will be false. Exit to the next line\n #(end of omega loop)\n\n if optimized:\n #Is there anything allowed in this chi line?\n anything_in_line = any(self.allowed[i_phi, i_chi, :])\n #Once we reach a completely disallowed line, all others after will be too\n if anything_in_line: was_anything_in_line = True\n if was_anything_in_line and (not anything_in_line):\n break #we don't need to look at the remaining lines.\n #(end of chi loop)\n #(end of phi loop)\n\n print \"Done!\"\n \n if visualize==1:\n #2D Animated plot\n for i_phi in range(self.phi_list.size):\n phi = self.phi_list[i_phi]\n #Here we are still in the phi loop\n if visualize:\n pylab.figure(0)\n pylab.imshow(self.allowed[i_phi, :, :], interpolation='nearest', extent=(-self.omega_range, self.omega_range, -self.chi_range, self.chi_range))\n pylab.xlabel(\"Omega\")\n pylab.ylabel(\"Chi\")\n pylab.title(\"Allowable angles for phi=%s\" % phi)\n pylab.draw()\n time.sleep(0.2)\n pylab.draw()\n time.sleep(1)\n pylab.ion()\n \n\n if visualize==2:\n #Single 3D plot of allowed angles.\n mlab.clf() #Clear figure\n mlab.contour3d(self.allowed.astype(float), contours=[0.5])\n mlab.xlabel(\"Phi\")\n mlab.ylabel(\"Chi\")\n mlab.zlabel(\"Omega\")\n mlab.axes()\n mlab.show()\n\n #Done calculating\n return None","def check_doa(geometry, doa):\n if doa < 0:\n return False\n if geometry == \"linear\" and doa > 180:\n return False\n if geometry == \"circular\" and doa >= 360:\n return False\n return True","def HFincidentAngle(self,PFC, MHD):\n xyz = PFC.centers\n r,z,phi = tools.xyz2cyl(xyz[:,0],xyz[:,1],xyz[:,2])\n BNorms = MHD.Bfield_pointcloud(PFC.ep, r, z, phi, PFC.powerDir, normal=True)\n PFC.bdotn = np.multiply(PFC.norms, BNorms).sum(1)\n return","def force_12(alpha, r1, r2, R_particle, eps_particle, k, eps_out, eps_in,\n fiber_radius, nmin, nmax, kzimax, E0_mod, nmin_sc, nmax_sc, case):\n\n dr = 1 / k * 1e-5\n dz = dr\n dtheta = 1e-5\n\n p1 = dipole_moment(1, r1, r2, R_particle, eps_particle, k, eps_out, eps_in,\n fiber_radius, nmin, nmax, kzimax,\n E0_mod, nmin_sc, nmax_sc, case)\n p1c = p1.conjugate()\n\n # Fr\n if alpha == 0:\n r1plusdr = r1 + np.array([dr, 0, 0])\n r1minusdr = r1 - np.array([dr, 0, 0])\n Eplusr = total_loc_efield(1, r1plusdr, r2, k, case, nmin, nmax, kzimax,\n fiber_radius, eps_out, eps_in, E0_mod,\n nmin_sc, nmax_sc, R_particle, eps_particle)\n Eminusr = total_loc_efield(1, r1minusdr, r2, k, case, nmin, nmax, kzimax,\n fiber_radius, eps_out, eps_in, E0_mod,\n nmin_sc, nmax_sc, R_particle, eps_particle)\n grad_r = (Eplusr - Eminusr) / (2 * dr)\n\n return(0.5 * np.dot(p1c, grad_r).real)\n # Ftheta\n elif alpha == 1:\n r1plusdtheta = r1 + np.array([0, dtheta, 0])\n r1minusdtheta = r1 - np.array([0, dtheta, 0])\n\n Eplustheta = total_loc_efield(1, r1plusdtheta, r2, k, case, nmin, nmax, kzimax,\n fiber_radius, eps_out, eps_in, E0_mod,\n nmin_sc, nmax_sc, R_particle, eps_particle)\n Eminustheta = total_loc_efield(1, r1minusdtheta, r2, k, case, nmin, nmax, kzimax,\n fiber_radius, eps_out, eps_in, E0_mod,\n nmin_sc, nmax_sc, R_particle, eps_particle)\n grad_theta = (Eplustheta - Eminustheta) / (r1[0] * 2 * dtheta)\n\n return(0.5 * np.dot(p1c, grad_theta).real)\n # Fz\n elif alpha == 2:\n r1plusdz = r1 + np.array([0, 0, dz])\n r1minusdz = r1 - np.array([0, 0, dz])\n\n Eplusz = total_loc_efield(1, r1plusdz, r2, k, case, nmin, nmax, kzimax,\n fiber_radius, eps_out, eps_in, E0_mod,\n nmin_sc, nmax_sc, R_particle, eps_particle)\n Eminusz = total_loc_efield(1, r1minusdz, r2, k, case, nmin, nmax, kzimax,\n fiber_radius, eps_out, eps_in, E0_mod,\n nmin_sc, nmax_sc, R_particle, eps_particle)\n grad_z = (Eplusz - Eminusz) / (2 * dz)\n\n return(0.5 * np.dot(p1c, grad_z).real)\n else:\n print('alpha is out of range!')\n return(0)","def checkForwardBackwardUnity(self):\n if round(self.alpha[-1,-1] - self.beta[0, 0], 7) != 0:\n print('')\n raise BaumWelchForwardBackwardDifference(self.alpha[-1,-1], self.beta[0,0])","def check_improper_torsions(self, force0, force1, bond_force0, bond_force1):\n\n assert type(force0) == type(force1), \"Error: force0 and force1 must be the same type.\"\n assert type(force0) == mm.PeriodicTorsionForce, \"Error: forces must be PeriodicTorsionForce\"\n\n bond_set0 = get_symmetrized_bond_set(bond_force0)\n bond_set1 = get_symmetrized_bond_set(bond_force1)\n\n if force0.getNumTorsions() == 0 and force1.getNumTorsions() == 0:\n return # Must leave now, otherwise try to access torsions that don't exist.\n\n F = force0 if force0.getNumTorsions() > 0 else force1 # Either force0 or force1 is nonempty, so find that one.\n i0, i1, i2, i3, per, phase, k0 = F.getTorsionParameters(0)\n #phase_unit, k0_unit = phase.unit, k0.unit\n k0_unit = u.kilojoules_per_mole\n phase_unit = u.degrees\n\n dict0, dict1 = {}, {}\n for k in range(force0.getNumTorsions()):\n i0, i1, i2, i3, per, phase, k0 = force0.getTorsionParameters(k)\n if not is_improper(i0, i1, i2, i3, bond_set0):\n continue\n\n i0, i1, i2, i3 = reorder_improper_torsions(i0, i1, i2, i3, bond_set0)\n\n phase, k0 = phase / phase_unit, k0 / k0_unit\n if k0 == 0.0:\n continue\n\n if not (i0, i1, i2, i3) in dict0:\n dict0[i0, i1, i2, i3] = []\n\n dict0[i0, i1, i2, i3].append((per, phase, k0))\n\n for k in range(force1.getNumTorsions()):\n i0, i1, i2, i3, per, phase, k0 = force1.getTorsionParameters(k)\n if not is_improper(i0, i1, i2, i3, bond_set1):\n continue\n\n i0, i1, i2, i3 = reorder_improper_torsions(i0, i1, i2, i3, bond_set0)\n\n phase, k0 = phase / phase_unit, k0 / k0_unit\n if k0 == 0.0:\n continue\n\n if not (i0, i1, i2, i3) in dict1:\n dict1[i0, i1, i2, i3] = []\n\n dict1[i0, i1, i2, i3].append((per, phase, k0))\n\n keys0 = set(dict0.keys())\n keys1 = set(dict1.keys())\n diff_keys = keys0.symmetric_difference(keys1)\n\n logger.info(\"Impropers0 - Impropers1 = %s\" % (keys0.difference(keys1)))\n logger.info(\"Impropers1 - Impropers0 = %s\" % (keys1.difference(keys0)))\n assert diff_keys == set(), \"Systems have different (improper) PeriodicTorsionForce entries: extra keys are: \\n%s\" % diff_keys\n\n for (i0, i1, i2, i3) in dict0.keys():\n entries0 = dict0[i0, i1, i2, i3]\n entries1 = dict1[i0, i1, i2, i3]\n assert len(entries0) == len(entries1), \"Error: (improper) PeriodicTorsionForce entry (%d, %d, %d, %d) has different numbers of terms (%d and %d, respectively).\" % (i0, i1, i2, i3, len(entries0), len(entries1))\n\n subdict0 = dict(((per, reduce_precision(phase)), k0) for (per, phase, k0) in entries0)\n subdict1 = dict(((per, reduce_precision(phase)), k0) for (per, phase, k0) in entries1)\n\n assert set(subdict0.keys()) == set(subdict1.keys()), \"Error: (improper) PeriodicTorsionForce entry (%d, %d, %d, %d) has different terms.\" % (i0, i1, i2, i3)\n\n for (per, phase) in subdict0.keys():\n val0 = subdict0[per, phase]\n val1 = subdict1[per, phase]\n assert compare(val0, val1), \"Error: (improper) PeriodicTorsionForce (atoms %d, %d, %d, %d, periodicity %d, phase %f degrees) has barrier height values of %f and %f kJ/mol, respectively.\" % (i0, i1, i2, i3, per, phase, val0, val1)","def read_forces(self, fname):\n outfile = open(fname)\n lines = outfile.readlines()\n outfile.close()\n nats = len(self.atoms)\n forces = np.zeros((nats, 3), float)\n infinite_force=\"*****\"\n if 'mozyme' in self.str_params['job_type'].lower():\n for i, line in enumerate(lines):\n if line.find('FINAL POINT AND DERIVATIVES') != -1:\n for j in range(nats):\n gline = lines[i + j + 5]\n pre_force=gline[8:35]\n if(infinite_force in pre_force):\n forces[j] = [999999999.9999,999999999.9999,999999999.9999]\n else:\n forces[j] = [float( pre_force[0:9].strip()),float( pre_force[9:18].strip()),float( pre_force[18:27].strip())]\n else:\n for i, line in enumerate(lines):\n if line.find('GRADIENT\\n') != -1:\n for j in range(nats * 3):\n gline = lines[i + j + 1]\n pre_force=gline[49:62]\n if(infinite_force in pre_force):\n forces[int(j/3), int(j%3)] =999999999.9999\n else:\n forces[int(j/3), int(j%3)] = float(pre_force)\n break\n#do not change unit for mopac\n forces *= - (kcal / mol)\n return forces","def test_remove_translational_rotational_dof(positions):\n class DummyTimeStep:\n def __init__(self, positions):\n self.positions = positions\n self.n_atoms = len(positions)\n ts = DummyTimeStep(positions=positions)\n\n transform = RemoveTransRotDOF(\n center_atom_idx=0,\n axis_atom_idx=2,\n plane_atom_idx=3,\n axis='z',\n plane='xz'\n )\n ts = transform(ts)\n\n # The center atom is at the origin.\n assert np.allclose(ts.positions[transform._center_atom_idx], 0.0)\n\n # The axis atom is on the expected axis.\n expected_axis_atom_position = transform.axis * np.linalg.norm(\n positions[transform._axis_atom_idx] - positions[transform._center_atom_idx])\n assert np.allclose(ts.positions[transform._axis_atom_idx], expected_axis_atom_position)\n\n # The plane atom is orthogonal to the plane normal.\n assert np.allclose(np.dot(ts.positions[transform._plane_atom_idx], transform.plane), 0.0)\n\n # The constrained atom indices is correct.\n expected = np.array([0, 1, 2, 6, 7, 10])\n assert np.all(transform.constrained_dof_indices == expected)","def magnetisation(field):\n norm_field = df.Field(field.mesh, dim=1, value=(field.norm.array != 0))\n volume = df.integral(norm_field * df.dV, direction='xyz')\n return df.integral(field * df.dV / volume, direction='xyz')","def validate_pmf(pmf, ops):\n validate_normalization(pmf, ops)\n validate_probabilities(pmf, ops)\n return True","def diwire_dfm(pl):\n\t# check angle\n\ttake3 = takeNGenerator(pl.points, 3)\n\tvalid = reduce(lambda flag, p: flag and (getAngle(*p) <= 135), take3, True)\n\t# check distance\n\ttake2 = takeNGenerator(pl.points, 2)\n\tvalid = reduce(lambda flag, p: flag and (\n\t\tgetDistance(*p) >= 12), take2, valid)\n\tif valid:\n\t\treturn True\n\telse:\n\t\treturn False","def _determine_extra_angles(self, angle_force, reference_topology, growth_indices):\n from simtk import openmm\n import itertools\n from openeye import oechem, oeomega\n\n if len(growth_indices)==0:\n return\n angle_force_constant = 400.0*unit.kilojoules_per_mole/unit.radians**2\n atoms = list(reference_topology.atoms())\n growth_indices = list(growth_indices)\n #get residue from first atom\n residue = atoms[growth_indices[0].idx].residue\n try:\n oemol = FFAllAngleGeometryEngine._oemol_from_residue(residue)\n except Exception as e:\n print(\"Could not generate an oemol from the residue.\")\n print(e)\n\n #get the omega geometry of the molecule:\n\n omega = oeomega.OEOmega()\n omega.SetMaxConfs(1)\n omega.SetStrictStereo(False) #TODO: fix stereochem\n omega(oemol)\n\n #we now have the residue as an oemol. Time to find the relevant angles.\n #There's no equivalent to OEGetTorsions, so first find atoms that are relevant\n #TODO: find out if that's really true\n aromatic_pred = oechem.OEIsAromaticAtom()\n heavy_pred = oechem.OEIsHeavy()\n angle_criteria = oechem.OEAndAtom(aromatic_pred, heavy_pred)\n\n #get all heavy aromatic atoms:\n #TODO: do this more efficiently\n heavy_aromatics = list(oemol.GetAtoms(angle_criteria))\n for atom in heavy_aromatics:\n #bonded_atoms = [bonded_atom for bonded_atom in list(atom.GetAtoms()) if bonded_atom in heavy_aromatics]\n bonded_atoms = list(atom.GetAtoms())\n for angle_atoms in itertools.combinations(bonded_atoms, 2):\n angle = oechem.OEGetAngle(oemol, angle_atoms[0], atom, angle_atoms[1])\n atom_indices = [angle_atoms[0].GetData(\"topology_index\"), atom.GetData(\"topology_index\"), angle_atoms[1].GetData(\"topology_index\")]\n angle_radians = angle*unit.radian\n growth_idx = self._calculate_growth_idx(atom_indices, growth_indices)\n #If this is a CustomAngleForce, we need to pass the parameters as a list, and it will have the growth_idx parameter.\n #If it's a regular HarmonicAngleForce, there is no growth_index and the parameters are passed separately.\n if isinstance(angle_force, openmm.CustomAngleForce):\n angle_force.addAngle(atom_indices[0], atom_indices[1], atom_indices[2], [angle_radians, angle_force_constant, growth_idx])\n elif isinstance(angle_force, openmm.HarmonicAngleForce):\n angle_force.addAngle(atom_indices[0], atom_indices[1], atom_indices[2], angle_radians, angle_force_constant)\n else:\n raise ValueError(\"Angle force must be either CustomAngleForce or HarmonicAngleForce\")\n return angle_force","def test_norm_compact_axis_angle():\n a = np.array([np.pi, 0.0, 0.0])\n n = pr.norm_compact_axis_angle(a)\n assert_array_almost_equal(a, n)\n\n a = np.array([0.0, np.pi, 0.0])\n n = pr.norm_compact_axis_angle(a)\n assert_array_almost_equal(a, n)\n\n a = np.array([0.0, 0.0, np.pi])\n n = pr.norm_compact_axis_angle(a)\n assert_array_almost_equal(a, n)\n\n random_state = np.random.RandomState(0)\n for _ in range(5):\n a = pr.random_compact_axis_angle(random_state)\n axis = a / np.linalg.norm(a)\n angle = random_state.uniform(-20.0, -10.0 + 2.0 * np.pi)\n a = axis * angle\n n = pr.norm_compact_axis_angle(a)\n for angle_offset in np.arange(0.0, 10.1 * np.pi, 2.0 * np.pi):\n a = axis * (angle + angle_offset)\n n2 = pr.norm_compact_axis_angle(a)\n assert_array_almost_equal(n, n2)","def backward_phi(self):\n for f in self.component_fields:\n f.require_grid_space()","def isAcute(trpl):\n vd = vectorFormat(trpl)\n if angle_between(*vd) < np.pi/2:\n return True\n else:\n return False","def test_norm_axis_angle():\n a = np.array([1.0, 0.0, 0.0, np.pi])\n n = pr.norm_axis_angle(a)\n assert_array_almost_equal(a, n)\n\n a = np.array([0.0, 1.0, 0.0, np.pi])\n n = pr.norm_axis_angle(a)\n assert_array_almost_equal(a, n)\n\n a = np.array([0.0, 0.0, 1.0, np.pi])\n n = pr.norm_axis_angle(a)\n assert_array_almost_equal(a, n)\n\n random_state = np.random.RandomState(0)\n for _ in range(5):\n a = pr.random_axis_angle(random_state)\n angle = random_state.uniform(-20.0, -10.0 + 2.0 * np.pi)\n a[3] = angle\n n = pr.norm_axis_angle(a)\n for angle_offset in np.arange(0.0, 10.1 * np.pi, 2.0 * np.pi):\n a[3] = angle + angle_offset\n n2 = pr.norm_axis_angle(a)\n assert_array_almost_equal(n, n2)","def mod_check(x, y):\r\n if (as_tensor_variable(x).dtype in complex_dtypes or\r\n as_tensor_variable(y).dtype in complex_dtypes):\r\n # Currently forbidden.\r\n raise scal.Mod.complex_error\r\n else:\r\n return mod(x, y)","def _is_trivial_angle(rad: float, atol: float) -> bool:\n return abs(rad) < atol or abs(abs(rad) - np.pi / 4) < atol","def assert_no_error(self): \r\n Nx = self['Nx']\r\n Nt = self.m.Nt\r\n L, T = self.problem['L T'.split()]\r\n L = L/2 # only half the domain used (symmetry)\r\n x = np.linspace(0, L, Nx+1) # Mesh points in space \r\n t = np.linspace(0, T, Nt+1) # Mesh points in time\r\n \r\n for n in range(len(t)):\r\n u_e = self.problem.u_exact(x, t[n])\r\n diff = np.abs(self.f.u[n,:] - u_e).max()\r\n print 'diff:', diff\r\n tol = 1E-13\r\n assert diff < tol","def assertAngle(self, angle: float):\n assert isinstance(angle, float), f\"bad angle instance, type of angle is {type(angle)}\"\n assert -180 <= angle <= 180","def test_fractional_bondorder_from_molecule(\n self,\n get_molecule,\n k_torsion_interpolated,\n k_bond_interpolated,\n length_bond_interpolated,\n central_atoms,\n ):\n mol = get_molecule()\n forcefield = ForceField(\n get_data_file_path(\"test_forcefields/test_forcefield.offxml\"), xml_ff_bo\n )\n topology = Topology.from_molecules(mol)\n\n omm_system = forcefield.create_openmm_system(\n topology,\n charge_from_molecules=[mol],\n partial_bond_orders_from_molecules=[mol],\n )\n\n # Verify that the assigned bond parameters were correctly interpolated\n off_bond_force = [\n force\n for force in omm_system.getForces()\n if isinstance(force, openmm.HarmonicBondForce)\n ][0]\n\n for idx in range(off_bond_force.getNumBonds()):\n params = off_bond_force.getBondParameters(idx)\n\n atom1, atom2 = params[0], params[1]\n atom1_mol, atom2_mol = central_atoms\n\n if ((atom1 == atom1_mol) and (atom2 == atom2_mol)) or (\n (atom1 == atom2_mol) and (atom2 == atom1_mol)\n ):\n k = params[-1]\n length = params[-2]\n assert_almost_equal(k / k.unit, k_bond_interpolated)\n assert_almost_equal(length / length.unit, length_bond_interpolated)\n\n # Verify that the assigned torsion parameters were correctly interpolated\n off_torsion_force = [\n force\n for force in omm_system.getForces()\n if isinstance(force, openmm.PeriodicTorsionForce)\n ][0]\n\n for idx in range(off_torsion_force.getNumTorsions()):\n params = off_torsion_force.getTorsionParameters(idx)\n\n atom2, atom3 = params[1], params[2]\n atom2_mol, atom3_mol = central_atoms\n\n if ((atom2 == atom2_mol) and (atom3 == atom3_mol)) or (\n (atom2 == atom3_mol) and (atom3 == atom2_mol)\n ):\n k = params[-1]\n assert_almost_equal(k / k.unit, k_torsion_interpolated)","def test_get_principal_moments_of_inertia(self):\n numbers = [6, 6, 8, 1, 1, 1, 1, 1, 1]\n coords = np.array([[1.235366, -0.257231, -0.106315],\n [0.083698, 0.554942, 0.046628],\n [-1.210594, -0.239505, -0.021674],\n [0.132571, 1.119728, 0.987719],\n [0.127795, 1.278999, -0.769346],\n [-1.272620, -0.962700, 0.798216],\n [-2.074974, 0.426198, 0.055846],\n [-1.275744, -0.785745, -0.965493],\n [1.241416, -0.911257, 0.593856]], np.float64)\n principal_moments_of_inertia = get_principal_moments_of_inertia(coords=coords, numbers=numbers)[0]\n expected_principal_moments_of_inertia = [60.98026894, 53.83156297, 14.48858465]\n for moment, expected_moment in zip(principal_moments_of_inertia, expected_principal_moments_of_inertia):\n self.assertAlmostEqual(moment, expected_moment)\n\n symbols = ['N', 'O', 'O'] # test a linear molecule\n coords = np.array([[0.000000, 0.000000, 1.106190],\n [0.000000, 0.000000, -0.072434],\n [0.000000, 0.000000, -1.191782]], np.float64)\n with self.assertRaises(InputError):\n get_principal_moments_of_inertia(coords=coords, numbers=numbers)\n principal_moments_of_inertia, axes = get_principal_moments_of_inertia(coords=coords, symbols=symbols)\n expected_principal_moments_of_inertia = [39.4505153, 39.4505153, 0.0]\n expected_axes = [[1, 0, 0], [0, 1, 0], [0, 0, 1]]\n for moment, expected_moment in zip(principal_moments_of_inertia, expected_principal_moments_of_inertia):\n self.assertAlmostEqual(moment, expected_moment)\n for axis, expected_axis in zip(axes, expected_axes):\n for entry, expected_entry in zip(axis, expected_axis):\n self.assertAlmostEqual(entry, expected_entry)\n self.assertIsInstance(principal_moments_of_inertia, tuple)\n self.assertIsInstance(axes, tuple)","def test_angle_angle_explicit(pcff):\n\n expected = {\n \"K\": \"3.5475\",\n \"reference\": \"1\",\n \"Theta10\": \"107.6600\",\n \"Theta20\": \"105.8500\",\n }\n\n i = \"h\"\n j = \"c\"\n k = \"h\"\n l = \"n+\" # noqa: E741\n ptype, key, form, parameters = pcff.angle_angle_parameters(i, j, k, l)\n assert ptype == \"explicit\"\n assert key == (\"h\", \"c\", \"h\", \"n+\")\n assert parameters == expected","def test_t(self):\n assert np.isclose(self.stepper.t, self.final_t)","def test_charge_increment_model_one_less_ci_than_tagged_atom(self):\n # Make a FF from each OFFXML string\n file_path = get_data_file_path(\"test_forcefields/test_forcefield.offxml\")\n ff1 = ForceField(file_path, xml_charge_increment_model_ff_one_less_ci)\n del ff1._parameter_handlers[\"ToolkitAM1BCC\"]\n ff2 = ForceField(file_path, xml_charge_increment_model_ff_no_missing_cis)\n del ff2._parameter_handlers[\"ToolkitAM1BCC\"]\n top = Topology.from_molecules([create_ethanol()])\n # Make a system from each FF\n sys1 = ff2.create_openmm_system(top)\n sys2 = ff2.create_openmm_system(top)\n # Extract the nonbonded force from each system\n nonbonded_force1 = [\n force\n for force in sys1.getForces()\n if isinstance(force, openmm.NonbondedForce)\n ][0]\n nonbonded_force2 = [\n force\n for force in sys2.getForces()\n if isinstance(force, openmm.NonbondedForce)\n ][0]\n\n # Ensure that the systems both have the correct charges assigned\n expected_charges = [\n 0.17,\n -0.18,\n -0.04,\n 0.01,\n 0.01,\n 0.01,\n 0.01,\n 0.01,\n 0.0,\n ] * openmm_unit.elementary_charge\n for idx, expected_charge in enumerate(expected_charges):\n charge1, _, _ = nonbonded_force1.getParticleParameters(idx)\n charge2, _, _ = nonbonded_force2.getParticleParameters(idx)\n assert (\n abs(charge1 - expected_charge) < 1.0e-6 * openmm_unit.elementary_charge\n )\n assert charge1 == charge2","def search_base_angles(self, motor_positions):\n\n # Errore nelle soluzioni\n err = [0, 0, 0]\n\n # Angolo di inizio ricerca\n # Se gia' eseguita una conversione suo i valori precedenti\n if self.isLastAnglesValid:\n self.alpha_start = list(self.alpha)\n else:\n # Angolo minimo di partenza ( -alpha_limit )\n # TO_CHECK: perche' parto da una configurazione sicuramente errata? -10?\n self.alpha_start = [self.alpha_limit_r, self.alpha_limit_r, self.alpha_limit_r]\n\n # Angoli presunti\n # self.temp = list(self.alpha_start)\n alpha = list(self.alpha_start)\n\n # Altezze reali degli attuatori\n height = [self.real_height + motor_positions[0],\n self.real_height + motor_positions[1],\n self.real_height + motor_positions[2]]\n\n # Trovo il mediano tra 0-1-2\n '''\n if any([all([motor_positions[0] > motor_positions[1], motor_positions[0] < motor_positions[2]]),\n all([motor_positions[0] < motor_positions[1], motor_positions[0] > motor_positions[2]])]):\n is_0_median = True\n is_1_median = False\n is_2_median = False\n else:\n is_0_median = False\n if any([all([motor_positions[1] > motor_positions[2], motor_positions[1] < motor_positions[0]]),\n all([motor_positions[1] < motor_positions[2], motor_positions[1] > motor_positions[0]])]):\n is_0_median = False\n is_1_median = True\n is_2_median = False\n else:\n is_1_median = False\n if any([all([motor_positions[2] > motor_positions[1], motor_positions[2] < motor_positions[0]]),\n all([motor_positions[2] < motor_positions[1], motor_positions[2] > motor_positions[0]])]):\n is_0_median = False\n is_1_median = False\n is_2_median = True\n else:\n is_2_median = False\n '''\n\n # Incrementi degli angoli\n # TO_CHECK: perche' quattro? L'ultimo e' di backup?\n step_alpha_base = 0.1 * Kinematic.M_TO_RAD\n step_alpha = [step_alpha_base, step_alpha_base, step_alpha_base]\n\n # Numero di cicli eseguiti\n self.cycles = 0\n\n # Calcolo la condizione iniziale\n d1 = self.distance_12(alpha, height)\n err[0] = d1 - self.base_length\n step_alpha[1] = err[0] * self.ke * step_alpha_base\n\n d2 = self.distance_23(alpha, height)\n err[1] = d2 - self.base_length\n step_alpha[2] = err[1] * self.ke * step_alpha_base\n\n d3 = self.distance_13(alpha, height)\n err[2] = d3 - self.base_length\n step_alpha[0] = err[2] * self.ke * step_alpha_base\n\n i = 0\n while i < self.cycle_limit:\n\n i += 1\n\n # Incremento alfa1 ed azzero alfa2\n alpha[0] += step_alpha[0]\n alpha[1] = self.alpha_start[1]\n\n j = 0\n\n while j < self.cycle_limit:\n\n j += 1\n\n # self.next_iteration(alpha, step_alpha, i, j, n, err)\n self.cycles += 1\n\n if self.cycles > self.cycle_limit:\n logging.error(\"Maximum number of cycles executed, no solution found!\")\n return False\n\n # Incremento alfa1 ed azzero alfa2\n alpha[1] += step_alpha[1]\n\n # Se supero l'angolo limite\n # Partendo da -10 ( -0.17 ), non devo superare 10 ( 0.17 )\n if alpha[1] > -self.alpha_limit_r:\n\n # Angolo non trovato\n step_alpha[1] = step_alpha_base\n step_alpha[0] = err[0] * step_alpha_base * self.ke\n self.alpha_start[1] = -self.alpha_limit_r - 2 * step_alpha[1]\n break\n\n d1 = self.distance_12(alpha, height)\n err[0] = d1 - self.base_length\n step_alpha[1] = err[0] * self.ke * step_alpha_base\n\n if abs(err[0]) < self.err_limit:\n\n # Trovato il minimo\n self.alpha_start[1] = alpha[1]\n step_alpha[1] = step_alpha_base\n\n n = 0\n while n < self.cycle_limit:\n\n n += 1\n\n # self.next_iteration(alpha, step_alpha, i, j, n, err)\n self.cycles += 1\n\n if self.cycles > self.cycle_limit:\n logging.error(\"Maximum number of cycles executed, no solution found!\")\n return False\n\n alpha[2] += step_alpha[2]\n d2 = self.distance_23(alpha, height)\n err[1] = d2 - self.base_length\n step_alpha[2] = err[1] * self.ke * step_alpha_base\n\n if abs(err[1]) < self.err_limit:\n\n step_alpha[2] = step_alpha_base\n d3 = self.distance_13(alpha, height)\n err[2] = d3 - self.base_length\n step_alpha[0] = err[2] * self.ke * step_alpha_base\n\n if abs(err[2]) < self.err_limit:\n\n # Trovatas la soluzione\n self.alpha = list(alpha)\n return True\n\n # NEXT j!!!\n break\n\n # Next i!!!\n break","def check_extension(sim_par, base_mof, mobile_mof, emap, emap_atom_list, new_structure):\n emap_max = [emap[-1][0], emap[-1][1], emap[-1][2]]\n emap_min = [emap[0][0], emap[0][1], emap[0][2]]\n\n energy_limit = sim_par['atom_energy_limit']\n ext_cut_off = sim_par['ext_cut_off']\n\n rotation_info = new_structure['rotation']\n first_point = new_structure['first_point']\n translation_vector = Coor(new_structure['translation_vector'])\n\n Quat = Quaternion([0, 1, 1, 1])\n\n packing_factor = Packing.factor(mobile_mof.uc_size, ext_cut_off)\n uc_vectors = Packing.uc_vectors(mobile_mof.uc_size, mobile_mof.uc_angle)\n trans_vec = Packing.translation_vectors(packing_factor, uc_vectors)\n packed_coors = Packing.uc_coors(trans_vec, packing_factor, uc_vectors, mobile_mof.atom_coors)\n\n x_angle = rotation_info[0]\n y_angle = rotation_info[1]\n z_angle = rotation_info[2]\n\n collision = False\n for unit_cell in packed_coors:\n\n if not collision:\n\n for coor_index, coor in enumerate(unit_cell):\n\n if not collision:\n\n new_coor = Coor(coor)\n Q = Quaternion([1, new_coor.x, new_coor.y, new_coor.z]) # Might be a better way to do this\n Q = Quat.rotation(Q.xyz(), [0, 0, 0], [1, 0, 0], x_angle)\n Q = Quat.rotation(Q.xyz(), [0, 0, 0], [0, 1, 0], y_angle)\n Q = Quat.rotation(Q.xyz(), [0, 0, 0], [0, 0, 1], z_angle)\n new_coor = Coor(Q.xyz())\n\n new_coor += translation_vector\n pbc_coor = new_coor.pbc(base_mof.uc_size, base_mof.uc_angle, base_mof.frac_ucv)\n\n atom_name = mobile_mof.atom_names[coor_index]\n atom_index = energy_map_atom_index(atom_name, emap_atom_list)\n\n point_energy = trilinear_interpolate(pbc_coor.xyz(), atom_index, emap, emap_max, emap_min)\n\n if point_energy < energy_limit:\n continue\n else:\n collision = True\n break\n else:\n break\n else:\n break\n\n return collision","def alchemical_forces(self):\n return self._cpp_obj._forces * self._cpp_obj.norm_value","def test_integrate_wontfix(self):\n ans_flam = 8.8608168e-09 * (u.erg / (u.cm * u.cm * u.s))\n assert_quantity_allclose(\n self.sp.integrate(wavelengths=self.w, flux_unit='flam',\n integration_type='analytical'), ans_flam)","def test_non_integral_validation(self):","def test_non_integral_validation(self):","def is_valid(self):\n posit1 = (self.mean_v > 0) & (self.kappa_y > 0) & (self.eta_y > 0)\n posit2 = (self.kappa_s > 0) & (self.eta_s > 0)\n return posit1 & posit2 & self.feller()","def _validate_axes(self):\n if not (\n np.abs(self.axis_u.dot(self.axis_v) < 1e-6)\n and np.abs(self.axis_v.dot(self.axis_w) < 1e-6)\n and np.abs(self.axis_w.dot(self.axis_u) < 1e-6)\n ):\n raise ValueError(\"axis_u, axis_v, and axis_w must be orthogonal\")\n return True","def modify_openmm_forces(self, *args, **kwargs):\n raise NotImplementedError()","def test_norm_angle():\n random_state = np.random.RandomState(0)\n a_norm = random_state.uniform(-np.pi, np.pi, size=(100,))\n for b in np.linspace(-10.0 * np.pi, 10.0 * np.pi, 11):\n a = a_norm + b\n assert_array_almost_equal(pr.norm_angle(a), a_norm)\n\n assert_almost_equal(pr.norm_angle(-np.pi), np.pi)\n assert_almost_equal(pr.norm_angle(np.pi), np.pi)","def validate_magvar(mv):\n result = VALID\n mag_var = None\n try:\n mag_var = float(mv)\n if (mag_var > 360) or (mag_var < -360):\n result = NOT_VALID\n except ValueError:\n try:\n prefix = mv[0]\n if REGEX_MAGVAR_DD.match(mv[1:]): # Check if there are only numbers > 0, eg. 1.5, not -1.5\n mag_var = float(mv[1:])\n if prefix == 'W':\n result = -mag_var\n elif prefix == 'E':\n result = mag_var\n else:\n result = NOT_VALID\n else:\n result = NOT_VALID\n\n if (mag_var != None) and ((mag_var > 360) or (mag_var < -360)):\n result = NOT_VALID \n \n except ValueError:\n result = NOT_VALID\n mag_var = None\n\n return result, mag_var","def comp_axes(self, machine, N0=None):\n if self.time is None and N0 is None:\n raise InputError(\"ERROR: time and N0 can't be both None\")\n\n # Get machine pole pair number\n p = machine.get_pole_pair_number()\n\n # Get electrical fundamental frequency\n f_elec = self.comp_felec()\n\n # Airgap radius\n Rag = machine.comp_Rgap_mec()\n\n # Setup normalizations for time and angle axes\n norm_time = {\n \"elec_order\": f_elec,\n \"mech_order\": f_elec / p,\n }\n if N0 is not None:\n norm_time[\"angle_rotor\"] = 1 / (360 * N0 / 60)\n\n norm_angle = {\"space_order\": p, \"distance\": 1 / Rag}\n\n # Create time axis\n if self.time is None:\n # Create time axis as a DataLinspace\n Time = DataLinspace(\n name=\"time\",\n unit=\"s\",\n initial=0,\n final=60 / N0 * self.Nrev,\n number=self.Nt_tot,\n include_endpoint=False,\n normalizations=norm_time,\n )\n else:\n # Load time data\n time = self.time.get_data()\n self.Nt_tot = len(time)\n Time = Data1D(name=\"time\", unit=\"s\", values=time, normalizations=norm_time)\n\n # Create angle axis\n if self.angle is None:\n # Create angle axis as a DataLinspace\n Angle = DataLinspace(\n name=\"angle\",\n unit=\"rad\",\n initial=0,\n final=2 * pi,\n number=self.Na_tot,\n include_endpoint=False,\n normalizations=norm_angle,\n )\n else:\n # Load angle data\n angle = self.angle.get_data()\n self.Na_tot = len(angle)\n Angle = Data1D(\n name=\"angle\", unit=\"rad\", values=angle, normalizations=norm_angle\n )\n\n return Time, Angle","def test_run_mantel_correlogram_invaid_input(self):\r\n self.assertRaises(ValueError, run_mantel_correlogram, [self.fp1],\r\n [self.dm1, self.dm3], self.num_perms, None, self.alpha)","def update_forces(self):\n\n pass","def test_magmom(convcell_cr: PhonopyAtoms):\n symprec = 1e-5\n symmetry_nonspin = Symmetry(convcell_cr, symprec=symprec)\n atom_map_nonspin = symmetry_nonspin.get_map_atoms()\n len_sym_nonspin = len(symmetry_nonspin.symmetry_operations[\"rotations\"])\n\n spin = [1, -1]\n cell_withspin = convcell_cr.copy()\n cell_withspin.magnetic_moments = spin\n symmetry_withspin = Symmetry(cell_withspin, symprec=symprec)\n atom_map_withspin = symmetry_withspin.get_map_atoms()\n len_sym_withspin = len(symmetry_withspin.symmetry_operations[\"rotations\"])\n\n broken_spin = [1, -2]\n cell_brokenspin = convcell_cr.copy()\n cell_brokenspin = convcell_cr.copy()\n cell_brokenspin.magnetic_moments = broken_spin\n symmetry_brokenspin = Symmetry(cell_brokenspin, symprec=symprec)\n atom_map_brokenspin = symmetry_brokenspin.get_map_atoms()\n len_sym_brokenspin = len(symmetry_brokenspin.symmetry_operations[\"rotations\"])\n\n assert (atom_map_nonspin == atom_map_withspin).all()\n assert (atom_map_nonspin != atom_map_brokenspin).any()\n assert len_sym_nonspin == len_sym_withspin\n assert len_sym_nonspin != len_sym_brokenspin","def test_run_mantel_test_invaid_input(self):\r\n self.assertRaises(ValueError, run_mantel_test, 'mantel',\r\n [self.fp1,\r\n self.fp2], [\r\n self.dm1], self.num_perms, 'two sided',\r\n None, self.alpha)","def test_abs_magnitude_graph_missing_velocity_returns_exception():\n from space_rocks.views.plot_magnitude import graph_abs_magnitude\n\n test_mag = [1, 2, 3, 4, 5]\n test_neo_names = [\"ceres\", \"phobos\", \"deimos\", \"asteroid x\", \"it was earth all along!!\"]\n\n with pytest.raises(UnknownAxisException):\n graph_abs_magnitude(test_mag, [], test_neo_names)","def test_charge_increment_model_net_charge(self):\n file_path = get_data_file_path(\"test_forcefields/test_forcefield.offxml\")\n ff = ForceField(file_path, xml_charge_increment_model_ff_net_charge)\n del ff._parameter_handlers[\"ToolkitAM1BCC\"]\n\n acetate = create_acetate()\n top = acetate.to_topology()\n\n sys = ff.create_openmm_system(top)\n nonbonded_force = [\n force\n for force in sys.getForces()\n if isinstance(force, openmm.NonbondedForce)\n ][0]\n expected_charges = [\n 0,\n 0.15,\n -0.2,\n -0.95,\n 0,\n 0,\n 0,\n ] * openmm_unit.elementary_charge\n for idx, expected_charge in enumerate(expected_charges):\n charge, _, _ = nonbonded_force.getParticleParameters(idx)\n assert (\n abs(charge - expected_charge) < 1.0e-6 * openmm_unit.elementary_charge\n )","def bode(system, mn=0.001, mx=1000, npts=100, title=\"\", xlim=False, ylim=False, sv=False,\n disp3db=False, lowcut=None, magnitude=True, angle=True, freqaxis=\"rad\"):\n # Condition system input to ensure proper execution\n system = _sys_condition(system, False)\n\n # Condition min and max freq terms\n degrees = False\n if freqaxis.lower().find(\"deg\") != -1: # degrees requested\n degrees = True\n # Scale Degrees to Radians for calculation\n mn = 2 * _np.pi * mn\n mx = 2 * _np.pi * mx\n mn = _np.log10(mn) # find the _exponent value\n mx = _np.log10(mx) # find the _exponent value\n\n # Generate the frequency range to calculate over\n wover = _np.logspace(mn, mx, npts)\n\n # Calculate the bode system\n w, mag, ang = _sig.bode(system, wover)\n\n def _plot(plot_title, y_label):\n _plt.title(plot_title)\n _plt.ylabel(y_label)\n if degrees: # Plot in degrees\n _plt.plot(w / (2 * _np.pi), ang)\n _plt.xlabel(\"Frequency (Hz)\")\n else: # Plot in radians\n _plt.plot(w, ang)\n _plt.xlabel(\"Frequency (rad/sec)\")\n _plt.xscale(\"log\")\n _plt.grid(which=\"both\")\n if xlim:\n _plt.xlim(xlim)\n if ylim:\n _plt.ylim(ylim)\n if sv:\n _plt.savefig(title + \".png\")\n\n # Plot Magnitude\n if magnitude:\n magTitle = \"Magnitude \" + title\n _plot(magTitle, \"Magnitude (DB)\")\n if disp3db:\n _plt.axhline(-3)\n if lowcut is not None:\n _plt.axhline(lowcut)\n _plt.show()\n\n # Plot Angle\n if angle:\n angTitle = \"Angle \" + title\n _plot(angTitle, \"Angle (degrees)\")\n _plt.show()","def test_calculate_angle():\n r1 = np.array([0, 0, -1])\n r2 = np.array([0, 0, 0])\n r3 = np.array([1, 0, 0])\n\n expected_angle = 90\n calculated_angle = molecool.calculate_angle(r1, r2, r3, degrees = True)\n\n assert expected_angle == calculated_angle","def check_openmm_requirements(cls, combine_nonbonded_forces: bool) -> None:","def intf_ANGLE(E):\n if ( not E.The.StackSize() >= 3\n or not inc.point_formatted_LST(E.The,1)\n or not inc.point_formatted_LST(E.The,2)\n or not inc.point_formatted_LST(E.The,3) ):\n print(\"Input Error: angle\")\n print(intf_ANGLE.__doc__)\n return # Without doing much of anything.\n import math\n Cobject= E.The.StackPop()\n #C= map(lambda x:x.val, Cobject.val) # Should now be a list of floats.\n C= [x.val for x in Cobject.val] # Should now be a list of floats.\n Bobject= E.The.StackPop()\n #B= map(lambda x:x.val, Bobject.val) # Should now be a list of floats.\n B= [x.val for x in Bobject.val] # Should now be a list of floats.\n Aobject= E.The.StackPop()\n #A= map(lambda x:x.val, Aobject.val) # Should now be a list of floats.\n A= [x.val for x in Aobject.val] # Should now be a list of floats.\n v1= [ A[0]-B[0], A[1]-B[1], A[2]-B[2] ]\n v2= [ C[0]-B[0], C[1]-B[1], C[2]-B[2] ]\n v1mag= math.sqrt( v1[0]*v1[0] + v1[1]*v1[1] + v1[2]*v1[2] )\n v2mag= math.sqrt( v2[0]*v2[0] + v2[1]*v2[1] + v2[2]*v2[2] )\n try:\n v1norm= [x/v1mag for x in v1]\n v2norm= [x/v2mag for x in v2]\n dotprod= v1norm[0]*v2norm[0] + v1norm[1]*v2norm[1] + v1norm[2]*v2norm[2]\n a= math.acos(dotprod) * 180 / math.pi\n except ZeroDivisionError:\n print(\"The supplied points are not distinct or have some other math problem.\")\n return\n d= objectifier.StackOB_VAL(a) # Can't be just regular Python ints.\n E.The.StackPush(d)","def validate(self, mesh, mod):\n return True","def _assert_validity_of_inputs(self):\n for item in [\"frequency\", \"Dt\", \"gain\", \"gain_imu\", \"gain_marg\"]:\n if isinstance(self.__getattribute__(item), bool):\n raise TypeError(f\"Parameter '{item}' must be numeric.\")\n if not isinstance(self.__getattribute__(item), (int, float)):\n raise TypeError(f\"Parameter '{item}' is not a non-zero number.\")\n if self.__getattribute__(item) <= 0.0:\n raise ValueError(f\"Parameter '{item}' must be a non-zero number.\")\n if self.q0 is not None:\n if not isinstance(self.q0, (list, tuple, np.ndarray)):\n raise TypeError(f\"Parameter 'q0' must be an array. Got {type(self.q0)}.\")\n self.q0 = np.copy(self.q0)\n if self.q0.shape != (4,):\n raise ValueError(f\"Parameter 'q0' must be an array of shape (4,). It is {self.q0.shape}.\")\n if not np.allclose(np.linalg.norm(self.q0), 1.0):\n raise ValueError(f\"Parameter 'q0' must be a versor (norm equal to 1.0). Its norm is equal to {np.linalg.norm(self.q0)}.\")","def validPeriod(period):\r\n try:\r\n i = float(period)\r\n except ValueError:\r\n return False\r\n else:\r\n if i>0:\r\n return True\r\n else:\r\n return False","def omega(x):\n # if ramp_start_time - ramp_constant_time <= x <= end_ramp_end_time + ramp_constant_time:\n # f_t0 = smooth_factor * (x - ramp_start_time)\n # f_t1 = smooth_factor * (x - i_ramp_end_time)\n # if ramp_mode == 'with_end_acc':\n # f_t2 = smooth_factor * (x - steady_end_time)\n # f_t3 = smooth_factor * (x - end_ramp_end_time)\n # elif ramp_mode == 'no_end_acc':\n # f_t2 = smooth_factor * ramp_start_time\n # f_t3 = smooth_factor * i_ramp_end_time\n\n # omegax = (ramp_stage_acceleration / 2) / smooth_factor * (\n # logcosh(f_t0) - logcosh(f_t1) + logcosh(f_t3) - logcosh(f_t2))\n # else:\n # if bstroke == 'yes' and x <= 2 * (end_ramp_end_time +\n # ramp_constant_time):\n # x -= end_ramp_end_time + ramp_constant_time\n # f_t0 = smooth_factor * (x - ramp_start_time)\n # f_t1 = smooth_factor * (x - i_ramp_end_time)\n # if ramp_mode == 'with_end_acc':\n # f_t2 = smooth_factor * (x - steady_end_time)\n # f_t3 = smooth_factor * (x - end_ramp_end_time)\n # elif ramp_mode == 'no_end_acc':\n # f_t2 = smooth_factor * ramp_start_time\n # f_t3 = smooth_factor * i_ramp_end_time\n\n # omegax = -(ramp_stage_acceleration / 2) / smooth_factor * (\n # logcosh(f_t0) - logcosh(f_t1) + logcosh(f_t3) -\n # logcosh(f_t2))\n # else:\n # omegax = 0\n\n if bstroke == 'no':\n f_t0 = smooth_factor * (x - ramp_start_time)\n f_t1 = smooth_factor * (x - i_ramp_end_time)\n if ramp_mode == 'with_end_acc':\n f_t2 = smooth_factor * (x - steady_end_time)\n f_t3 = smooth_factor * (x - end_ramp_end_time)\n elif ramp_mode == 'no_end_acc':\n f_t2 = smooth_factor * ramp_start_time\n f_t3 = smooth_factor * i_ramp_end_time\n\n omegax = (ramp_stage_acceleration / 2) / smooth_factor * (\n logcosh(f_t0) - logcosh(f_t1) + logcosh(f_t3) - logcosh(f_t2))\n\n else:\n if x <= end_ramp_end_time + ramp_constant_time:\n f_t0 = smooth_factor * (x - ramp_start_time)\n f_t1 = smooth_factor * (x - i_ramp_end_time)\n if ramp_mode == 'with_end_acc':\n f_t2 = smooth_factor * (x - steady_end_time)\n f_t3 = smooth_factor * (x - end_ramp_end_time)\n elif ramp_mode == 'no_end_acc':\n f_t2 = smooth_factor * ramp_start_time\n f_t3 = smooth_factor * i_ramp_end_time\n\n omegax = (ramp_stage_acceleration /\n 2) / smooth_factor * (logcosh(f_t0) - logcosh(f_t1) +\n logcosh(f_t3) - logcosh(f_t2))\n\n else:\n x -= end_ramp_end_time + ramp_constant_time\n f_t0 = smooth_factor * (x - ramp_start_time)\n f_t1 = smooth_factor * (x - i_ramp_end_time)\n if ramp_mode == 'with_end_acc':\n f_t2 = smooth_factor * (x - steady_end_time)\n f_t3 = smooth_factor * (x - end_ramp_end_time)\n elif ramp_mode == 'no_end_acc':\n f_t2 = smooth_factor * ramp_start_time\n f_t3 = smooth_factor * i_ramp_end_time\n\n omegax = -(ramp_stage_acceleration / 2) / smooth_factor * (\n logcosh(f_t0) - logcosh(f_t1) + logcosh(f_t3) -\n logcosh(f_t2))\n\n return omegax"],"string":"[\n \"def test_FEMM_periodicity_angle():\\n\\n SPMSM_015 = load(join(DATA_DIR, \\\"Machine\\\", \\\"SPMSM_015.json\\\"))\\n\\n assert SPMSM_015.comp_periodicity() == (9, False, 9, True)\\n\\n simu = Simu1(name=\\\"test_FEMM_periodicity_angle\\\", machine=SPMSM_015)\\n\\n # Definition of the enforced output of the electrical module\\n I0_rms = 250 / sqrt(2)\\n Phi0 = 140 * pi / 180 # Maximum Torque Per Amp\\n\\n Id_ref = (I0_rms * exp(1j * Phi0)).real\\n Iq_ref = (I0_rms * exp(1j * Phi0)).imag\\n\\n simu.input = InputCurrent(\\n Id_ref=Id_ref,\\n Iq_ref=Iq_ref,\\n Na_tot=252 * 9,\\n Nt_tot=4 * 9,\\n N0=1000,\\n )\\n\\n # Definition of the magnetic simulation: with periodicity\\n simu.mag = MagFEMM(\\n type_BH_stator=1,\\n type_BH_rotor=1,\\n is_periodicity_a=True,\\n is_periodicity_t=False,\\n nb_worker=cpu_count(),\\n Kmesh_fineness=2,\\n )\\n simu.force = ForceMT()\\n\\n # Definition of the magnetic simulation: no periodicity\\n # Definition of the magnetic simulation: no periodicity\\n simu2 = simu.copy()\\n simu2.mag.is_periodicity_a = False\\n\\n simu2.force = ForceMT()\\n\\n # Run simulations\\n out = Output(simu=simu)\\n simu.run()\\n\\n out2 = Output(simu=simu2)\\n simu2.run()\\n\\n # Plot the result\\n out.mag.B.plot_2D_Data(\\n \\\"time\\\",\\n \\\"angle[0]{°}\\\",\\n data_list=[out2.mag.B],\\n legend_list=[\\\"Periodic\\\", \\\"Full\\\"],\\n save_path=join(save_path, simu.name + \\\"_B_time.png\\\"),\\n is_show_fig=False,\\n **dict_2D\\n )\\n\\n out.mag.B.plot_2D_Data(\\n \\\"angle{°}\\\",\\n \\\"time[1]\\\",\\n data_list=[out2.mag.B],\\n legend_list=[\\\"Periodic\\\", \\\"Full\\\"],\\n save_path=join(save_path, simu.name + \\\"_B_space.png\\\"),\\n is_show_fig=False,\\n **dict_2D\\n )\\n\\n out.force.AGSF.plot_2D_Data(\\n \\\"wavenumber=[0,100]\\\",\\n \\\"time[0]\\\",\\n data_list=[out2.force.AGSF],\\n legend_list=[\\\"Periodic\\\", \\\"Full\\\"],\\n save_path=join(save_path, simu.name + \\\"_P_space_fft.png\\\"),\\n is_show_fig=False,\\n **dict_2D\\n )\\n\\n out.force.AGSF.plot_2D_Data(\\n \\\"freqs\\\",\\n \\\"angle[0]\\\",\\n data_list=[out2.force.AGSF],\\n legend_list=[\\\"Periodic\\\", \\\"Full\\\"],\\n save_path=join(save_path, simu.name + \\\"_P_fft2.png\\\"),\\n is_show_fig=False,\\n **dict_2D\\n )\\n\\n out.mag.Tem.plot_2D_Data(\\n \\\"time\\\",\\n data_list=[out2.mag.Tem],\\n legend_list=[\\\"Periodic\\\", \\\"Full\\\"],\\n save_path=join(save_path, simu.name + \\\"_Tem_time.png\\\"),\\n is_show_fig=False,\\n **dict_2D\\n )\\n\\n out.mag.Phi_wind_stator.plot_2D_Data(\\n \\\"time\\\",\\n \\\"phase\\\",\\n data_list=[out2.mag.Phi_wind_stator],\\n legend_list=[\\\"Periodic\\\", \\\"Full\\\"],\\n save_path=join(save_path, simu.name + \\\"_Phi_wind_stator_time.png\\\"),\\n is_show_fig=False,\\n **dict_2D\\n )\\n\\n # Compare both simu\\n Bflux = out.mag.B\\n arg_list = [\\\"angle\\\"]\\n result = Bflux.get_rphiz_along(*arg_list)\\n Brad = result[\\\"radial\\\"]\\n angle = result[\\\"angle\\\"]\\n\\n Bflux2 = out2.mag.B\\n arg_list = [\\\"angle\\\"]\\n result2 = Bflux2.get_rphiz_along(*arg_list)\\n Brad2 = result2[\\\"radial\\\"]\\n\\n assert_array_almost_equal(Brad, Brad2, decimal=1)\\n\\n return out, out2\",\n \"def test_mag_form_fac_case1():\\n ion = MagneticFormFactor('Fe')\\n formfac, _temp = ion.calc_mag_form_fac()[0], ion.calc_mag_form_fac()[1:]\\n del _temp\\n assert (abs(np.sum(formfac) - 74.155233575216599) < 1e-12)\",\n \"def test_mag_form_fac():\\n ion = MagneticFormFactor('Fe')\\n formfac, _temp = ion.calc_mag_form_fac(q=1.)[0], ion.calc_mag_form_fac(q=1.)[1:]\\n del _temp\\n assert (abs(formfac - 0.932565) < 1e-6)\",\n \"def test_mag_form_fac_case2():\\n ion = MagneticFormFactor('Fe')\\n formfac, _temp = ion.calc_mag_form_fac(qrange=[0, 2])[0], ion.calc_mag_form_fac(qrange=[0, 2])[1:]\\n del _temp\\n assert (abs(np.sum(formfac) - 74.155233575216599) < 1e-12)\",\n \"def test_library_charges_monatomic_ions(self, monatomic_ion, formal_charge):\\n ff = ForceField(\\n get_data_file_path(\\\"test_forcefields/test_forcefield.offxml\\\"),\\n get_data_file_path(\\\"test_forcefields/ion_charges.offxml\\\"),\\n )\\n mol = Molecule.from_smiles(\\\"[{}]\\\".format(monatomic_ion))\\n omm_system = ff.create_openmm_system(mol.to_topology())\\n\\n nonbondedForce = [\\n f for f in omm_system.getForces() if type(f) == NonbondedForce\\n ][0]\\n q, _, _ = nonbondedForce.getParticleParameters(0)\\n assert q == formal_charge\",\n \"def test_FEMM_periodicity_time_no_periodicity_a():\\n\\n SPMSM_015 = load(join(DATA_DIR, \\\"Machine\\\", \\\"SPMSM_015.json\\\"))\\n\\n assert SPMSM_015.comp_periodicity() == (9, False, 9, True)\\n\\n simu = Simu1(name=\\\"test_FEMM_periodicity_time_no_periodicity_a\\\", machine=SPMSM_015)\\n\\n # Definition of the enforced output of the electrical module\\n I0_rms = 250 / sqrt(2)\\n Phi0 = 140 * pi / 180 # Maximum Torque Per Amp\\n\\n Id_ref = (I0_rms * exp(1j * Phi0)).real\\n Iq_ref = (I0_rms * exp(1j * Phi0)).imag\\n\\n simu.input = InputCurrent(\\n Id_ref=Id_ref,\\n Iq_ref=Iq_ref,\\n Na_tot=252 * 9,\\n Nt_tot=4 * 9,\\n N0=1000,\\n )\\n\\n # Definition of the magnetic simulation: with periodicity\\n simu.mag = MagFEMM(\\n type_BH_stator=1,\\n type_BH_rotor=1,\\n is_periodicity_a=False,\\n is_periodicity_t=True,\\n nb_worker=cpu_count(),\\n Kmesh_fineness=2,\\n )\\n simu.force = ForceMT()\\n\\n # Definition of the magnetic simulation: no periodicity\\n simu2 = simu.copy()\\n simu2.mag.is_periodicity_t = False\\n\\n # Run simulations\\n out = Output(simu=simu)\\n simu.run()\\n\\n out2 = Output(simu=simu2)\\n simu2.run()\\n\\n # Plot the result\\n out.mag.B.plot_2D_Data(\\n \\\"time\\\",\\n \\\"angle[0]{°}\\\",\\n data_list=[out2.mag.B],\\n legend_list=[\\\"Periodic\\\", \\\"Full\\\"],\\n save_path=join(save_path, simu.name + \\\"_B_time.png\\\"),\\n is_show_fig=False,\\n **dict_2D\\n )\\n\\n out.mag.B.plot_2D_Data(\\n \\\"angle{°}\\\",\\n \\\"time[1]\\\",\\n data_list=[out2.mag.B],\\n legend_list=[\\\"Periodic\\\", \\\"Full\\\"],\\n save_path=join(save_path, simu.name + \\\"_B_space.png\\\"),\\n is_show_fig=False,\\n **dict_2D\\n )\\n\\n out.force.AGSF.plot_2D_Data(\\n \\\"wavenumber=[0,100]\\\",\\n \\\"time[0]\\\",\\n data_list=[out2.force.AGSF],\\n legend_list=[\\\"Periodic\\\", \\\"Full\\\"],\\n save_path=join(save_path, simu.name + \\\"_P_space_fft.png\\\"),\\n is_show_fig=False,\\n **dict_2D\\n )\\n\\n out.force.AGSF.plot_2D_Data(\\n \\\"freqs\\\",\\n \\\"angle[0]\\\",\\n data_list=[out2.force.AGSF],\\n legend_list=[\\\"Periodic\\\", \\\"Full\\\"],\\n save_path=join(save_path, simu.name + \\\"_P_fft2.png\\\"),\\n is_show_fig=False,\\n **dict_2D\\n )\\n\\n out.mag.Tem.plot_2D_Data(\\n \\\"time\\\",\\n data_list=[out2.mag.Tem],\\n legend_list=[\\\"Periodic\\\", \\\"Full\\\"],\\n save_path=join(save_path, simu.name + \\\"_Tem_time.png\\\"),\\n is_show_fig=False,\\n **dict_2D\\n )\\n\\n out.mag.Phi_wind_stator.plot_2D_Data(\\n \\\"time\\\",\\n \\\"phase\\\",\\n data_list=[out2.mag.Phi_wind_stator],\\n legend_list=[\\\"Periodic\\\", \\\"Full\\\"],\\n save_path=join(save_path, simu.name + \\\"_Phi_wind_stator_time.png\\\"),\\n is_show_fig=False,\\n **dict_2D\\n )\\n\\n Bflux = out.mag.B\\n arg_list = [\\\"time\\\"]\\n result = Bflux.get_rphiz_along(*arg_list)\\n Brad = result[\\\"radial\\\"]\\n time = result[\\\"time\\\"]\\n\\n Bflux2 = out2.mag.B\\n arg_list = [\\\"time\\\"]\\n result2 = Bflux2.get_rphiz_along(*arg_list)\\n Brad2 = result2[\\\"radial\\\"]\\n time2 = result2[\\\"time\\\"]\\n\\n # Compare both simu\\n assert_array_almost_equal((Brad - Brad2) / Brad2, 0, decimal=2)\\n assert_array_almost_equal(time, time2, decimal=6)\\n\\n AGSF = out.force.AGSF\\n arg_list = [\\\"time\\\"]\\n result_AGSF = AGSF.get_rphiz_along(*arg_list)\\n Prad = result_AGSF[\\\"radial\\\"]\\n time3 = result_AGSF[\\\"time\\\"]\\n\\n AGSF2 = out2.force.AGSF\\n arg_list = [\\\"time\\\"]\\n result_AGSF2 = AGSF2.get_rphiz_along(*arg_list)\\n Prad2 = result_AGSF2[\\\"radial\\\"]\\n time4 = result_AGSF2[\\\"time\\\"]\\n\\n # Compare both simu\\n assert_array_almost_equal((Prad - Prad2) / Prad2, 0, decimal=2)\\n assert_array_almost_equal(time3, time4, decimal=6)\\n\\n return out, out2\",\n \"def check(self, X):\\n if (np.min(X) < -90.) or (np.max(X) > 90.):\\n print \\\"Warning: X may be defined in degrees instead of radians\\\"\",\n \"def check_force_parameters(self, skipImpropers = False):\\n self.check_bonds(self.bond_force0, self.bond_force1)\\n self.check_angles(self.angle_force0, self.angle_force1)\\n self.check_nonbonded(self.nonbonded_force0, self.nonbonded_force1)\\n self.check_proper_torsions(self.torsion_force0, self.torsion_force1, self.bond_force0, self.bond_force1)\\n if not skipImpropers:\\n self.check_improper_torsions(self.torsion_force0, self.torsion_force1, self.bond_force0, self.bond_force1)\\n logger.info(\\\"Note: skipping degenerate impropers with < 4 atoms.\\\")\",\n \"def test_assign_charges_using_library_charges_by_single_atoms(self):\\n ff = ForceField(\\n get_data_file_path(\\\"test_forcefields/test_forcefield.offxml\\\"),\\n xml_ethanol_library_charges_by_atom_ff,\\n )\\n\\n molecules = [\\n Molecule.from_file(get_data_file_path(\\\"molecules/ethanol.sdf\\\")),\\n Molecule.from_file(get_data_file_path(\\\"molecules/ethanol_reordered.sdf\\\")),\\n ]\\n top = Topology.from_molecules(molecules)\\n omm_system = ff.create_openmm_system(top)\\n nonbondedForce = [\\n f for f in omm_system.getForces() if type(f) == NonbondedForce\\n ][0]\\n expected_charges = [\\n -0.2,\\n -0.1,\\n 0.3,\\n 0.08,\\n -0.02,\\n -0.02,\\n -0.02,\\n -0.01,\\n -0.01,\\n -0.2,\\n 0.3,\\n -0.1,\\n 0.08,\\n -0.02,\\n -0.02,\\n -0.02,\\n -0.01,\\n -0.01,\\n ] * openmm_unit.elementary_charge\\n for particle_index, expected_charge in enumerate(expected_charges):\\n q, _, _ = nonbondedForce.getParticleParameters(particle_index)\\n assert q == expected_charge\",\n \"def test_check_compact_axis_angle():\\n a_list = [0, 0, 0]\\n a = pr.check_compact_axis_angle(a_list)\\n assert_array_almost_equal(a_list, a)\\n assert_equal(type(a), np.ndarray)\\n assert_equal(a.dtype, np.float64)\\n\\n random_state = np.random.RandomState(0)\\n a = pr.norm_vector(pr.random_vector(random_state, 3))\\n a *= np.pi + random_state.randn() * 4.0 * np.pi\\n a2 = pr.check_compact_axis_angle(a)\\n pr.assert_compact_axis_angle_equal(a, a2)\\n assert_greater(np.linalg.norm(a2), 0)\\n assert_greater(np.pi, np.linalg.norm(a2))\\n\\n assert_raises_regexp(\\n ValueError, \\\"Expected axis and angle in array with shape\\\",\\n pr.check_compact_axis_angle, np.zeros(4))\\n assert_raises_regexp(\\n ValueError, \\\"Expected axis and angle in array with shape\\\",\\n pr.check_compact_axis_angle, np.zeros((3, 3)))\",\n \"def comp_angle_magnet(self):\\n Rbo = self.get_Rbo()\\n W0 = self.comp_W0m()\\n Harc = self.comp_H_arc()\\n if self.is_outwards():\\n return float(2 * arctan(W0 / (2 * (Rbo + self.H1 - Harc))))\\n else:\\n return float(2 * arctan(W0 / (2 * (Rbo - self.H1 - Harc))))\\n\\n # if self.W0_is_rad:\\n # return self.W0\\n # else: # Convert W0 from m to rad\\n # Rbo = self.get_Rbo()\\n # return float(2 * arcsin(self.W0 / (2 * Rbo)))\",\n \"def _forces_moments(self, delta):\\n # assert delta.shape == (4,1)\\n da = delta[0]\\n de = delta[1]\\n dt = delta[2]\\n dr = delta[3]\\n\\n e0 = self._state[3]\\n e1 = self._state[4]\\n e2 = self._state[5]\\n e3 = self._state[6]\\n u = self._state[7]\\n v = self._state[8]\\n w = self._state[9]\\n p = self._state[10]\\n q = self._state[11]\\n r = self._state[12]\\n\\n self._Va = np.sqrt(u**2 + v**2 + w**2)\\n self._alpha = np.arctan(1.0*w/u)\\n self._beta = np.arcsin(1.0*v/self._Va)\\n\\n\\n\\n Fg = self.mass*self.gravity*np.array([2*(e1*e3-e2*e0),\\n 2*(e2*e3 + e1*e0),\\n e3**2 + e0**2 - e1**2 - e2**2,\\n ])\\n\\n # Fg = self.mass*self.gravity*np.array([2*(e1*e3 - e2*e0),\\n # 2*(e2*e3 + e1*e0),\\n # e3**2 + e0**2 - e1**2 - e2**2,\\n # ])\\n\\n M_e = 25\\n sig = lambda a: (1+np.exp(-M_e*(a-self.alpha0))+np.exp(M_e*(a+self.alpha0)))/((1+np.exp(-M_e*(a-self.alpha0)))*(1+np.exp(M_e*(a+self.alpha0))))\\n cla = lambda a: (1-sig(a))*(self.C_L_0+self.C_L_alpha*a)+sig(a)*(2*np.sign(a)*np.sin(a)**2*np.cos(a))\\n cda = lambda a: self.C_D_p + (self.C_L_0+self.C_L_alpha*a)**2/(np.pi*self.e*self.AR)\\n\\n cxa = lambda a: -(cda(a)) * np.cos(a) + (cla(a)) * np.sin(a)\\n\\n cxq = lambda a: -self.C_D_q * np.cos(a) +self.C_L_q * np.sin(a)\\n\\n cxde = lambda a: -self.C_D_delta_e * np.cos(a) + self.C_L_delta_e * np.sin(a)\\n\\n cza = lambda a: -(cda(a)) * np.sin(a) - (cla(a)) * np.cos(a)\\n\\n czq = lambda a: -self.C_D_q * np.sin(a) - self.C_L_q * np.cos(a)\\n\\n czde = lambda a: -self.C_D_delta_e * np.sin(a) - self.C_L_delta_e * np.cos(a)\\n\\n c = self.c/(2.0*self._Va)\\n b = self.b/(2.0*self._Va)\\n\\n\\n\\n one = 0.5*self.rho*self._Va**2*self.S_wing\\n # two = np.array([[1,0,0],[0,1,0],[0,0,1]])\\n three = np.array([[cxa(self._alpha)+cxq(self._alpha)*c*q+cxde(self._alpha)*de],\\n [self.C_Y_0+self.C_Y_beta*self._beta+self.C_Y_p*b*p+self.C_Y_r*b*r+self.C_Y_delta_a*da+self.C_Y_delta_r*dr],\\n [cza(self._alpha)+czq(self._alpha)*c*q+czde(self._alpha)*de]])\\n\\n Fa = np.squeeze(three) * one\\n # pdb.set_trace()\\n Fa = Fa.reshape((3,-1))\\n\\n F = Fg + Fa\\n #\\n # print(\\\"Fa:\\\",Fa)\\n\\n Fp = 0.5*self.rho*self.S_prop*self.C_prop*((self.k_motor*dt)**2-self._Va**2)\\n\\n # print(\\\"FP:\\\", Fp)\\n\\n fx = F[0] + Fp\\n # + 0.5*MAV.rho*self._Va**2*MAV.S_wing*(\\\\\\n # +cxa(self._alpha)\\\\\\n # + cxq(self._alpha)*c*q\\\\\\n # + cxde(self._alpha)*de\\n # )\\n\\n fy = F[1]\\n fz = F[2]\\n\\n # Moment time!!!\\n one = 0.5*self.rho*self._Va**2*self.S_wing\\n two = np.array([\\\\\\n [self.b*(self.C_ell_0+self.C_ell_beta*self._beta+self.C_ell_p*b*p+self.C_ell_r*b*r+self.C_ell_delta_a*da+self.C_ell_delta_r*dr)],\\n [self.c*(self.C_m_0+(self.C_m_alpha*self._alpha)+(self.C_m_q*c*q)+(self.C_m_delta_e*de))],\\n [self.b*(self.C_n_0+(self.C_n_beta*self._beta)+(self.C_n_p*b*p)+(self.C_n_r*b*r)+(self.C_n_delta_a*da)+(self.C_n_delta_r*dr))]\\n ])\\n Ma = one * np.squeeze(two)\\n # print(\\\"\\\\nMa:\\\", Ma)\\n # pdb.set_trace()\\n Ma = Ma.reshape((3,-1))\\n\\n size = Ma.shape[1]\\n\\n Mp = np.block([[np.ones(size)*-self.kTp*(self.kOmega*dt)**2],\\n [np.zeros(size)],\\n [np.zeros(size)]\\n ])\\n\\n M = Mp + Ma\\n\\n Mx = M[0]\\n My = M[1]\\n Mz = M[2]\\n\\n # self._forces[0] = fx\\n # self._forces[1] = fy\\n # self._forces[2] = fz\\n # pdb.set_trace()\\n # print(fx, fy, fz, Mx, My, Mz)\\n\\n return np.array([fx, fy, fz, Mx, My, Mz])\",\n \"def test_library_charges_dont_parameterize_molecule_because_of_incomplete_coverage(\\n self,\\n ):\\n molecules = [Molecule.from_file(get_data_file_path(\\\"molecules/toluene.sdf\\\"))]\\n top = Topology.from_molecules(molecules)\\n\\n # The library charges in the FF should not be able to fully cover toluene\\n ff = ForceField(\\n get_data_file_path(\\\"test_forcefields/test_forcefield.offxml\\\"),\\n xml_ethanol_library_charges_by_atom_ff,\\n )\\n # Delete the ToolkitAM1BCCHandler so the molecule won't get charges from anywhere\\n del ff._parameter_handlers[\\\"ToolkitAM1BCC\\\"]\\n with pytest.raises(\\n RuntimeError, match=\\\"Cc1ccccc1 could not be fully assigned charges\\\"\\n ):\\n omm_system = ff.create_openmm_system(top)\\n\\n # If we do NOT delete the ToolkiAM1BCCHandler, then toluene should be assigned some nonzero partial charges.\\n # The exact value will vary by toolkit, so we don't test that here.\\n ff = ForceField(\\n get_data_file_path(\\\"test_forcefields/test_forcefield.offxml\\\"),\\n xml_ethanol_library_charges_by_atom_ff,\\n )\\n omm_system = ff.create_openmm_system(top)\\n nonbondedForce = [\\n f for f in omm_system.getForces() if type(f) == NonbondedForce\\n ][0]\\n for particle_index in range(top.n_atoms):\\n q, _, _ = nonbondedForce.getParticleParameters(particle_index)\\n assert q != 0 * unit.elementary_charge\",\n \"def is_valid_angle(self, theta_step):\\n return not (self.angle % theta_step)\",\n \"def test_fractional_bondorder_invalid_interpolation_method(self):\\n mol = create_ethanol()\\n\\n forcefield = ForceField(\\n get_data_file_path(\\\"test_forcefields/test_forcefield.offxml\\\"), xml_ff_bo\\n )\\n forcefield.get_parameter_handler(\\n \\\"ProperTorsions\\\"\\n )._fractional_bondorder_interpolation = \\\"invalid method name\\\"\\n topology = Topology.from_molecules([mol])\\n\\n # If important, this can be a custom exception instead of a verbose ValidationError\\n with pytest.raises(\\n ValidationError,\\n match=\\\"given=invalid method name\\\",\\n ):\\n forcefield.create_openmm_system(\\n topology,\\n charge_from_molecules=[mol],\\n )\",\n \"def f_theta_omega(angles, times):\\n # gravity = 9.81\\n # arm_length = 0.1 \\n\\n # omega = angles[0]\\n # theta = angles[1]\\n # ftheta = omega\\n # fomega = -(gravity/arm_length) * np.sin(theta)\\n pass\",\n \"def is_pure_magnetic(self):\\n klist = [key for key in self.components if not self.component_is_zero(key)]\\n return all([key.startswith('magnetic') for key in klist])\",\n \"def test_charge_increment_model_forward_and_reverse_ethanol(self):\\n file_path = get_data_file_path(\\\"test_forcefields/test_forcefield.offxml\\\")\\n ff = ForceField(file_path, xml_charge_increment_model_ff_ethanol)\\n del ff._parameter_handlers[\\\"ToolkitAM1BCC\\\"]\\n top = Topology.from_molecules([create_ethanol(), create_reversed_ethanol()])\\n sys = ff.create_openmm_system(top)\\n nonbonded_force = [\\n force\\n for force in sys.getForces()\\n if isinstance(force, openmm.NonbondedForce)\\n ][0]\\n expected_charges = [\\n 0.2,\\n -0.15,\\n -0.05,\\n 0.0,\\n 0.0,\\n 0.0,\\n 0.0,\\n 0.0,\\n 0.0,\\n 0.0,\\n 0.0,\\n 0.0,\\n 0.0,\\n 0.0,\\n 0.0,\\n -0.05,\\n -0.15,\\n 0.2,\\n ] * openmm_unit.elementary_charge\\n for idx, expected_charge in enumerate(expected_charges):\\n charge, _, _ = nonbonded_force.getParticleParameters(idx)\\n assert (\\n abs(charge - expected_charge) < 1.0e-6 * openmm_unit.elementary_charge\\n )\",\n \"def test_float_input_angles(self):\\n decomposer = OneQubitEulerDecomposer(\\\"PSX\\\")\\n input_matrix = np.array(\\n [\\n [0.70710678, 0.70710678],\\n [0.70710678, -0.70710678],\\n ],\\n dtype=np.float64,\\n )\\n (theta, phi, lam) = decomposer.angles(input_matrix)\\n expected_theta = 1.5707963267948966\\n expected_phi = 0.0\\n expected_lam = 3.141592653589793\\n self.assertAlmostEqual(theta, expected_theta)\\n self.assertAlmostEqual(phi, expected_phi)\\n self.assertAlmostEqual(lam, expected_lam)\",\n \"def test_check_axis_angle():\\n a_list = [1, 0, 0, 0]\\n a = pr.check_axis_angle(a_list)\\n assert_array_almost_equal(a_list, a)\\n assert_equal(type(a), np.ndarray)\\n assert_equal(a.dtype, np.float64)\\n\\n random_state = np.random.RandomState(0)\\n a = np.empty(4)\\n a[:3] = pr.random_vector(random_state, 3)\\n a[3] = random_state.randn() * 4.0 * np.pi\\n a2 = pr.check_axis_angle(a)\\n pr.assert_axis_angle_equal(a, a2)\\n assert_almost_equal(np.linalg.norm(a2[:3]), 1.0)\\n assert_greater(a2[3], 0)\\n assert_greater(np.pi, a2[3])\\n\\n assert_raises_regexp(\\n ValueError, \\\"Expected axis and angle in array with shape\\\",\\n pr.check_axis_angle, np.zeros(3))\\n assert_raises_regexp(\\n ValueError, \\\"Expected axis and angle in array with shape\\\",\\n pr.check_axis_angle, np.zeros((3, 3)))\",\n \"def test_float_input_angles_and_phase(self):\\n decomposer = OneQubitEulerDecomposer(\\\"PSX\\\")\\n input_matrix = np.array(\\n [\\n [0.70710678, 0.70710678],\\n [0.70710678, -0.70710678],\\n ],\\n dtype=np.float64,\\n )\\n (theta, phi, lam, gamma) = decomposer.angles_and_phase(input_matrix)\\n expected_theta = 1.5707963267948966\\n expected_phi = 0.0\\n expected_lam = 3.141592653589793\\n expected_gamma = -0.7853981633974483\\n self.assertAlmostEqual(theta, expected_theta)\\n self.assertAlmostEqual(phi, expected_phi)\\n self.assertAlmostEqual(lam, expected_lam)\\n self.assertAlmostEqual(gamma, expected_gamma)\",\n \"def check_nonbonded(self, force0, force1):\\n\\n assert type(force0) == type(force1), \\\"Error: force0 and force1 must be the same type.\\\"\\n assert type(force0) == mm.NonbondedForce, \\\"Error: forces must be NonbondedForces\\\"\\n assert force0.getNumParticles() == force1.getNumParticles(), \\\"Error: Systems have %d and %d particles in NonbondedForce, respectively.\\\" % (force0.getNumParticles(), force1.getNumParticles())\\n\\n n_atoms = force0.getNumParticles()\\n\\n q, sigma, epsilon = force0.getParticleParameters(0)\\n #unit_q, unit_sigma, unit_epsilon = q.unit, sigma.unit, epsilon.unit\\n unit_q = u.elementary_charge\\n unit_sigma = u.angstrom\\n unit_epsilon = u.kilojoule_per_mole\\n\\n for k in range(n_atoms):\\n q0, sigma0, epsilon0 = force0.getParticleParameters(k)\\n q1, sigma1, epsilon1 = force1.getParticleParameters(k)\\n\\n q0, sigma0, epsilon0 = q0 / unit_q, sigma0 / unit_sigma, epsilon0 / unit_epsilon\\n q1, sigma1, epsilon1 = q1 / unit_q, sigma1 / unit_sigma, epsilon1 / unit_epsilon\\n\\n assert compare(q0, q1), \\\"Error: Particle %d has charges of %f and %f, respectively.\\\" % (k, q0, q1)\\n\\n if epsilon0 != 0.:\\n assert compare(sigma0, sigma1), \\\"Error: Particle %d has sigma of %f and %f angstroms, respectively.\\\" % (k, sigma0, sigma1)\\n else:\\n logger.info(\\\"Skipping comparison of sigma (%f, %f) on particle %d because epsilon has values %f, %f kJ/mol\\\" % (sigma0, sigma1, k, epsilon0, epsilon1))\\n\\n assert compare(epsilon0, epsilon1), \\\"Error: Particle %d has epsilon of %f and %f kJ/mol, respectively.\\\" % (k, epsilon0, epsilon1)\\n\\n n_exceptions = force0.getNumExceptions()\\n assert force0.getNumExceptions() == force1.getNumExceptions(), \\\"Error: Systems have %d and %d exceptions in NonbondedForce, respectively.\\\" % (force0.getNumExceptions(), force1.getNumExceptions())\\n\\n i0, i1, qq, sigma, epsilon = force0.getExceptionParameters(0)\\n unit_qq = u.elementary_charge**2\\n unit_sigma = u.angstrom\\n unit_epsilon = u.kilojoule_per_mole\\n\\n dict0, dict1 = {}, {}\\n for k in range(n_exceptions):\\n i0, i1, qq, sigma, epsilon = force0.getExceptionParameters(k)\\n i0, i1 = reorder_bonds(i0, i1)\\n dict0[i0, i1] = ((qq / unit_qq, sigma / unit_sigma, epsilon / unit_epsilon))\\n\\n i0, i1, qq, sigma, epsilon = force1.getExceptionParameters(k)\\n i0, i1 = reorder_bonds(i0, i1)\\n dict1[i0, i1] = ((qq / unit_qq, sigma / unit_sigma, epsilon / unit_epsilon))\\n\\n keys0 = set(dict0.keys())\\n keys1 = set(dict1.keys())\\n logger.info(\\\"Exceptions0 - Exceptions1 = %s\\\" % (keys0.difference(keys1)))\\n logger.info(\\\"Exceptions1 - Exceptions0 = %s\\\" % (keys1.difference(keys0)))\\n assert set(dict0.keys()) == set(dict1.keys()), \\\"Systems have different NonBondedForce Exceptions\\\"\\n\\n for k, parameter_name in enumerate([\\\"qq\\\", \\\"sigma\\\", \\\"epsilon\\\"]):\\n for (i0, i1) in dict0.keys():\\n val0 = dict0[i0, i1][k]\\n val1 = dict1[i0, i1][k]\\n if parameter_name == \\\"sigma\\\" and dict0[i0, i1][2] == 0.0 and dict1[i0, i1][2] == 0.0:\\n continue # If both epsilon parameters are zero, then sigma doesn't matter so skip the comparison.\\n if parameter_name ==\\\"sigma\\\":\\n assert compare(val0, val1), \\\"Error: NonBondedForce Exception, atom (%d, %d) has sigma values of %f and %f angstroms, respectively.\\\" % (i0, i1, parameter_name, val0, val1)\\n elif parameter_name==\\\"qq\\\":\\n assert compare(val0, val1), \\\"Error: NonBondedForce Exception atom (%d, %d) has squared charge values of %f and %f (elementary charge)**2, respectively.\\\" % (i0, i1, val0, val1)\\n else:\\n assert compare(val0, val1), \\\"Error: NonBondedForce Exception, atom (%d, %d) has epsilon values of %f and %f kJ/mol, respectively.\\\" % (i0, i1, val0, val1)\",\n \"def comp_angle_opening_magnet(self):\\n\\n if self.W1 > 0:\\n Rbo = self.get_Rbo()\\n return float(2 * arcsin(self.W1 / (2 * Rbo)))\\n else:\\n return self.comp_angle_magnet()\",\n \"def check_angles(self, force0, force1):\\n\\n assert type(force0) == type(force1), \\\"Error: force0 and force1 must be the same type.\\\"\\n assert type(force0) == mm.HarmonicAngleForce, \\\"Error: forces must be HarmonicAngleForces\\\"\\n\\n n_angles0 = force0.getNumAngles()\\n n_angles1 = force1.getNumAngles()\\n\\n dict0, dict1 = {}, {}\\n\\n i0, i1, i2, theta0, k0 = force0.getAngleParameters(0)\\n #unit_theta = theta0.unit\\n unit_theta = u.degrees\\n #unit_k = k0.unit\\n unit_k = u.kilojoules_per_mole/(u.degrees)**2\\n\\n for k in range(n_angles0):\\n i0, i1, i2, theta0, k0 = force0.getAngleParameters(k)\\n if (k0 / k0.unit) != 0.0: # Skip forces with strength 0.0\\n i0, i1, i2 = reorder_angles(i0, i1, i2)\\n dict0[i0, i1, i2] = ((theta0 / unit_theta, k0 / unit_k))\\n\\n for k in range(n_angles1):\\n i0, i1, i2, theta0, k0 = force1.getAngleParameters(k)\\n if (k0 / k0.unit) != 0.0: # Skip forces with strength 0.0\\n i0, i1, i2 = reorder_angles(i0, i1, i2)\\n dict1[i0, i1, i2] = ((theta0 / unit_theta, k0 / unit_k))\\n\\n keys0 = set(dict0.keys())\\n keys1 = set(dict1.keys())\\n logger.info(\\\"Angles0 - Angles1 = %s\\\" % (keys0.difference(keys1)))\\n logger.info(\\\"Angles1 - Angles0 = %s\\\" % (keys1.difference(keys0)))\\n diff_keys = keys0.symmetric_difference(keys1)\\n assert diff_keys == set(), \\\"Systems have different HarmonicAngleForce entries: extra keys are: \\\\n%s\\\" % diff_keys\\n\\n for k, parameter_name in enumerate([\\\"theta0\\\", \\\"k0\\\"]):\\n for (i0, i1, i2) in dict0.keys():\\n val0 = dict0[i0, i1, i2][k]\\n val1 = dict1[i0, i1, i2][k]\\n if parameter_name=='theta0':\\n assert compare(val0, val1), \\\"Error: Harmonic Angle (%d, %d, %d) has angle values of %f and %f degrees, respectively.\\\" % (i0, i1, i2, val0, val1)\\n else:\\n assert compare(val0, val1), \\\"Error: Harmonic Angle (%d, %d, %d) has force constant values of %f and %f kJ/(mol degree**2), respectively.\\\" % (i0, i1, i2, val0, val1)\",\n \"def isSecondOblateAxis(alpha1, alpha2, beta1, beta2, maxDist, maxTorsAngle): \\n a1 = np.asarray(alpha1)\\n a2 = np.asarray(alpha2)\\n b1 = np.asarray(beta1)\\n b2 = np.asarray(beta2)\\n #lent = alpha1 - beta1\\n adir = a2 - a1\\n bdir = b2 - b1\\n aLength = np.sqrt ( np.dot(adir, adir) )\\n bLength = np.sqrt ( np.dot(bdir, bdir) )\\n DotProdNormed = np.dot(adir, bdir) / ( aLength * bLength ) \\n maxTors = np.cos( np.radians( maxTorsAngle ))\\n if (abs(DotProdNormed) > maxTors):\\n # print beta1, beta2, \\\"not rectangular, angle = \\\", np.arccos(DotProdNormed)\\n return False\\n # print beta1, beta2, \\\"is rectangular.\\\" \\n # find nearest point to alpha mid on the potential beta axis by bisection\\n # midAlpha = [a2 + 0.5 * dAlph for a2, dAlph in zip(alpha2, dirAlpha)]\\n axisDist = minimalDistance(a1, a2, b1, b2)\\n# print \\\"Distance of\\\", a1, \\\"<->\\\", a2, \\\" to \\\", b1, \\\"<->\\\", b2, \\\"is\\\", axisDist\\n #midBeta = [b2 + 0.5 * dBeta for b2, dBeta in zip(beta2, dirBeta)]\\n if axisDist < maxDist:\\n # print b1, \\\"<->\\\", b2, \\\"is possible axis\\\"\\n return True\\n else:\\n # print b1, \\\"<->\\\", b2, \\\"is too far (\\\", axisDist ,\\\") from\\\", a1, \\\"<->\\\", a2, \\\", maximal allowed distance =\\\", maxDist\\n return False\",\n \"def test_axis_angle_from_compact_axis_angle():\\n ca = [0.0, 0.0, 0.0]\\n a = pr.axis_angle_from_compact_axis_angle(ca)\\n assert_array_almost_equal(a, np.array([1.0, 0.0, 0.0, 0.0]))\\n\\n random_state = np.random.RandomState(1)\\n for _ in range(5):\\n ca = pr.random_compact_axis_angle(random_state)\\n a = pr.axis_angle_from_compact_axis_angle(ca)\\n assert_almost_equal(np.linalg.norm(ca), a[3])\\n assert_array_almost_equal(ca[:3] / np.linalg.norm(ca), a[:3])\",\n \"def test_compact_axis_angle():\\n a = np.array([1.0, 0.0, 0.0, 0.0])\\n ca = pr.compact_axis_angle(a)\\n assert_array_almost_equal(ca, np.zeros(3))\\n\\n random_state = np.random.RandomState(0)\\n for _ in range(5):\\n a = pr.random_axis_angle(random_state)\\n ca = pr.compact_axis_angle(a)\\n assert_array_almost_equal(pr.norm_vector(ca), a[:3])\\n assert_almost_equal(np.linalg.norm(ca), a[3])\",\n \"def testCorrectForTwoAtomCellWithoutPeriodicityNEEDED(self):\\n\\t\\texpDist = 0.01*10\\n\\t\\tself._checkExpMatchesActual(expDist)\",\n \"def _validate_mesh(self):\\n if not (np.abs(self.axis_u.dot(self.axis_v) < 1e-6) and #pylint: disable=no-member\\n np.abs(self.axis_v.dot(self.axis_w) < 1e-6) and #pylint: disable=no-member\\n np.abs(self.axis_w.dot(self.axis_u) < 1e-6)): #pylint: disable=no-member\\n raise ValueError('axis_u, axis_v, and axis_w must be orthogonal')\\n return True\",\n \"def test_comp_magnetostrictive_tensor_1cell():\\n\\n # Physical quantities\\n dim = 2\\n Nt_tot = 1\\n\\n mu = 1\\n Be = np.array([[[mu / 2, 0]]])\\n He = np.array([[[-1 / 2, 0]]])\\n mue = np.array([[mu]])\\n\\n Me = np.reshape(Be / mue - He, (dim, 1, Nt_tot))\\n\\n alphaij = [[1, 0, 0], [1, 0, 0]]\\n\\n alpha1 = 1\\n alpha2 = 1\\n\\n # Computation\\n tensor = ForceTensor()\\n\\n tensor_comp = tensor.comp_magnetrosctrictive_tensor(\\n mue, Me, Nt_tot, alphaij\\n ) # Should be equal to -alpha1*mu*MM' - alpha2*mu*M²*I2\\n\\n assert tensor_comp[0, 0, 0] == -mu * (alpha1 + alpha2)\\n assert tensor_comp[0, 1, 0] == 0\\n assert tensor_comp[1, 0, 0] == 0\\n assert tensor_comp[1, 1, 0] == -mu * alpha2\\n\\n print(\\\"test_comp_magnetostrictive_tensor succeeded\\\")\\n\\n return True\",\n \"def check_these(phi, chi, omega):\\n #Calculate the leg position from these angles\\n self.getplatepos(phi, chi, omega)\\n #Make sure the legs are not in fault\\n self.check_limits()\\n return (not any(self.leg_fault))\",\n \"def test_get_partial_charges(self, force_field):\\n ethanol: Molecule = create_ethanol()\\n\\n ethanol_partial_charges = from_openmm(\\n self.get_partial_charges_from_create_openmm_system(ethanol, force_field)\\n )\\n\\n partial_charges = force_field.get_partial_charges(ethanol)\\n\\n assert (\\n ethanol_partial_charges - partial_charges < 1.0e-6 * unit.elementary_charge\\n ).all()\\n assert partial_charges.shape == (ethanol.n_atoms,)\",\n \"def test_Force_Tensor_compforce():\\n\\n # 'axes_dict' input\\n axes_dict = {\\n \\\"Time\\\": [0],\\n \\\"Angle\\\": [0],\\n }\\n\\n # 'output' input\\n\\n # Mesh object\\n\\n mesh = MeshMat()\\n mesh.cell[\\\"triangle3\\\"] = CellMat(nb_node_per_cell=3)\\n mesh.node = NodeMat()\\n\\n mesh.node.add_node(np.array([0, 0]))\\n mesh.node.add_node(np.array([0, 1]))\\n mesh.node.add_node(np.array([1, 0]))\\n\\n nodes_test = np.array([0, 1, 2])\\n mesh.add_cell(nodes_test, \\\"triangle3\\\")\\n\\n # Mag object\\n Time = Data1D(name=\\\"time\\\", values=[0], is_components=True)\\n indices_cell = [0]\\n Indices_Cell = Data1D(name=\\\"indice\\\", values=indices_cell, is_components=True)\\n axis_list = [Time, Indices_Cell]\\n\\n mu = 1\\n\\n B_elem = np.array([[[mu / 2, 0]]])\\n H_elem = np.array([[[1 / 2, 0]]])\\n mu_elem = np.array([[mu]])\\n\\n B_sol = build_solution_vector(\\n field=B_elem,\\n axis_list=axis_list,\\n name=\\\"Magnetic Flux Density\\\",\\n symbol=\\\"B\\\",\\n unit=\\\"T\\\",\\n )\\n H_sol = build_solution_vector(\\n field=H_elem,\\n axis_list=axis_list,\\n name=\\\"Magnetic Field\\\",\\n symbol=\\\"H\\\",\\n unit=\\\"A/m\\\",\\n )\\n mu_sol = build_solution_data(\\n field=mu_elem,\\n axis_list=axis_list,\\n name=\\\"Magnetic Permeability\\\",\\n symbol=\\\"mu\\\",\\n unit=\\\"H/m\\\",\\n )\\n\\n list_solution = [B_sol, H_sol, mu_sol]\\n\\n out_dict[\\\"meshsolution\\\"] = build_meshsolution(\\n list_solution=list_solution,\\n label=\\\"FEMM 2D Magnetostatic\\\",\\n list_mesh=meshFEMM,\\n group=groups,\\n )\",\n \"def check_validity(self,check_derivative=True,verbose=True):\\n is_valid = True\\n if self.f0(0.0)!=0.0:\\n is_valid = False\\n if verbose:\\n print(\\\"DynamicalSystem: Warning: The system does \\\"+\\n \\\"not satisfy f0(0)=0 (f(0)=\\\",self.f0(0.0),\\\")\\\")\\n if self.f1(1.0)!=1.0:\\n is_valid = False\\n if verbose:\\n print(\\\"DynamicalSystem: Warning: The system does \\\"+\\n \\\"not satisfy f0(1)=1 (f1(1)=\\\",self.f1(1.0),\\\")\\\")\\n if self.rho_max<self.rho_min:\\n is_valid = False\\n if verbose:\\n print(\\\"DynamicalSystem: Warning: The system does \\\"+\\n \\\"not satisfy rho_max>=rho_min (rho_min,rho_max=\\\",\\n rho_min,rho_max,\\\")\\\")\\n if check_derivative:\\n # Coarse check if the derivative is bounded below by some d>1\\n # Note it is sufficient to check the restricted ranges given\\n xs0 = np.linspace(0.0,self.rho_max,129)\\n xs1 = np.linspace(self.rho_min,1.0,129)\\n d = np.min(np.concatenate((self.df0(xs0),self.df1(xs1))))\\n if d<=1.0:\\n is_valid = False\\n if verbose:\\n print(\\\"DynamicalSystem: Warning: The system does \\\"+\\n \\\"not satisfy: d>1 (d<=\\\",d,\\\")\\\")\\n return is_valid\",\n \"def check_angle(self):\\n self.find_pixels()\\n alpha_theta=np.deg2rad(70)\\n alpha_phi=np.deg2rad(70)\\n extreme_values=self.compute_extreme_values(alpha_phi, alpha_theta)\\n x=np.linspace(extreme_values[0], extreme_values[1], self.number_of_pix[1])\\n y=np.linspace(extreme_values[2], extreme_values[3], self.number_of_pix[0])\\n phi_0=20\\n phi_0=np.deg2rad(phi_0)\\n j, diff=self.compute_phi(\\\"find_orient.png\\\")\\n print \\\"j=\\\", j\\n print \\\"diff=\\\", diff\",\n \"def test_field():\\n\\n # Using mesh with radius 10 nm (nmag ex. 1)\\n mesh = from_geofile(os.path.join(MODULE_DIR, \\\"sphere1.geo\\\"))\\n S3 = df.VectorFunctionSpace(mesh, \\\"Lagrange\\\", 1)\\n m_function = df.interpolate(df.Constant((1, 0, 0)), S3)\\n m = Field(S3, m_function)\\n\\n demag = Demag()\\n demag.setup(m, Field(df.FunctionSpace(mesh, 'DG', 0), Ms), unit_length=1e-9)\\n\\n # Compute demag field\\n H_demag = demag.compute_field()\\n H_demag.shape = (3, -1)\\n x, y, z = H_demag[0], H_demag[1], H_demag[2]\\n\\n print \\\"Max values in direction:\\\"\\n print \\\"x: %g, y: %g, z: %g\\\" % (max(x), max(y), max(z))\\n print \\\"Min values in direction:\\\"\\n print \\\"x: %g, y: %g, z: %g\\\" % (min(x), min(y), min(z))\\n\\n x, y, z = average(x), average(y), average(z)\\n print \\\"Average values in direction\\\"\\n print \\\"x: %g, y: %g, z: %g\\\" % (x, y, z)\\n\\n # Compute relative erros\\n x = abs((x + 1./3*Ms)/Ms)\\n y = abs(y/Ms)\\n z = abs(z/Ms)\\n\\n print \\\"Relative error:\\\"\\n print \\\"x: %g, y: %g, z: %g\\\" % (x, y, z)\\n assert x < TOL, \\\"x-average is %g, should be -1/3.\\\" % x\\n assert y < TOL, \\\"y-average is %g, should be zero.\\\" % y\\n assert z < TOL, \\\"z-average is %g, should be zero.\\\" % z\",\n \"def read_force_field(ff_file, units=\\\"Angstrom\\\", fragment_id=AtomicData.atomic_number):\\n fh = open(ff_file)\\n line = fh.readline()\\n # read number of atoms\\n nat = int(line.split()[0])\\n # skip comment\\n fh.readline()\\n #\\n atomlist = []\\n atomtypes = []\\n partial_charges = []\\n lattice_vectors = []\\n for i in xrange(nat+3):\\n # read nat atoms and at most 3 lattice vectors\\n line = fh.readline()\\n if not line:\\n # end of file reached\\n break\\n words = line.split()\\n x,y,z = map(float, words[1:4])\\n if units == \\\"Angstrom\\\":\\n x,y,z = map(lambda c: c/AtomicData.bohr_to_angs, [x,y,z])\\n if words[0] == \\\"Tv\\\":\\n lattice_vectors.append( [x,y,z] )\\n continue\\n atno = fragment_id(words[0])\\n atomlist.append((atno, [x,y,z]))\\n atomtypes.append(int(words[4]))\\n if len(words) > 5:\\n # 6th column contains partial charges\\n partial_charges.append( float(words[5]) )\\n else:\\n partial_charges.append( 0.0 ) \\n fh.close()\\n if lattice_vectors == []:\\n print \\\"No lattice vectors found\\\"\\n # no lattice vectors were provided\\n # HACK: By setting a lattice vectors to 0, we tell\\n # the function 'build_force_field' that we do not want\\n # a periodic calculation in this direction.\\n # If all lattice vectors are 0, only the atoms in the central\\n # unit cell are included (number of replica cells == 0)\\n lattice_vectors = [ [0.0, 0.0, 0.0],\\n [0.0, 0.0, 0.0],\\n [0.0, 0.0, 0.0] ]\\n\\n assert len(lattice_vectors) == 3, \\\"Need 3 lattice vectors, got %d!\\\" % len(lattice_vectors)\\n return atomlist, atomtypes, partial_charges, lattice_vectors\",\n \"def test_assign_charges_to_molecule_in_parts_using_multiple_library_charges(self):\\n ff = ForceField(\\n get_data_file_path(\\\"test_forcefields/test_forcefield.offxml\\\"),\\n xml_ethanol_library_charges_in_parts_ff,\\n )\\n\\n molecules = [\\n Molecule.from_file(get_data_file_path(\\\"molecules/ethanol.sdf\\\")),\\n Molecule.from_file(get_data_file_path(\\\"molecules/ethanol_reordered.sdf\\\")),\\n ]\\n top = Topology.from_molecules(molecules)\\n omm_system = ff.create_openmm_system(top)\\n nonbondedForce = [\\n f for f in omm_system.getForces() if type(f) == NonbondedForce\\n ][0]\\n expected_charges = [\\n -0.2,\\n -0.1,\\n 0.3,\\n 0.08,\\n -0.02,\\n -0.02,\\n -0.02,\\n -0.01,\\n -0.01,\\n -0.2,\\n 0.3,\\n -0.1,\\n 0.08,\\n -0.02,\\n -0.02,\\n -0.02,\\n -0.01,\\n -0.01,\\n ] * openmm_unit.elementary_charge\\n for particle_index, expected_charge in enumerate(expected_charges):\\n q, _, _ = nonbondedForce.getParticleParameters(particle_index)\\n assert q == expected_charge\",\n \"def test_get_moment_of_inertia_tensor(self):\\n symbols = ['O', 'C', 'C', 'H', 'H', 'H', 'H', 'H', 'H']\\n coords = np.array([[1.28706525, 0.52121353, 0.04219198],\\n [0.39745682, -0.35265044, -0.63649234],\\n [0.36441173, -1.68197093, 0.08682400],\\n [-0.59818222, 0.10068325, -0.65235399],\\n [0.74799641, -0.48357798, -1.66461710],\\n [0.03647269, -1.54932006, 1.12314420],\\n [-0.31340646, -2.38081353, -0.41122551],\\n [1.36475837, -2.12581592, 0.12433596],\\n [2.16336803, 0.09985803, 0.03295192]], np.float64)\\n tensor = get_moment_of_inertia_tensor(coords=coords, symbols=symbols)\\n expected_tensor = [[50.24197604, -15.43600683, -3.07977736],\\n [-15.43600683, 22.20416597, 2.5935549],\\n [-3.07977736, 2.5935549, 55.49144794]]\\n np.testing.assert_almost_equal(tensor, expected_tensor)\",\n \"def test_fractional_bondorder_multiple_same_mol(self):\\n\\n mol = create_ethanol()\\n mol2 = create_reversed_ethanol()\\n\\n forcefield = ForceField(\\n get_data_file_path(\\\"test_forcefields/test_forcefield.offxml\\\"),\\n xml_ff_bo,\\n )\\n topology = Topology.from_molecules([mol, mol2])\\n\\n with pytest.raises(ValueError):\\n forcefield.create_openmm_system(\\n topology,\\n charge_from_molecules=[mol],\\n partial_bond_orders_from_molecules=[mol, mol2],\\n )\",\n \"def test_conversions_matrix_axis_angle_continuous():\\n for angle in np.arange(3.1, 3.2, 0.01):\\n a = np.array([1.0, 0.0, 0.0, angle])\\n R = pr.matrix_from_axis_angle(a)\\n pr.assert_rotation_matrix(R)\\n\\n a2 = pr.axis_angle_from_matrix(R)\\n pr.assert_axis_angle_equal(a, a2)\\n\\n R2 = pr.matrix_from_axis_angle(a2)\\n assert_array_almost_equal(R, R2)\\n pr.assert_rotation_matrix(R2)\",\n \"def ft_ext_force(self):\\r\\n return self._arm.ft_ext_force\",\n \"def check_proper_torsions(self, force0, force1, bond_force0, bond_force1):\\n\\n assert type(force0) == type(force1), \\\"Error: force0 and force1 must be the same type.\\\"\\n assert type(force0) == mm.PeriodicTorsionForce, \\\"Error: forces must be PeriodicTorsionForce\\\"\\n\\n bond_set0 = get_symmetrized_bond_set(bond_force0)\\n bond_set1 = get_symmetrized_bond_set(bond_force1)\\n\\n # Build list of atoms to help make output more useful\\n atoms0 = [ atom for atom in self.simulation0.topology.atoms() ]\\n atoms1 = [ atom for atom in self.simulation1.topology.atoms() ]\\n\\n\\n # Check torsions for equivalent\\n\\n if force0.getNumTorsions() == 0 and force1.getNumTorsions() == 0:\\n return # Must leave now, otherwise try to access torsions that don't exist.\\n\\n F = force0 if force0.getNumTorsions() > 0 else force1 # Either force0 or force1 is nonempty, so find that one.\\n i0, i1, i2, i3, per, phase, k0 = F.getTorsionParameters(0)\\n #phase_unit, k0_unit = phase.unit, k0.unit\\n k0_unit = u.kilojoules_per_mole\\n phase_unit = u.degrees\\n\\n dict0, dict1 = {}, {}\\n for k in range(force0.getNumTorsions()):\\n i0, i1, i2, i3, per, phase, k0 = force0.getTorsionParameters(k)\\n if not is_proper(i0, i1, i2, i3, bond_set0):\\n continue\\n\\n i0, i1, i2, i3 = reorder_proper_torsions(i0, i1, i2, i3)\\n\\n phase, k0 = phase / phase_unit, k0 / k0_unit\\n if k0 == 0.0:\\n continue\\n\\n if not (i0, i1, i2, i3) in dict0:\\n dict0[i0, i1, i2, i3] = []\\n\\n dict0[i0, i1, i2, i3].append((per, phase, k0))\\n\\n for k in range(force1.getNumTorsions()):\\n i0, i1, i2, i3, per, phase, k0 = force1.getTorsionParameters(k)\\n if not is_proper(i0, i1, i2, i3, bond_set1):\\n continue\\n\\n i0, i1, i2, i3 = reorder_proper_torsions(i0, i1, i2, i3)\\n\\n phase, k0 = phase / phase_unit, k0 / k0_unit\\n if k0 == 0.0:\\n continue\\n\\n if not (i0, i1, i2, i3) in dict1:\\n dict1[i0, i1, i2, i3] = []\\n\\n dict1[i0, i1, i2, i3].append((per, phase, k0))\\n\\n keys0 = set(dict0.keys())\\n keys1 = set(dict1.keys())\\n diff_keys = keys0.symmetric_difference(keys1)\\n\\n logger.info(\\\"Propers0 - Propers1 = %s\\\" % (keys0.difference(keys1)))\\n logger.info(\\\"Propers1 - Propers0 = %s\\\" % (keys1.difference(keys0)))\\n assert diff_keys == set(), \\\"Systems have different (proper) PeriodicTorsionForce entries: extra keys are: \\\\n%s\\\" % diff_keys\\n\\n for (i0, i1, i2, i3) in dict0.keys():\\n # Store strings for printing debug info\\n torsion_atoms0 = '%s - %s - %s - %s' % (atoms0[i0].name, atoms0[i1].name, atoms0[i2].name, atoms0[i3].name )\\n torsion_atoms1 = '%s - %s - %s - %s' % (atoms1[i0].name, atoms1[i1].name, atoms1[i2].name, atoms1[i3].name )\\n\\n # Proceed to check\\n entries0 = dict0[i0, i1, i2, i3]\\n entries1 = dict1[i0, i1, i2, i3]\\n if len(entries0) != len(entries1):\\n print(\\\"Compared torsion involving atoms '%s' with that involving atoms '%s': \\\" % (torsion_atoms0, torsion_atoms1))\\n raise Exception(\\\"Error: (proper) PeriodicTorsionForce entry (atoms %d, %d, %d, %d) has different numbers of terms (%d and %d, respectively).\\\" % (i0, i1, i2, i3, len(entries0), len(entries1)))\\n\\n subdict0 = dict(((per, reduce_precision(phase)), k0) for (per, phase, k0) in entries0)\\n subdict1 = dict(((per, reduce_precision(phase)), k0) for (per, phase, k0) in entries1)\\n\\n if set(subdict0.keys()) != set(subdict1.keys()):\\n print(\\\"Compared torsion involving atoms '%s' with that involving atoms '%s': \\\" % (torsion_atoms0, torsion_atoms1))\\n print(\\\"Keys for system0: '%s'; keys for system1: '%s'\\\" % (subdict0.keys(), subdict1.keys() ) )\\n raise Exception(\\\"Error: (proper) PeriodicTorsionForce entry (atoms %d, %d, %d, %d) has different terms.\\\" % (i0, i1, i2, i3) )\\n\\n for (per, phase) in subdict0.keys():\\n val0 = subdict0[per, phase]\\n val1 = subdict1[per, phase]\\n if not compare(val0, val1):\\n print(\\\"Compared torsion involving atoms '%s' with that involving atoms '%s': \\\" % (torsion_atoms0, torsion_atoms1))\\n raise Exception( \\\"Error: (proper) PeriodicTorsionForce (atoms %d, %d, %d, %d, periodicity %d, phase %f degrees) has barrier height values of %f and %f kJ/mol, respectively.\\\" % (i0, i1, i2, i3, per, phase, val0, val1) )\",\n \"def test_run_mantel_test_no_cdm(self):\\r\\n self.assertRaises(ValueError, run_mantel_test, 'partial_mantel',\\r\\n [self.fp1, self.fp2], [self.dm1,\\r\\n self.dm2], self.num_perms,\\r\\n 'two sided', self.comment, self.alpha)\",\n \"def test_euler_angles_1q_hard_thetas(self, gate):\\n self.check_one_qubit_euler_angles(Operator(gate))\",\n \"def test_maf(self):\\n # Flipping the strand\\n self.assertAlmostEqual(self.g.maf(), 8 / 18)\",\n \"def is_valid(self):\\n return (4 * (self.a ** 3) + 27 * (self.b ** 2)) % self.fp != 0\",\n \"def CalcForce_aeroframe_DEP(V, CoefMatrix, x, rho, g):\\r\\n\\r\\n #Compute aero forces\\r\\n # here x must be of the form (alpha, beta, p, q, r, da, dr, de) (last one punctualy used)\\r\\n # set non dim for p,q,r\\r\\n nonDim=np.ones(7)\\r\\n nonDim[2]=g.b/(2*V)\\r\\n nonDim[3]=g.c/(2*V)\\r\\n nonDim[4]=g.b/(2*V)\\r\\n # F=np.dot(CoefMatrix,x[0:7]) # commented form, modification to account for symmetric drag increase of side slip\\r\\n F=np.zeros((3))\\r\\n M=np.zeros((3))\\r\\n xsym=np.copy(x[0:-1])\\r\\n xsym[1]=abs(xsym[1]) # make beta always positive since derivatives have already correct sign for drag and lift only\\r\\n xsym[-3]=abs(xsym[-3]) # make ailerons deflection always positive for drag increase and lift decrease\\r\\n xsym[-1]=abs(xsym[-1]) # make rudder deflection always positive for drag increase and lift decrease\\r\\n F[0]=np.dot(CoefMatrix[0],xsym)\\r\\n F[1]=np.dot(CoefMatrix[1],x[0:-1]) #side force\\r\\n F[2]=np.dot(CoefMatrix[2],xsym)\\r\\n M=np.dot(CoefMatrix[3:6,:],x[0:-1])\\r\\n# print(\\\"Printing moment coeff\\\")\\r\\n# print(M)\\r\\n\\r\\n \\r\\n #No need to project\\r\\n# alpha=x[0]\\r\\n# beta=x[1]\\r\\n# H=np.array([[math.cos(alpha)*math.sin(beta), -math.cos(alpha)*math.sin(beta), -math.sin(alpha)],[math.sin(beta), math.cos(beta), 0],[math.sin(alpha)*math.cos(beta), -math.sin(alpha)*math.sin(beta), math.cos(alpha)]])\\r\\n if V<=71 :\\r\\n Fbody=np.array([-F[0]-g.Cd0_fl,F[1],-F[2]-g.CL0_fl]) # add alpha=0 coefficients\\r\\n Moment=M+np.array([0,x[-1]*g.Cm_de+g.Cm0_fl,0])\\r\\n else:\\r\\n Fbody=np.array([-F[0]-g.Cd0,F[1],-F[2]-g.CL0]) # add alpha=0 coefficients\\r\\n Moment=M+np.array([0,x[-1]*g.Cm_de+g.Cm0,0])\\r\\n \\r\\n\\r\\n Fbody=0.5*V**2.0*rho*g.S*Fbody\\r\\n Moment=0.5*V**2.0*rho*g.S*g.b*Moment\\r\\n \\r\\n return np.append(Fbody, Moment)\",\n \"def test_force(self):\\n group = hoomd.group.all()\\n\\n # compute forces\\n f = azplugins.restrain.plane(group=group, point=(0,0,0), normal=(1,0,0), k=2.0)\\n hoomd.run(1)\\n np.testing.assert_array_almost_equal(f.forces[0].force, (-2.,0,0))\\n np.testing.assert_array_almost_equal(f.forces[1].force, ( 2.,0,0))\\n np.testing.assert_array_almost_equal(f.forces[2].force, ( 6.,0,0))\\n self.assertAlmostEqual(f.forces[0].energy, 1.)\\n self.assertAlmostEqual(f.forces[1].energy, 1.)\\n self.assertAlmostEqual(f.forces[2].energy, 9.)\\n np.testing.assert_array_almost_equal(f.forces[0].virial, (-2.,0,0,0,0,0))\\n np.testing.assert_array_almost_equal(f.forces[1].virial, (-2.,0,4.,0,0,0))\\n np.testing.assert_array_almost_equal(f.forces[2].virial, (12.,0,0,0,0,0))\\n\\n # change the spring constant\\n f.set_params(k=1.0)\\n hoomd.run(1)\\n np.testing.assert_array_almost_equal(f.forces[0].force, (-1.,0,0))\\n np.testing.assert_array_almost_equal(f.forces[1].force, ( 1.,0,0))\\n np.testing.assert_array_almost_equal(f.forces[2].force, ( 3.,0,0))\\n self.assertAlmostEqual(f.forces[0].energy, 0.5)\\n self.assertAlmostEqual(f.forces[1].energy, 0.5)\\n self.assertAlmostEqual(f.forces[2].energy, 4.5)\\n\\n # shift the plane down\\n f.set_params(point=(-1,0,0))\\n hoomd.run(1)\\n np.testing.assert_array_almost_equal(f.forces[0].force, (-2.,0,0))\\n np.testing.assert_array_almost_equal(f.forces[1].force, ( 0.,0,0))\\n np.testing.assert_array_almost_equal(f.forces[2].force, ( 2.,0,0))\\n self.assertAlmostEqual(f.forces[0].energy, 2.0)\\n self.assertAlmostEqual(f.forces[1].energy, 0.0)\\n self.assertAlmostEqual(f.forces[2].energy, 2.0)\\n\\n # rotate the plane so that only particle 1 is off the line\\n f.set_params(point=(0,0,0), normal=(0,0,1))\\n hoomd.run(1)\\n np.testing.assert_array_almost_equal(f.forces[0].force, (0,0,0))\\n np.testing.assert_array_almost_equal(f.forces[1].force, (0,0,-2))\\n np.testing.assert_array_almost_equal(f.forces[2].force, (0,0,0))\\n self.assertAlmostEqual(f.forces[0].energy, 0.0)\\n self.assertAlmostEqual(f.forces[1].energy, 2.0)\\n self.assertAlmostEqual(f.forces[2].energy, 0.0)\",\n \"def calculate_allowable_angles(self, angular_resolution=0.01, visualize=0, optimized=False):\\n #Could be optimized more, if required.\\n \\n if visualize:\\n pylab.ion() #Turns interaction on (?)\\n print \\\"Calculation started\\\"\\n\\n if angular_resolution < self.ANGULAR_RESOLUTION_MIN:\\n warnings.warn(\\\"Requested too small angular resolution. Using %s\\\" % self.ANGULAR_RESOLUTION_MIN)\\n angular_resolution = self.ANGULAR_RESOLUTION_MIN\\n\\n #We do not need to look at more than the motor step size in phi, since the sample rotational\\n # motor does the rest.\\n self.phi_range = 0.99 * (self.sample_motor_step_size / 2)\\n #Arbitrary max ranges here. TODO: User setting?\\n self.chi_range = pi/8\\n self.omega_range = pi/6\\n\\n #Make the lists\\n self.phi_list = array([-self.phi_range, 0, self.phi_range])\\n self.phi_list = np.append(np.arange(-self.phi_range, self.phi_range, angular_resolution), (self.phi_range) )\\n self.chi_list = np.arange(-self.chi_range, self.chi_range, angular_resolution)\\n self.omega_list = np.arange(-self.omega_range, self.omega_range, angular_resolution)\\n\\n #Create the allowed angle map, all false\\n self.allowed = np.zeros( (self.phi_list.size, self.chi_list.size, self.omega_list.size), dtype=np.bool )\\n\\n #Make sure the limits are calculated\\n self.calculate_leg_xy_limits()\\n\\n\\n #Loop through all the angles\\n for i_phi in range(self.phi_list.size):\\n phi = self.phi_list[i_phi]\\n print 'Calculating phi = %s' % phi\\n was_anything_in_line = False\\n for i_chi in range(self.chi_list.size):\\n chi = self.chi_list[i_chi]\\n was_allowed = False\\n for i_omega in range(self.omega_list.size):\\n omega = self.omega_list[i_omega]\\n\\n #Calcualte the leg position from these angles\\n self.getplatepos(phi, chi, omega)\\n #Make sure the legs are not in fault\\n self.check_limits()\\n allowed = not any(self.leg_fault)\\n #Save it\\n self.allowed[i_phi, i_chi, i_omega] = allowed\\n if optimized:\\n #Check that we have reached an unallowed section, to speed calculation\\n if allowed: was_allowed = True\\n if was_allowed and (not allowed):\\n break #All other omega values in this chi will be false. Exit to the next line\\n #(end of omega loop)\\n\\n if optimized:\\n #Is there anything allowed in this chi line?\\n anything_in_line = any(self.allowed[i_phi, i_chi, :])\\n #Once we reach a completely disallowed line, all others after will be too\\n if anything_in_line: was_anything_in_line = True\\n if was_anything_in_line and (not anything_in_line):\\n break #we don't need to look at the remaining lines.\\n #(end of chi loop)\\n #(end of phi loop)\\n\\n print \\\"Done!\\\"\\n \\n if visualize==1:\\n #2D Animated plot\\n for i_phi in range(self.phi_list.size):\\n phi = self.phi_list[i_phi]\\n #Here we are still in the phi loop\\n if visualize:\\n pylab.figure(0)\\n pylab.imshow(self.allowed[i_phi, :, :], interpolation='nearest', extent=(-self.omega_range, self.omega_range, -self.chi_range, self.chi_range))\\n pylab.xlabel(\\\"Omega\\\")\\n pylab.ylabel(\\\"Chi\\\")\\n pylab.title(\\\"Allowable angles for phi=%s\\\" % phi)\\n pylab.draw()\\n time.sleep(0.2)\\n pylab.draw()\\n time.sleep(1)\\n pylab.ion()\\n \\n\\n if visualize==2:\\n #Single 3D plot of allowed angles.\\n mlab.clf() #Clear figure\\n mlab.contour3d(self.allowed.astype(float), contours=[0.5])\\n mlab.xlabel(\\\"Phi\\\")\\n mlab.ylabel(\\\"Chi\\\")\\n mlab.zlabel(\\\"Omega\\\")\\n mlab.axes()\\n mlab.show()\\n\\n #Done calculating\\n return None\",\n \"def check_doa(geometry, doa):\\n if doa < 0:\\n return False\\n if geometry == \\\"linear\\\" and doa > 180:\\n return False\\n if geometry == \\\"circular\\\" and doa >= 360:\\n return False\\n return True\",\n \"def HFincidentAngle(self,PFC, MHD):\\n xyz = PFC.centers\\n r,z,phi = tools.xyz2cyl(xyz[:,0],xyz[:,1],xyz[:,2])\\n BNorms = MHD.Bfield_pointcloud(PFC.ep, r, z, phi, PFC.powerDir, normal=True)\\n PFC.bdotn = np.multiply(PFC.norms, BNorms).sum(1)\\n return\",\n \"def force_12(alpha, r1, r2, R_particle, eps_particle, k, eps_out, eps_in,\\n fiber_radius, nmin, nmax, kzimax, E0_mod, nmin_sc, nmax_sc, case):\\n\\n dr = 1 / k * 1e-5\\n dz = dr\\n dtheta = 1e-5\\n\\n p1 = dipole_moment(1, r1, r2, R_particle, eps_particle, k, eps_out, eps_in,\\n fiber_radius, nmin, nmax, kzimax,\\n E0_mod, nmin_sc, nmax_sc, case)\\n p1c = p1.conjugate()\\n\\n # Fr\\n if alpha == 0:\\n r1plusdr = r1 + np.array([dr, 0, 0])\\n r1minusdr = r1 - np.array([dr, 0, 0])\\n Eplusr = total_loc_efield(1, r1plusdr, r2, k, case, nmin, nmax, kzimax,\\n fiber_radius, eps_out, eps_in, E0_mod,\\n nmin_sc, nmax_sc, R_particle, eps_particle)\\n Eminusr = total_loc_efield(1, r1minusdr, r2, k, case, nmin, nmax, kzimax,\\n fiber_radius, eps_out, eps_in, E0_mod,\\n nmin_sc, nmax_sc, R_particle, eps_particle)\\n grad_r = (Eplusr - Eminusr) / (2 * dr)\\n\\n return(0.5 * np.dot(p1c, grad_r).real)\\n # Ftheta\\n elif alpha == 1:\\n r1plusdtheta = r1 + np.array([0, dtheta, 0])\\n r1minusdtheta = r1 - np.array([0, dtheta, 0])\\n\\n Eplustheta = total_loc_efield(1, r1plusdtheta, r2, k, case, nmin, nmax, kzimax,\\n fiber_radius, eps_out, eps_in, E0_mod,\\n nmin_sc, nmax_sc, R_particle, eps_particle)\\n Eminustheta = total_loc_efield(1, r1minusdtheta, r2, k, case, nmin, nmax, kzimax,\\n fiber_radius, eps_out, eps_in, E0_mod,\\n nmin_sc, nmax_sc, R_particle, eps_particle)\\n grad_theta = (Eplustheta - Eminustheta) / (r1[0] * 2 * dtheta)\\n\\n return(0.5 * np.dot(p1c, grad_theta).real)\\n # Fz\\n elif alpha == 2:\\n r1plusdz = r1 + np.array([0, 0, dz])\\n r1minusdz = r1 - np.array([0, 0, dz])\\n\\n Eplusz = total_loc_efield(1, r1plusdz, r2, k, case, nmin, nmax, kzimax,\\n fiber_radius, eps_out, eps_in, E0_mod,\\n nmin_sc, nmax_sc, R_particle, eps_particle)\\n Eminusz = total_loc_efield(1, r1minusdz, r2, k, case, nmin, nmax, kzimax,\\n fiber_radius, eps_out, eps_in, E0_mod,\\n nmin_sc, nmax_sc, R_particle, eps_particle)\\n grad_z = (Eplusz - Eminusz) / (2 * dz)\\n\\n return(0.5 * np.dot(p1c, grad_z).real)\\n else:\\n print('alpha is out of range!')\\n return(0)\",\n \"def checkForwardBackwardUnity(self):\\n if round(self.alpha[-1,-1] - self.beta[0, 0], 7) != 0:\\n print('')\\n raise BaumWelchForwardBackwardDifference(self.alpha[-1,-1], self.beta[0,0])\",\n \"def check_improper_torsions(self, force0, force1, bond_force0, bond_force1):\\n\\n assert type(force0) == type(force1), \\\"Error: force0 and force1 must be the same type.\\\"\\n assert type(force0) == mm.PeriodicTorsionForce, \\\"Error: forces must be PeriodicTorsionForce\\\"\\n\\n bond_set0 = get_symmetrized_bond_set(bond_force0)\\n bond_set1 = get_symmetrized_bond_set(bond_force1)\\n\\n if force0.getNumTorsions() == 0 and force1.getNumTorsions() == 0:\\n return # Must leave now, otherwise try to access torsions that don't exist.\\n\\n F = force0 if force0.getNumTorsions() > 0 else force1 # Either force0 or force1 is nonempty, so find that one.\\n i0, i1, i2, i3, per, phase, k0 = F.getTorsionParameters(0)\\n #phase_unit, k0_unit = phase.unit, k0.unit\\n k0_unit = u.kilojoules_per_mole\\n phase_unit = u.degrees\\n\\n dict0, dict1 = {}, {}\\n for k in range(force0.getNumTorsions()):\\n i0, i1, i2, i3, per, phase, k0 = force0.getTorsionParameters(k)\\n if not is_improper(i0, i1, i2, i3, bond_set0):\\n continue\\n\\n i0, i1, i2, i3 = reorder_improper_torsions(i0, i1, i2, i3, bond_set0)\\n\\n phase, k0 = phase / phase_unit, k0 / k0_unit\\n if k0 == 0.0:\\n continue\\n\\n if not (i0, i1, i2, i3) in dict0:\\n dict0[i0, i1, i2, i3] = []\\n\\n dict0[i0, i1, i2, i3].append((per, phase, k0))\\n\\n for k in range(force1.getNumTorsions()):\\n i0, i1, i2, i3, per, phase, k0 = force1.getTorsionParameters(k)\\n if not is_improper(i0, i1, i2, i3, bond_set1):\\n continue\\n\\n i0, i1, i2, i3 = reorder_improper_torsions(i0, i1, i2, i3, bond_set0)\\n\\n phase, k0 = phase / phase_unit, k0 / k0_unit\\n if k0 == 0.0:\\n continue\\n\\n if not (i0, i1, i2, i3) in dict1:\\n dict1[i0, i1, i2, i3] = []\\n\\n dict1[i0, i1, i2, i3].append((per, phase, k0))\\n\\n keys0 = set(dict0.keys())\\n keys1 = set(dict1.keys())\\n diff_keys = keys0.symmetric_difference(keys1)\\n\\n logger.info(\\\"Impropers0 - Impropers1 = %s\\\" % (keys0.difference(keys1)))\\n logger.info(\\\"Impropers1 - Impropers0 = %s\\\" % (keys1.difference(keys0)))\\n assert diff_keys == set(), \\\"Systems have different (improper) PeriodicTorsionForce entries: extra keys are: \\\\n%s\\\" % diff_keys\\n\\n for (i0, i1, i2, i3) in dict0.keys():\\n entries0 = dict0[i0, i1, i2, i3]\\n entries1 = dict1[i0, i1, i2, i3]\\n assert len(entries0) == len(entries1), \\\"Error: (improper) PeriodicTorsionForce entry (%d, %d, %d, %d) has different numbers of terms (%d and %d, respectively).\\\" % (i0, i1, i2, i3, len(entries0), len(entries1))\\n\\n subdict0 = dict(((per, reduce_precision(phase)), k0) for (per, phase, k0) in entries0)\\n subdict1 = dict(((per, reduce_precision(phase)), k0) for (per, phase, k0) in entries1)\\n\\n assert set(subdict0.keys()) == set(subdict1.keys()), \\\"Error: (improper) PeriodicTorsionForce entry (%d, %d, %d, %d) has different terms.\\\" % (i0, i1, i2, i3)\\n\\n for (per, phase) in subdict0.keys():\\n val0 = subdict0[per, phase]\\n val1 = subdict1[per, phase]\\n assert compare(val0, val1), \\\"Error: (improper) PeriodicTorsionForce (atoms %d, %d, %d, %d, periodicity %d, phase %f degrees) has barrier height values of %f and %f kJ/mol, respectively.\\\" % (i0, i1, i2, i3, per, phase, val0, val1)\",\n \"def read_forces(self, fname):\\n outfile = open(fname)\\n lines = outfile.readlines()\\n outfile.close()\\n nats = len(self.atoms)\\n forces = np.zeros((nats, 3), float)\\n infinite_force=\\\"*****\\\"\\n if 'mozyme' in self.str_params['job_type'].lower():\\n for i, line in enumerate(lines):\\n if line.find('FINAL POINT AND DERIVATIVES') != -1:\\n for j in range(nats):\\n gline = lines[i + j + 5]\\n pre_force=gline[8:35]\\n if(infinite_force in pre_force):\\n forces[j] = [999999999.9999,999999999.9999,999999999.9999]\\n else:\\n forces[j] = [float( pre_force[0:9].strip()),float( pre_force[9:18].strip()),float( pre_force[18:27].strip())]\\n else:\\n for i, line in enumerate(lines):\\n if line.find('GRADIENT\\\\n') != -1:\\n for j in range(nats * 3):\\n gline = lines[i + j + 1]\\n pre_force=gline[49:62]\\n if(infinite_force in pre_force):\\n forces[int(j/3), int(j%3)] =999999999.9999\\n else:\\n forces[int(j/3), int(j%3)] = float(pre_force)\\n break\\n#do not change unit for mopac\\n forces *= - (kcal / mol)\\n return forces\",\n \"def test_remove_translational_rotational_dof(positions):\\n class DummyTimeStep:\\n def __init__(self, positions):\\n self.positions = positions\\n self.n_atoms = len(positions)\\n ts = DummyTimeStep(positions=positions)\\n\\n transform = RemoveTransRotDOF(\\n center_atom_idx=0,\\n axis_atom_idx=2,\\n plane_atom_idx=3,\\n axis='z',\\n plane='xz'\\n )\\n ts = transform(ts)\\n\\n # The center atom is at the origin.\\n assert np.allclose(ts.positions[transform._center_atom_idx], 0.0)\\n\\n # The axis atom is on the expected axis.\\n expected_axis_atom_position = transform.axis * np.linalg.norm(\\n positions[transform._axis_atom_idx] - positions[transform._center_atom_idx])\\n assert np.allclose(ts.positions[transform._axis_atom_idx], expected_axis_atom_position)\\n\\n # The plane atom is orthogonal to the plane normal.\\n assert np.allclose(np.dot(ts.positions[transform._plane_atom_idx], transform.plane), 0.0)\\n\\n # The constrained atom indices is correct.\\n expected = np.array([0, 1, 2, 6, 7, 10])\\n assert np.all(transform.constrained_dof_indices == expected)\",\n \"def magnetisation(field):\\n norm_field = df.Field(field.mesh, dim=1, value=(field.norm.array != 0))\\n volume = df.integral(norm_field * df.dV, direction='xyz')\\n return df.integral(field * df.dV / volume, direction='xyz')\",\n \"def validate_pmf(pmf, ops):\\n validate_normalization(pmf, ops)\\n validate_probabilities(pmf, ops)\\n return True\",\n \"def diwire_dfm(pl):\\n\\t# check angle\\n\\ttake3 = takeNGenerator(pl.points, 3)\\n\\tvalid = reduce(lambda flag, p: flag and (getAngle(*p) <= 135), take3, True)\\n\\t# check distance\\n\\ttake2 = takeNGenerator(pl.points, 2)\\n\\tvalid = reduce(lambda flag, p: flag and (\\n\\t\\tgetDistance(*p) >= 12), take2, valid)\\n\\tif valid:\\n\\t\\treturn True\\n\\telse:\\n\\t\\treturn False\",\n \"def _determine_extra_angles(self, angle_force, reference_topology, growth_indices):\\n from simtk import openmm\\n import itertools\\n from openeye import oechem, oeomega\\n\\n if len(growth_indices)==0:\\n return\\n angle_force_constant = 400.0*unit.kilojoules_per_mole/unit.radians**2\\n atoms = list(reference_topology.atoms())\\n growth_indices = list(growth_indices)\\n #get residue from first atom\\n residue = atoms[growth_indices[0].idx].residue\\n try:\\n oemol = FFAllAngleGeometryEngine._oemol_from_residue(residue)\\n except Exception as e:\\n print(\\\"Could not generate an oemol from the residue.\\\")\\n print(e)\\n\\n #get the omega geometry of the molecule:\\n\\n omega = oeomega.OEOmega()\\n omega.SetMaxConfs(1)\\n omega.SetStrictStereo(False) #TODO: fix stereochem\\n omega(oemol)\\n\\n #we now have the residue as an oemol. Time to find the relevant angles.\\n #There's no equivalent to OEGetTorsions, so first find atoms that are relevant\\n #TODO: find out if that's really true\\n aromatic_pred = oechem.OEIsAromaticAtom()\\n heavy_pred = oechem.OEIsHeavy()\\n angle_criteria = oechem.OEAndAtom(aromatic_pred, heavy_pred)\\n\\n #get all heavy aromatic atoms:\\n #TODO: do this more efficiently\\n heavy_aromatics = list(oemol.GetAtoms(angle_criteria))\\n for atom in heavy_aromatics:\\n #bonded_atoms = [bonded_atom for bonded_atom in list(atom.GetAtoms()) if bonded_atom in heavy_aromatics]\\n bonded_atoms = list(atom.GetAtoms())\\n for angle_atoms in itertools.combinations(bonded_atoms, 2):\\n angle = oechem.OEGetAngle(oemol, angle_atoms[0], atom, angle_atoms[1])\\n atom_indices = [angle_atoms[0].GetData(\\\"topology_index\\\"), atom.GetData(\\\"topology_index\\\"), angle_atoms[1].GetData(\\\"topology_index\\\")]\\n angle_radians = angle*unit.radian\\n growth_idx = self._calculate_growth_idx(atom_indices, growth_indices)\\n #If this is a CustomAngleForce, we need to pass the parameters as a list, and it will have the growth_idx parameter.\\n #If it's a regular HarmonicAngleForce, there is no growth_index and the parameters are passed separately.\\n if isinstance(angle_force, openmm.CustomAngleForce):\\n angle_force.addAngle(atom_indices[0], atom_indices[1], atom_indices[2], [angle_radians, angle_force_constant, growth_idx])\\n elif isinstance(angle_force, openmm.HarmonicAngleForce):\\n angle_force.addAngle(atom_indices[0], atom_indices[1], atom_indices[2], angle_radians, angle_force_constant)\\n else:\\n raise ValueError(\\\"Angle force must be either CustomAngleForce or HarmonicAngleForce\\\")\\n return angle_force\",\n \"def test_norm_compact_axis_angle():\\n a = np.array([np.pi, 0.0, 0.0])\\n n = pr.norm_compact_axis_angle(a)\\n assert_array_almost_equal(a, n)\\n\\n a = np.array([0.0, np.pi, 0.0])\\n n = pr.norm_compact_axis_angle(a)\\n assert_array_almost_equal(a, n)\\n\\n a = np.array([0.0, 0.0, np.pi])\\n n = pr.norm_compact_axis_angle(a)\\n assert_array_almost_equal(a, n)\\n\\n random_state = np.random.RandomState(0)\\n for _ in range(5):\\n a = pr.random_compact_axis_angle(random_state)\\n axis = a / np.linalg.norm(a)\\n angle = random_state.uniform(-20.0, -10.0 + 2.0 * np.pi)\\n a = axis * angle\\n n = pr.norm_compact_axis_angle(a)\\n for angle_offset in np.arange(0.0, 10.1 * np.pi, 2.0 * np.pi):\\n a = axis * (angle + angle_offset)\\n n2 = pr.norm_compact_axis_angle(a)\\n assert_array_almost_equal(n, n2)\",\n \"def backward_phi(self):\\n for f in self.component_fields:\\n f.require_grid_space()\",\n \"def isAcute(trpl):\\n vd = vectorFormat(trpl)\\n if angle_between(*vd) < np.pi/2:\\n return True\\n else:\\n return False\",\n \"def test_norm_axis_angle():\\n a = np.array([1.0, 0.0, 0.0, np.pi])\\n n = pr.norm_axis_angle(a)\\n assert_array_almost_equal(a, n)\\n\\n a = np.array([0.0, 1.0, 0.0, np.pi])\\n n = pr.norm_axis_angle(a)\\n assert_array_almost_equal(a, n)\\n\\n a = np.array([0.0, 0.0, 1.0, np.pi])\\n n = pr.norm_axis_angle(a)\\n assert_array_almost_equal(a, n)\\n\\n random_state = np.random.RandomState(0)\\n for _ in range(5):\\n a = pr.random_axis_angle(random_state)\\n angle = random_state.uniform(-20.0, -10.0 + 2.0 * np.pi)\\n a[3] = angle\\n n = pr.norm_axis_angle(a)\\n for angle_offset in np.arange(0.0, 10.1 * np.pi, 2.0 * np.pi):\\n a[3] = angle + angle_offset\\n n2 = pr.norm_axis_angle(a)\\n assert_array_almost_equal(n, n2)\",\n \"def mod_check(x, y):\\r\\n if (as_tensor_variable(x).dtype in complex_dtypes or\\r\\n as_tensor_variable(y).dtype in complex_dtypes):\\r\\n # Currently forbidden.\\r\\n raise scal.Mod.complex_error\\r\\n else:\\r\\n return mod(x, y)\",\n \"def _is_trivial_angle(rad: float, atol: float) -> bool:\\n return abs(rad) < atol or abs(abs(rad) - np.pi / 4) < atol\",\n \"def assert_no_error(self): \\r\\n Nx = self['Nx']\\r\\n Nt = self.m.Nt\\r\\n L, T = self.problem['L T'.split()]\\r\\n L = L/2 # only half the domain used (symmetry)\\r\\n x = np.linspace(0, L, Nx+1) # Mesh points in space \\r\\n t = np.linspace(0, T, Nt+1) # Mesh points in time\\r\\n \\r\\n for n in range(len(t)):\\r\\n u_e = self.problem.u_exact(x, t[n])\\r\\n diff = np.abs(self.f.u[n,:] - u_e).max()\\r\\n print 'diff:', diff\\r\\n tol = 1E-13\\r\\n assert diff < tol\",\n \"def assertAngle(self, angle: float):\\n assert isinstance(angle, float), f\\\"bad angle instance, type of angle is {type(angle)}\\\"\\n assert -180 <= angle <= 180\",\n \"def test_fractional_bondorder_from_molecule(\\n self,\\n get_molecule,\\n k_torsion_interpolated,\\n k_bond_interpolated,\\n length_bond_interpolated,\\n central_atoms,\\n ):\\n mol = get_molecule()\\n forcefield = ForceField(\\n get_data_file_path(\\\"test_forcefields/test_forcefield.offxml\\\"), xml_ff_bo\\n )\\n topology = Topology.from_molecules(mol)\\n\\n omm_system = forcefield.create_openmm_system(\\n topology,\\n charge_from_molecules=[mol],\\n partial_bond_orders_from_molecules=[mol],\\n )\\n\\n # Verify that the assigned bond parameters were correctly interpolated\\n off_bond_force = [\\n force\\n for force in omm_system.getForces()\\n if isinstance(force, openmm.HarmonicBondForce)\\n ][0]\\n\\n for idx in range(off_bond_force.getNumBonds()):\\n params = off_bond_force.getBondParameters(idx)\\n\\n atom1, atom2 = params[0], params[1]\\n atom1_mol, atom2_mol = central_atoms\\n\\n if ((atom1 == atom1_mol) and (atom2 == atom2_mol)) or (\\n (atom1 == atom2_mol) and (atom2 == atom1_mol)\\n ):\\n k = params[-1]\\n length = params[-2]\\n assert_almost_equal(k / k.unit, k_bond_interpolated)\\n assert_almost_equal(length / length.unit, length_bond_interpolated)\\n\\n # Verify that the assigned torsion parameters were correctly interpolated\\n off_torsion_force = [\\n force\\n for force in omm_system.getForces()\\n if isinstance(force, openmm.PeriodicTorsionForce)\\n ][0]\\n\\n for idx in range(off_torsion_force.getNumTorsions()):\\n params = off_torsion_force.getTorsionParameters(idx)\\n\\n atom2, atom3 = params[1], params[2]\\n atom2_mol, atom3_mol = central_atoms\\n\\n if ((atom2 == atom2_mol) and (atom3 == atom3_mol)) or (\\n (atom2 == atom3_mol) and (atom3 == atom2_mol)\\n ):\\n k = params[-1]\\n assert_almost_equal(k / k.unit, k_torsion_interpolated)\",\n \"def test_get_principal_moments_of_inertia(self):\\n numbers = [6, 6, 8, 1, 1, 1, 1, 1, 1]\\n coords = np.array([[1.235366, -0.257231, -0.106315],\\n [0.083698, 0.554942, 0.046628],\\n [-1.210594, -0.239505, -0.021674],\\n [0.132571, 1.119728, 0.987719],\\n [0.127795, 1.278999, -0.769346],\\n [-1.272620, -0.962700, 0.798216],\\n [-2.074974, 0.426198, 0.055846],\\n [-1.275744, -0.785745, -0.965493],\\n [1.241416, -0.911257, 0.593856]], np.float64)\\n principal_moments_of_inertia = get_principal_moments_of_inertia(coords=coords, numbers=numbers)[0]\\n expected_principal_moments_of_inertia = [60.98026894, 53.83156297, 14.48858465]\\n for moment, expected_moment in zip(principal_moments_of_inertia, expected_principal_moments_of_inertia):\\n self.assertAlmostEqual(moment, expected_moment)\\n\\n symbols = ['N', 'O', 'O'] # test a linear molecule\\n coords = np.array([[0.000000, 0.000000, 1.106190],\\n [0.000000, 0.000000, -0.072434],\\n [0.000000, 0.000000, -1.191782]], np.float64)\\n with self.assertRaises(InputError):\\n get_principal_moments_of_inertia(coords=coords, numbers=numbers)\\n principal_moments_of_inertia, axes = get_principal_moments_of_inertia(coords=coords, symbols=symbols)\\n expected_principal_moments_of_inertia = [39.4505153, 39.4505153, 0.0]\\n expected_axes = [[1, 0, 0], [0, 1, 0], [0, 0, 1]]\\n for moment, expected_moment in zip(principal_moments_of_inertia, expected_principal_moments_of_inertia):\\n self.assertAlmostEqual(moment, expected_moment)\\n for axis, expected_axis in zip(axes, expected_axes):\\n for entry, expected_entry in zip(axis, expected_axis):\\n self.assertAlmostEqual(entry, expected_entry)\\n self.assertIsInstance(principal_moments_of_inertia, tuple)\\n self.assertIsInstance(axes, tuple)\",\n \"def test_angle_angle_explicit(pcff):\\n\\n expected = {\\n \\\"K\\\": \\\"3.5475\\\",\\n \\\"reference\\\": \\\"1\\\",\\n \\\"Theta10\\\": \\\"107.6600\\\",\\n \\\"Theta20\\\": \\\"105.8500\\\",\\n }\\n\\n i = \\\"h\\\"\\n j = \\\"c\\\"\\n k = \\\"h\\\"\\n l = \\\"n+\\\" # noqa: E741\\n ptype, key, form, parameters = pcff.angle_angle_parameters(i, j, k, l)\\n assert ptype == \\\"explicit\\\"\\n assert key == (\\\"h\\\", \\\"c\\\", \\\"h\\\", \\\"n+\\\")\\n assert parameters == expected\",\n \"def test_t(self):\\n assert np.isclose(self.stepper.t, self.final_t)\",\n \"def test_charge_increment_model_one_less_ci_than_tagged_atom(self):\\n # Make a FF from each OFFXML string\\n file_path = get_data_file_path(\\\"test_forcefields/test_forcefield.offxml\\\")\\n ff1 = ForceField(file_path, xml_charge_increment_model_ff_one_less_ci)\\n del ff1._parameter_handlers[\\\"ToolkitAM1BCC\\\"]\\n ff2 = ForceField(file_path, xml_charge_increment_model_ff_no_missing_cis)\\n del ff2._parameter_handlers[\\\"ToolkitAM1BCC\\\"]\\n top = Topology.from_molecules([create_ethanol()])\\n # Make a system from each FF\\n sys1 = ff2.create_openmm_system(top)\\n sys2 = ff2.create_openmm_system(top)\\n # Extract the nonbonded force from each system\\n nonbonded_force1 = [\\n force\\n for force in sys1.getForces()\\n if isinstance(force, openmm.NonbondedForce)\\n ][0]\\n nonbonded_force2 = [\\n force\\n for force in sys2.getForces()\\n if isinstance(force, openmm.NonbondedForce)\\n ][0]\\n\\n # Ensure that the systems both have the correct charges assigned\\n expected_charges = [\\n 0.17,\\n -0.18,\\n -0.04,\\n 0.01,\\n 0.01,\\n 0.01,\\n 0.01,\\n 0.01,\\n 0.0,\\n ] * openmm_unit.elementary_charge\\n for idx, expected_charge in enumerate(expected_charges):\\n charge1, _, _ = nonbonded_force1.getParticleParameters(idx)\\n charge2, _, _ = nonbonded_force2.getParticleParameters(idx)\\n assert (\\n abs(charge1 - expected_charge) < 1.0e-6 * openmm_unit.elementary_charge\\n )\\n assert charge1 == charge2\",\n \"def search_base_angles(self, motor_positions):\\n\\n # Errore nelle soluzioni\\n err = [0, 0, 0]\\n\\n # Angolo di inizio ricerca\\n # Se gia' eseguita una conversione suo i valori precedenti\\n if self.isLastAnglesValid:\\n self.alpha_start = list(self.alpha)\\n else:\\n # Angolo minimo di partenza ( -alpha_limit )\\n # TO_CHECK: perche' parto da una configurazione sicuramente errata? -10?\\n self.alpha_start = [self.alpha_limit_r, self.alpha_limit_r, self.alpha_limit_r]\\n\\n # Angoli presunti\\n # self.temp = list(self.alpha_start)\\n alpha = list(self.alpha_start)\\n\\n # Altezze reali degli attuatori\\n height = [self.real_height + motor_positions[0],\\n self.real_height + motor_positions[1],\\n self.real_height + motor_positions[2]]\\n\\n # Trovo il mediano tra 0-1-2\\n '''\\n if any([all([motor_positions[0] > motor_positions[1], motor_positions[0] < motor_positions[2]]),\\n all([motor_positions[0] < motor_positions[1], motor_positions[0] > motor_positions[2]])]):\\n is_0_median = True\\n is_1_median = False\\n is_2_median = False\\n else:\\n is_0_median = False\\n if any([all([motor_positions[1] > motor_positions[2], motor_positions[1] < motor_positions[0]]),\\n all([motor_positions[1] < motor_positions[2], motor_positions[1] > motor_positions[0]])]):\\n is_0_median = False\\n is_1_median = True\\n is_2_median = False\\n else:\\n is_1_median = False\\n if any([all([motor_positions[2] > motor_positions[1], motor_positions[2] < motor_positions[0]]),\\n all([motor_positions[2] < motor_positions[1], motor_positions[2] > motor_positions[0]])]):\\n is_0_median = False\\n is_1_median = False\\n is_2_median = True\\n else:\\n is_2_median = False\\n '''\\n\\n # Incrementi degli angoli\\n # TO_CHECK: perche' quattro? L'ultimo e' di backup?\\n step_alpha_base = 0.1 * Kinematic.M_TO_RAD\\n step_alpha = [step_alpha_base, step_alpha_base, step_alpha_base]\\n\\n # Numero di cicli eseguiti\\n self.cycles = 0\\n\\n # Calcolo la condizione iniziale\\n d1 = self.distance_12(alpha, height)\\n err[0] = d1 - self.base_length\\n step_alpha[1] = err[0] * self.ke * step_alpha_base\\n\\n d2 = self.distance_23(alpha, height)\\n err[1] = d2 - self.base_length\\n step_alpha[2] = err[1] * self.ke * step_alpha_base\\n\\n d3 = self.distance_13(alpha, height)\\n err[2] = d3 - self.base_length\\n step_alpha[0] = err[2] * self.ke * step_alpha_base\\n\\n i = 0\\n while i < self.cycle_limit:\\n\\n i += 1\\n\\n # Incremento alfa1 ed azzero alfa2\\n alpha[0] += step_alpha[0]\\n alpha[1] = self.alpha_start[1]\\n\\n j = 0\\n\\n while j < self.cycle_limit:\\n\\n j += 1\\n\\n # self.next_iteration(alpha, step_alpha, i, j, n, err)\\n self.cycles += 1\\n\\n if self.cycles > self.cycle_limit:\\n logging.error(\\\"Maximum number of cycles executed, no solution found!\\\")\\n return False\\n\\n # Incremento alfa1 ed azzero alfa2\\n alpha[1] += step_alpha[1]\\n\\n # Se supero l'angolo limite\\n # Partendo da -10 ( -0.17 ), non devo superare 10 ( 0.17 )\\n if alpha[1] > -self.alpha_limit_r:\\n\\n # Angolo non trovato\\n step_alpha[1] = step_alpha_base\\n step_alpha[0] = err[0] * step_alpha_base * self.ke\\n self.alpha_start[1] = -self.alpha_limit_r - 2 * step_alpha[1]\\n break\\n\\n d1 = self.distance_12(alpha, height)\\n err[0] = d1 - self.base_length\\n step_alpha[1] = err[0] * self.ke * step_alpha_base\\n\\n if abs(err[0]) < self.err_limit:\\n\\n # Trovato il minimo\\n self.alpha_start[1] = alpha[1]\\n step_alpha[1] = step_alpha_base\\n\\n n = 0\\n while n < self.cycle_limit:\\n\\n n += 1\\n\\n # self.next_iteration(alpha, step_alpha, i, j, n, err)\\n self.cycles += 1\\n\\n if self.cycles > self.cycle_limit:\\n logging.error(\\\"Maximum number of cycles executed, no solution found!\\\")\\n return False\\n\\n alpha[2] += step_alpha[2]\\n d2 = self.distance_23(alpha, height)\\n err[1] = d2 - self.base_length\\n step_alpha[2] = err[1] * self.ke * step_alpha_base\\n\\n if abs(err[1]) < self.err_limit:\\n\\n step_alpha[2] = step_alpha_base\\n d3 = self.distance_13(alpha, height)\\n err[2] = d3 - self.base_length\\n step_alpha[0] = err[2] * self.ke * step_alpha_base\\n\\n if abs(err[2]) < self.err_limit:\\n\\n # Trovatas la soluzione\\n self.alpha = list(alpha)\\n return True\\n\\n # NEXT j!!!\\n break\\n\\n # Next i!!!\\n break\",\n \"def check_extension(sim_par, base_mof, mobile_mof, emap, emap_atom_list, new_structure):\\n emap_max = [emap[-1][0], emap[-1][1], emap[-1][2]]\\n emap_min = [emap[0][0], emap[0][1], emap[0][2]]\\n\\n energy_limit = sim_par['atom_energy_limit']\\n ext_cut_off = sim_par['ext_cut_off']\\n\\n rotation_info = new_structure['rotation']\\n first_point = new_structure['first_point']\\n translation_vector = Coor(new_structure['translation_vector'])\\n\\n Quat = Quaternion([0, 1, 1, 1])\\n\\n packing_factor = Packing.factor(mobile_mof.uc_size, ext_cut_off)\\n uc_vectors = Packing.uc_vectors(mobile_mof.uc_size, mobile_mof.uc_angle)\\n trans_vec = Packing.translation_vectors(packing_factor, uc_vectors)\\n packed_coors = Packing.uc_coors(trans_vec, packing_factor, uc_vectors, mobile_mof.atom_coors)\\n\\n x_angle = rotation_info[0]\\n y_angle = rotation_info[1]\\n z_angle = rotation_info[2]\\n\\n collision = False\\n for unit_cell in packed_coors:\\n\\n if not collision:\\n\\n for coor_index, coor in enumerate(unit_cell):\\n\\n if not collision:\\n\\n new_coor = Coor(coor)\\n Q = Quaternion([1, new_coor.x, new_coor.y, new_coor.z]) # Might be a better way to do this\\n Q = Quat.rotation(Q.xyz(), [0, 0, 0], [1, 0, 0], x_angle)\\n Q = Quat.rotation(Q.xyz(), [0, 0, 0], [0, 1, 0], y_angle)\\n Q = Quat.rotation(Q.xyz(), [0, 0, 0], [0, 0, 1], z_angle)\\n new_coor = Coor(Q.xyz())\\n\\n new_coor += translation_vector\\n pbc_coor = new_coor.pbc(base_mof.uc_size, base_mof.uc_angle, base_mof.frac_ucv)\\n\\n atom_name = mobile_mof.atom_names[coor_index]\\n atom_index = energy_map_atom_index(atom_name, emap_atom_list)\\n\\n point_energy = trilinear_interpolate(pbc_coor.xyz(), atom_index, emap, emap_max, emap_min)\\n\\n if point_energy < energy_limit:\\n continue\\n else:\\n collision = True\\n break\\n else:\\n break\\n else:\\n break\\n\\n return collision\",\n \"def alchemical_forces(self):\\n return self._cpp_obj._forces * self._cpp_obj.norm_value\",\n \"def test_integrate_wontfix(self):\\n ans_flam = 8.8608168e-09 * (u.erg / (u.cm * u.cm * u.s))\\n assert_quantity_allclose(\\n self.sp.integrate(wavelengths=self.w, flux_unit='flam',\\n integration_type='analytical'), ans_flam)\",\n \"def test_non_integral_validation(self):\",\n \"def test_non_integral_validation(self):\",\n \"def is_valid(self):\\n posit1 = (self.mean_v > 0) & (self.kappa_y > 0) & (self.eta_y > 0)\\n posit2 = (self.kappa_s > 0) & (self.eta_s > 0)\\n return posit1 & posit2 & self.feller()\",\n \"def _validate_axes(self):\\n if not (\\n np.abs(self.axis_u.dot(self.axis_v) < 1e-6)\\n and np.abs(self.axis_v.dot(self.axis_w) < 1e-6)\\n and np.abs(self.axis_w.dot(self.axis_u) < 1e-6)\\n ):\\n raise ValueError(\\\"axis_u, axis_v, and axis_w must be orthogonal\\\")\\n return True\",\n \"def modify_openmm_forces(self, *args, **kwargs):\\n raise NotImplementedError()\",\n \"def test_norm_angle():\\n random_state = np.random.RandomState(0)\\n a_norm = random_state.uniform(-np.pi, np.pi, size=(100,))\\n for b in np.linspace(-10.0 * np.pi, 10.0 * np.pi, 11):\\n a = a_norm + b\\n assert_array_almost_equal(pr.norm_angle(a), a_norm)\\n\\n assert_almost_equal(pr.norm_angle(-np.pi), np.pi)\\n assert_almost_equal(pr.norm_angle(np.pi), np.pi)\",\n \"def validate_magvar(mv):\\n result = VALID\\n mag_var = None\\n try:\\n mag_var = float(mv)\\n if (mag_var > 360) or (mag_var < -360):\\n result = NOT_VALID\\n except ValueError:\\n try:\\n prefix = mv[0]\\n if REGEX_MAGVAR_DD.match(mv[1:]): # Check if there are only numbers > 0, eg. 1.5, not -1.5\\n mag_var = float(mv[1:])\\n if prefix == 'W':\\n result = -mag_var\\n elif prefix == 'E':\\n result = mag_var\\n else:\\n result = NOT_VALID\\n else:\\n result = NOT_VALID\\n\\n if (mag_var != None) and ((mag_var > 360) or (mag_var < -360)):\\n result = NOT_VALID \\n \\n except ValueError:\\n result = NOT_VALID\\n mag_var = None\\n\\n return result, mag_var\",\n \"def comp_axes(self, machine, N0=None):\\n if self.time is None and N0 is None:\\n raise InputError(\\\"ERROR: time and N0 can't be both None\\\")\\n\\n # Get machine pole pair number\\n p = machine.get_pole_pair_number()\\n\\n # Get electrical fundamental frequency\\n f_elec = self.comp_felec()\\n\\n # Airgap radius\\n Rag = machine.comp_Rgap_mec()\\n\\n # Setup normalizations for time and angle axes\\n norm_time = {\\n \\\"elec_order\\\": f_elec,\\n \\\"mech_order\\\": f_elec / p,\\n }\\n if N0 is not None:\\n norm_time[\\\"angle_rotor\\\"] = 1 / (360 * N0 / 60)\\n\\n norm_angle = {\\\"space_order\\\": p, \\\"distance\\\": 1 / Rag}\\n\\n # Create time axis\\n if self.time is None:\\n # Create time axis as a DataLinspace\\n Time = DataLinspace(\\n name=\\\"time\\\",\\n unit=\\\"s\\\",\\n initial=0,\\n final=60 / N0 * self.Nrev,\\n number=self.Nt_tot,\\n include_endpoint=False,\\n normalizations=norm_time,\\n )\\n else:\\n # Load time data\\n time = self.time.get_data()\\n self.Nt_tot = len(time)\\n Time = Data1D(name=\\\"time\\\", unit=\\\"s\\\", values=time, normalizations=norm_time)\\n\\n # Create angle axis\\n if self.angle is None:\\n # Create angle axis as a DataLinspace\\n Angle = DataLinspace(\\n name=\\\"angle\\\",\\n unit=\\\"rad\\\",\\n initial=0,\\n final=2 * pi,\\n number=self.Na_tot,\\n include_endpoint=False,\\n normalizations=norm_angle,\\n )\\n else:\\n # Load angle data\\n angle = self.angle.get_data()\\n self.Na_tot = len(angle)\\n Angle = Data1D(\\n name=\\\"angle\\\", unit=\\\"rad\\\", values=angle, normalizations=norm_angle\\n )\\n\\n return Time, Angle\",\n \"def test_run_mantel_correlogram_invaid_input(self):\\r\\n self.assertRaises(ValueError, run_mantel_correlogram, [self.fp1],\\r\\n [self.dm1, self.dm3], self.num_perms, None, self.alpha)\",\n \"def update_forces(self):\\n\\n pass\",\n \"def test_magmom(convcell_cr: PhonopyAtoms):\\n symprec = 1e-5\\n symmetry_nonspin = Symmetry(convcell_cr, symprec=symprec)\\n atom_map_nonspin = symmetry_nonspin.get_map_atoms()\\n len_sym_nonspin = len(symmetry_nonspin.symmetry_operations[\\\"rotations\\\"])\\n\\n spin = [1, -1]\\n cell_withspin = convcell_cr.copy()\\n cell_withspin.magnetic_moments = spin\\n symmetry_withspin = Symmetry(cell_withspin, symprec=symprec)\\n atom_map_withspin = symmetry_withspin.get_map_atoms()\\n len_sym_withspin = len(symmetry_withspin.symmetry_operations[\\\"rotations\\\"])\\n\\n broken_spin = [1, -2]\\n cell_brokenspin = convcell_cr.copy()\\n cell_brokenspin = convcell_cr.copy()\\n cell_brokenspin.magnetic_moments = broken_spin\\n symmetry_brokenspin = Symmetry(cell_brokenspin, symprec=symprec)\\n atom_map_brokenspin = symmetry_brokenspin.get_map_atoms()\\n len_sym_brokenspin = len(symmetry_brokenspin.symmetry_operations[\\\"rotations\\\"])\\n\\n assert (atom_map_nonspin == atom_map_withspin).all()\\n assert (atom_map_nonspin != atom_map_brokenspin).any()\\n assert len_sym_nonspin == len_sym_withspin\\n assert len_sym_nonspin != len_sym_brokenspin\",\n \"def test_run_mantel_test_invaid_input(self):\\r\\n self.assertRaises(ValueError, run_mantel_test, 'mantel',\\r\\n [self.fp1,\\r\\n self.fp2], [\\r\\n self.dm1], self.num_perms, 'two sided',\\r\\n None, self.alpha)\",\n \"def test_abs_magnitude_graph_missing_velocity_returns_exception():\\n from space_rocks.views.plot_magnitude import graph_abs_magnitude\\n\\n test_mag = [1, 2, 3, 4, 5]\\n test_neo_names = [\\\"ceres\\\", \\\"phobos\\\", \\\"deimos\\\", \\\"asteroid x\\\", \\\"it was earth all along!!\\\"]\\n\\n with pytest.raises(UnknownAxisException):\\n graph_abs_magnitude(test_mag, [], test_neo_names)\",\n \"def test_charge_increment_model_net_charge(self):\\n file_path = get_data_file_path(\\\"test_forcefields/test_forcefield.offxml\\\")\\n ff = ForceField(file_path, xml_charge_increment_model_ff_net_charge)\\n del ff._parameter_handlers[\\\"ToolkitAM1BCC\\\"]\\n\\n acetate = create_acetate()\\n top = acetate.to_topology()\\n\\n sys = ff.create_openmm_system(top)\\n nonbonded_force = [\\n force\\n for force in sys.getForces()\\n if isinstance(force, openmm.NonbondedForce)\\n ][0]\\n expected_charges = [\\n 0,\\n 0.15,\\n -0.2,\\n -0.95,\\n 0,\\n 0,\\n 0,\\n ] * openmm_unit.elementary_charge\\n for idx, expected_charge in enumerate(expected_charges):\\n charge, _, _ = nonbonded_force.getParticleParameters(idx)\\n assert (\\n abs(charge - expected_charge) < 1.0e-6 * openmm_unit.elementary_charge\\n )\",\n \"def bode(system, mn=0.001, mx=1000, npts=100, title=\\\"\\\", xlim=False, ylim=False, sv=False,\\n disp3db=False, lowcut=None, magnitude=True, angle=True, freqaxis=\\\"rad\\\"):\\n # Condition system input to ensure proper execution\\n system = _sys_condition(system, False)\\n\\n # Condition min and max freq terms\\n degrees = False\\n if freqaxis.lower().find(\\\"deg\\\") != -1: # degrees requested\\n degrees = True\\n # Scale Degrees to Radians for calculation\\n mn = 2 * _np.pi * mn\\n mx = 2 * _np.pi * mx\\n mn = _np.log10(mn) # find the _exponent value\\n mx = _np.log10(mx) # find the _exponent value\\n\\n # Generate the frequency range to calculate over\\n wover = _np.logspace(mn, mx, npts)\\n\\n # Calculate the bode system\\n w, mag, ang = _sig.bode(system, wover)\\n\\n def _plot(plot_title, y_label):\\n _plt.title(plot_title)\\n _plt.ylabel(y_label)\\n if degrees: # Plot in degrees\\n _plt.plot(w / (2 * _np.pi), ang)\\n _plt.xlabel(\\\"Frequency (Hz)\\\")\\n else: # Plot in radians\\n _plt.plot(w, ang)\\n _plt.xlabel(\\\"Frequency (rad/sec)\\\")\\n _plt.xscale(\\\"log\\\")\\n _plt.grid(which=\\\"both\\\")\\n if xlim:\\n _plt.xlim(xlim)\\n if ylim:\\n _plt.ylim(ylim)\\n if sv:\\n _plt.savefig(title + \\\".png\\\")\\n\\n # Plot Magnitude\\n if magnitude:\\n magTitle = \\\"Magnitude \\\" + title\\n _plot(magTitle, \\\"Magnitude (DB)\\\")\\n if disp3db:\\n _plt.axhline(-3)\\n if lowcut is not None:\\n _plt.axhline(lowcut)\\n _plt.show()\\n\\n # Plot Angle\\n if angle:\\n angTitle = \\\"Angle \\\" + title\\n _plot(angTitle, \\\"Angle (degrees)\\\")\\n _plt.show()\",\n \"def test_calculate_angle():\\n r1 = np.array([0, 0, -1])\\n r2 = np.array([0, 0, 0])\\n r3 = np.array([1, 0, 0])\\n\\n expected_angle = 90\\n calculated_angle = molecool.calculate_angle(r1, r2, r3, degrees = True)\\n\\n assert expected_angle == calculated_angle\",\n \"def check_openmm_requirements(cls, combine_nonbonded_forces: bool) -> None:\",\n \"def intf_ANGLE(E):\\n if ( not E.The.StackSize() >= 3\\n or not inc.point_formatted_LST(E.The,1)\\n or not inc.point_formatted_LST(E.The,2)\\n or not inc.point_formatted_LST(E.The,3) ):\\n print(\\\"Input Error: angle\\\")\\n print(intf_ANGLE.__doc__)\\n return # Without doing much of anything.\\n import math\\n Cobject= E.The.StackPop()\\n #C= map(lambda x:x.val, Cobject.val) # Should now be a list of floats.\\n C= [x.val for x in Cobject.val] # Should now be a list of floats.\\n Bobject= E.The.StackPop()\\n #B= map(lambda x:x.val, Bobject.val) # Should now be a list of floats.\\n B= [x.val for x in Bobject.val] # Should now be a list of floats.\\n Aobject= E.The.StackPop()\\n #A= map(lambda x:x.val, Aobject.val) # Should now be a list of floats.\\n A= [x.val for x in Aobject.val] # Should now be a list of floats.\\n v1= [ A[0]-B[0], A[1]-B[1], A[2]-B[2] ]\\n v2= [ C[0]-B[0], C[1]-B[1], C[2]-B[2] ]\\n v1mag= math.sqrt( v1[0]*v1[0] + v1[1]*v1[1] + v1[2]*v1[2] )\\n v2mag= math.sqrt( v2[0]*v2[0] + v2[1]*v2[1] + v2[2]*v2[2] )\\n try:\\n v1norm= [x/v1mag for x in v1]\\n v2norm= [x/v2mag for x in v2]\\n dotprod= v1norm[0]*v2norm[0] + v1norm[1]*v2norm[1] + v1norm[2]*v2norm[2]\\n a= math.acos(dotprod) * 180 / math.pi\\n except ZeroDivisionError:\\n print(\\\"The supplied points are not distinct or have some other math problem.\\\")\\n return\\n d= objectifier.StackOB_VAL(a) # Can't be just regular Python ints.\\n E.The.StackPush(d)\",\n \"def validate(self, mesh, mod):\\n return True\",\n \"def _assert_validity_of_inputs(self):\\n for item in [\\\"frequency\\\", \\\"Dt\\\", \\\"gain\\\", \\\"gain_imu\\\", \\\"gain_marg\\\"]:\\n if isinstance(self.__getattribute__(item), bool):\\n raise TypeError(f\\\"Parameter '{item}' must be numeric.\\\")\\n if not isinstance(self.__getattribute__(item), (int, float)):\\n raise TypeError(f\\\"Parameter '{item}' is not a non-zero number.\\\")\\n if self.__getattribute__(item) <= 0.0:\\n raise ValueError(f\\\"Parameter '{item}' must be a non-zero number.\\\")\\n if self.q0 is not None:\\n if not isinstance(self.q0, (list, tuple, np.ndarray)):\\n raise TypeError(f\\\"Parameter 'q0' must be an array. Got {type(self.q0)}.\\\")\\n self.q0 = np.copy(self.q0)\\n if self.q0.shape != (4,):\\n raise ValueError(f\\\"Parameter 'q0' must be an array of shape (4,). It is {self.q0.shape}.\\\")\\n if not np.allclose(np.linalg.norm(self.q0), 1.0):\\n raise ValueError(f\\\"Parameter 'q0' must be a versor (norm equal to 1.0). Its norm is equal to {np.linalg.norm(self.q0)}.\\\")\",\n \"def validPeriod(period):\\r\\n try:\\r\\n i = float(period)\\r\\n except ValueError:\\r\\n return False\\r\\n else:\\r\\n if i>0:\\r\\n return True\\r\\n else:\\r\\n return False\",\n \"def omega(x):\\n # if ramp_start_time - ramp_constant_time <= x <= end_ramp_end_time + ramp_constant_time:\\n # f_t0 = smooth_factor * (x - ramp_start_time)\\n # f_t1 = smooth_factor * (x - i_ramp_end_time)\\n # if ramp_mode == 'with_end_acc':\\n # f_t2 = smooth_factor * (x - steady_end_time)\\n # f_t3 = smooth_factor * (x - end_ramp_end_time)\\n # elif ramp_mode == 'no_end_acc':\\n # f_t2 = smooth_factor * ramp_start_time\\n # f_t3 = smooth_factor * i_ramp_end_time\\n\\n # omegax = (ramp_stage_acceleration / 2) / smooth_factor * (\\n # logcosh(f_t0) - logcosh(f_t1) + logcosh(f_t3) - logcosh(f_t2))\\n # else:\\n # if bstroke == 'yes' and x <= 2 * (end_ramp_end_time +\\n # ramp_constant_time):\\n # x -= end_ramp_end_time + ramp_constant_time\\n # f_t0 = smooth_factor * (x - ramp_start_time)\\n # f_t1 = smooth_factor * (x - i_ramp_end_time)\\n # if ramp_mode == 'with_end_acc':\\n # f_t2 = smooth_factor * (x - steady_end_time)\\n # f_t3 = smooth_factor * (x - end_ramp_end_time)\\n # elif ramp_mode == 'no_end_acc':\\n # f_t2 = smooth_factor * ramp_start_time\\n # f_t3 = smooth_factor * i_ramp_end_time\\n\\n # omegax = -(ramp_stage_acceleration / 2) / smooth_factor * (\\n # logcosh(f_t0) - logcosh(f_t1) + logcosh(f_t3) -\\n # logcosh(f_t2))\\n # else:\\n # omegax = 0\\n\\n if bstroke == 'no':\\n f_t0 = smooth_factor * (x - ramp_start_time)\\n f_t1 = smooth_factor * (x - i_ramp_end_time)\\n if ramp_mode == 'with_end_acc':\\n f_t2 = smooth_factor * (x - steady_end_time)\\n f_t3 = smooth_factor * (x - end_ramp_end_time)\\n elif ramp_mode == 'no_end_acc':\\n f_t2 = smooth_factor * ramp_start_time\\n f_t3 = smooth_factor * i_ramp_end_time\\n\\n omegax = (ramp_stage_acceleration / 2) / smooth_factor * (\\n logcosh(f_t0) - logcosh(f_t1) + logcosh(f_t3) - logcosh(f_t2))\\n\\n else:\\n if x <= end_ramp_end_time + ramp_constant_time:\\n f_t0 = smooth_factor * (x - ramp_start_time)\\n f_t1 = smooth_factor * (x - i_ramp_end_time)\\n if ramp_mode == 'with_end_acc':\\n f_t2 = smooth_factor * (x - steady_end_time)\\n f_t3 = smooth_factor * (x - end_ramp_end_time)\\n elif ramp_mode == 'no_end_acc':\\n f_t2 = smooth_factor * ramp_start_time\\n f_t3 = smooth_factor * i_ramp_end_time\\n\\n omegax = (ramp_stage_acceleration /\\n 2) / smooth_factor * (logcosh(f_t0) - logcosh(f_t1) +\\n logcosh(f_t3) - logcosh(f_t2))\\n\\n else:\\n x -= end_ramp_end_time + ramp_constant_time\\n f_t0 = smooth_factor * (x - ramp_start_time)\\n f_t1 = smooth_factor * (x - i_ramp_end_time)\\n if ramp_mode == 'with_end_acc':\\n f_t2 = smooth_factor * (x - steady_end_time)\\n f_t3 = smooth_factor * (x - end_ramp_end_time)\\n elif ramp_mode == 'no_end_acc':\\n f_t2 = smooth_factor * ramp_start_time\\n f_t3 = smooth_factor * i_ramp_end_time\\n\\n omegax = -(ramp_stage_acceleration / 2) / smooth_factor * (\\n logcosh(f_t0) - logcosh(f_t1) + logcosh(f_t3) -\\n logcosh(f_t2))\\n\\n return omegax\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.67807055","0.6025987","0.6009556","0.582327","0.57532835","0.5632618","0.5626842","0.5582642","0.55583394","0.55183727","0.5498292","0.5465175","0.54535043","0.54445416","0.54298043","0.54143214","0.5408169","0.53782576","0.53738904","0.53651005","0.5352132","0.5328103","0.5313558","0.52778214","0.52735066","0.52671456","0.52527094","0.52340204","0.52093196","0.52071655","0.5205858","0.520178","0.51995856","0.51960087","0.5190454","0.51798636","0.5173357","0.51687646","0.5165573","0.5148369","0.5139026","0.5132073","0.5120535","0.5116911","0.51165736","0.5105758","0.5099168","0.5081673","0.5075999","0.50674546","0.50647837","0.5052807","0.5044084","0.5030709","0.5021069","0.5017976","0.5017182","0.5013711","0.5012135","0.50092006","0.50045526","0.5000502","0.49970293","0.4996786","0.49933913","0.4993391","0.49897748","0.49889833","0.498559","0.4975346","0.497462","0.49723363","0.49690259","0.49627334","0.4962345","0.49613732","0.49544576","0.4947793","0.49424753","0.49424753","0.4939122","0.49384537","0.49330077","0.4920236","0.49188417","0.49187037","0.4916178","0.49041626","0.48959848","0.48916078","0.48914948","0.48871627","0.4887051","0.4886892","0.48848847","0.48843902","0.4882297","0.4882284","0.48809865","0.48798192"],"string":"[\n \"0.67807055\",\n \"0.6025987\",\n \"0.6009556\",\n \"0.582327\",\n \"0.57532835\",\n \"0.5632618\",\n \"0.5626842\",\n \"0.5582642\",\n \"0.55583394\",\n \"0.55183727\",\n \"0.5498292\",\n \"0.5465175\",\n \"0.54535043\",\n \"0.54445416\",\n \"0.54298043\",\n \"0.54143214\",\n \"0.5408169\",\n \"0.53782576\",\n \"0.53738904\",\n \"0.53651005\",\n \"0.5352132\",\n \"0.5328103\",\n \"0.5313558\",\n \"0.52778214\",\n \"0.52735066\",\n \"0.52671456\",\n \"0.52527094\",\n \"0.52340204\",\n \"0.52093196\",\n \"0.52071655\",\n \"0.5205858\",\n \"0.520178\",\n \"0.51995856\",\n \"0.51960087\",\n \"0.5190454\",\n \"0.51798636\",\n \"0.5173357\",\n \"0.51687646\",\n \"0.5165573\",\n \"0.5148369\",\n \"0.5139026\",\n \"0.5132073\",\n \"0.5120535\",\n \"0.5116911\",\n \"0.51165736\",\n \"0.5105758\",\n \"0.5099168\",\n \"0.5081673\",\n \"0.5075999\",\n \"0.50674546\",\n \"0.50647837\",\n \"0.5052807\",\n \"0.5044084\",\n \"0.5030709\",\n \"0.5021069\",\n \"0.5017976\",\n \"0.5017182\",\n \"0.5013711\",\n \"0.5012135\",\n \"0.50092006\",\n \"0.50045526\",\n \"0.5000502\",\n \"0.49970293\",\n \"0.4996786\",\n \"0.49933913\",\n \"0.4993391\",\n \"0.49897748\",\n \"0.49889833\",\n \"0.498559\",\n \"0.4975346\",\n \"0.497462\",\n \"0.49723363\",\n \"0.49690259\",\n \"0.49627334\",\n \"0.4962345\",\n \"0.49613732\",\n \"0.49544576\",\n \"0.4947793\",\n \"0.49424753\",\n \"0.49424753\",\n \"0.4939122\",\n \"0.49384537\",\n \"0.49330077\",\n \"0.4920236\",\n \"0.49188417\",\n \"0.49187037\",\n \"0.4916178\",\n \"0.49041626\",\n \"0.48959848\",\n \"0.48916078\",\n \"0.48914948\",\n \"0.48871627\",\n \"0.4887051\",\n \"0.4886892\",\n \"0.48848847\",\n \"0.48843902\",\n \"0.4882297\",\n \"0.4882284\",\n \"0.48809865\",\n \"0.48798192\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.54969805"},"document_rank":{"kind":"string","value":"11"}}}],"truncated":false,"partial":true},"paginationData":{"pageIndex":249,"numItemsPerPage":100,"numTotalItems":95772,"offset":24900,"length":100}},"jwt":"eyJhbGciOiJFZERTQSIsImtpZCI6IjVHZDBvd0g5MTM2eDZjc1FvbE1zcktNWUZoRVFoUm5PVVVybEpjOUhaUEEifQ.eyJyZWFkIjp0cnVlLCJwZXJtaXNzaW9ucyI6eyJyZXBvLmNvbnRlbnQucmVhZCI6dHJ1ZX0sInJlcG9JZHMiOlsiNjc1Mzc2ODJkMmE2Mjg0NzVhMWJmZmNkIl0sImlhdCI6MTc5MTA5NDI0MiwianRpIjoiYTRhNTJlZmEtNzg3NS00NWI5LWI1YzAtODI2YzExOWU5MmE4Iiwic3ViIjoiL2RhdGFzZXRzL25vbWljLWFpL2Nvcm5zdGFjay1weXRob24tdjEiLCJleHAiOjE3OTEwOTc4NDIsImlzcyI6Imh0dHBzOi8vaHVnZ2luZ2ZhY2UuY28ifQ.KFPusO2NLkDqyWpD1PbIay1EQpdzGd0FWDEDhYFHuUmWY-2Q_ffymzhelkDVV2qIg0MexNU-yAqCiAGPlJfRDw","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 |
|---|---|---|---|---|---|---|
Token mappings for NER model | def load_mappings(filepath):
return pickle.load(open(filepath, "rb")) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def tokens():\n pass",
"def map_Token_to_dict(t):\n token_info = {}\n token_info[\"word\"] = t.word\n token_info[\"lemma\"] = t.lemma\n token_info[\"msd\"] = t.msd\n token_info[\"pos\"] = t.pos\n token_info[\"saldo\"] = t.saldo\n token_info[\"ref\"] = t.ref\n token_info[\"deprel\"] = t... | [
"0.63447225",
"0.6226196",
"0.61659867",
"0.5927074",
"0.589132",
"0.58562636",
"0.58474576",
"0.5840225",
"0.58150643",
"0.5798591",
"0.5797799",
"0.57669115",
"0.5751382",
"0.5750236",
"0.57295144",
"0.57158226",
"0.5683966",
"0.5664627",
"0.5656512",
"0.564592",
"0.5643204... | 0.0 | -1 |
For use in custom count vectorizer | def get_tokens(input_cell):
return ast.literal_eval(input_cell) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def count_vectorizer(self, df:pd.DataFrame, column_name:str, y:list=None):\n self._vectorizer = CountVectorizer()\n # print(vectorizer.get_feature_names())\n ans = self._vectorizer.fit_transform(raw_documents=df[column_name], y=y)\n return ans",
"def count_vector(df:pd.DataFrame, colu... | [
"0.6809927",
"0.67695844",
"0.65299875",
"0.6391221",
"0.6323332",
"0.62907547",
"0.62714547",
"0.61953974",
"0.6180927",
"0.6131787",
"0.6047954",
"0.60330844",
"0.603307",
"0.5988649",
"0.59795606",
"0.5941198",
"0.59382194",
"0.5921308",
"0.58819425",
"0.58742064",
"0.5858... | 0.0 | -1 |
Assuming the model is y = a x + b | def linearRegression(self, xtr, ytr, xte, yte):
LEARNING_RATE = 0.5
with self.graph.as_default() as graph:
with tf.name_scope('training'):
with tf.name_scope('loss'):
train_loss = tf.reduce_mean(
tf.square(self.y_train - self.y_plac... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def model(theta, x):\n\tw, b = theta\n\treturn w * x + b",
"def linear_model(inp, w1, b1):\n y = inp @ w1 + b1\n centered_y = y - y.mean()\n return centered_y.sum()",
"def train(self, X, y):",
"def predict(self, X, a, b):\n pass",
"def _model(x, p):\n y_hat = 0\n for... | [
"0.7249487",
"0.71250397",
"0.6496419",
"0.6465882",
"0.63790184",
"0.63515145",
"0.62340564",
"0.62106526",
"0.6194019",
"0.617126",
"0.616771",
"0.6105718",
"0.6064502",
"0.6057555",
"0.6056323",
"0.6056323",
"0.6056323",
"0.60315615",
"0.6020455",
"0.60099643",
"0.60048103... | 0.0 | -1 |
Need to simplfy this function | def create_squad(self, direction):
if direction == 0:
for n in range(5):
ship = Plane(self.allSprites, self.enemy_bullets, direction)
ship_width = ship.rect.width
ship.x = ship_width
ship.rect.x = ship.x
ship.rect.y = sh... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def regular(self):",
"def apply(self) -> None:",
"def apply(self) -> None:",
"def exo2():",
"def apply(self):",
"def substantiate():",
"def support(self):",
"def degibber(self):",
"def common(self):",
"def preprocess(self):",
"def transform(self):",
"def result(self):",
"def result(self):",... | [
"0.6376737",
"0.6244976",
"0.6244976",
"0.6197035",
"0.61636925",
"0.6142249",
"0.6093243",
"0.59947705",
"0.5912478",
"0.58679175",
"0.5863944",
"0.5855838",
"0.5855838",
"0.58418566",
"0.58280736",
"0.58211434",
"0.57913846",
"0.5772694",
"0.5734324",
"0.5734324",
"0.573432... | 0.0 | -1 |
Performs a search over container using __eq__ comparison and not hash | def tunnel_in_container(container, tunnel):
for element in container:
if tunnel == element:
return True
return False | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __contains__(self, item):",
"def search(self, *args, **kwargs):\n # comparison = f\"__{kwargs.get('comparison')}__\" if kwargs.get('comparison') else '__eq__'\n comparison = '__{comparison}__'.format(comparison=kwargs.get('comparison')) if kwargs.get('comparison') else '__eq__'\n try:\n ... | [
"0.6521921",
"0.6412573",
"0.6221914",
"0.61815023",
"0.61169034",
"0.60485363",
"0.5968565",
"0.5967089",
"0.5930296",
"0.5905189",
"0.58816653",
"0.58630764",
"0.58409524",
"0.5830806",
"0.5827367",
"0.58256793",
"0.5808385",
"0.5803326",
"0.580157",
"0.5775276",
"0.5761809... | 0.0 | -1 |
Smart heuristics to join node into caves. In this implementation, if one endpoint of a tunnel lies within the radius of another, join them together. | def simplify(self):
added_clumps = []
staying_tunnels = []
removed_clumps = set()
for tunnel in self.tunnels:
tunnel_end_distance = self.get_distance(tunnel.start, tunnel.end)
if tunnel_end_distance - tunnel.start.distance_from_wall < 0 or \
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _compute_connection(current_waypoint, next_waypoint, threshold=35):\n n = next_waypoint.transform.rotation.yaw\n n = n % 360.0\n\n c = current_waypoint.transform.rotation.yaw\n c = c % 360.0\n\n diff_angle = (n - c) % 180.0\n if diff_angle < threshold or diff_angle > (180 - threshold):\n ... | [
"0.56855464",
"0.5546275",
"0.54715693",
"0.5383454",
"0.5380818",
"0.5340776",
"0.53051436",
"0.5162047",
"0.51586264",
"0.5147107",
"0.51121587",
"0.5093378",
"0.5077364",
"0.50570464",
"0.5055928",
"0.5012461",
"0.500983",
"0.49842656",
"0.497719",
"0.49690145",
"0.4961483... | 0.54145515 | 3 |
Converts clumps and tunnels to graph nodes and edges to be presented on the final map. | def extract_diagram(self):
nodes = []
edges = []
for clump in self.clumps:
new_nodes, new_edges = clump.get_diagram_representation()
nodes.extend(new_nodes)
edges.extend(new_edges)
#nodes.append(backend.JunctionNode(clump))
# TODO:... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def convert_connections(self, connections):\n model = self.model\n for conn in getattr(model, u'connection', []):\n comp1 = model.get_component_by_name(conn.map_components.component_1)\n comp2 = model.get_component_by_name(conn.map_components.component_2)\n for mappin... | [
"0.6328475",
"0.6253309",
"0.6002456",
"0.59599626",
"0.583428",
"0.5823277",
"0.57307833",
"0.5722579",
"0.57005084",
"0.56930006",
"0.56913257",
"0.56404",
"0.5634069",
"0.5631323",
"0.55093277",
"0.54946303",
"0.5490735",
"0.54480684",
"0.5414293",
"0.5393222",
"0.53843117... | 0.60783696 | 2 |
Finds connected points that are not part of tunnels and assigns a single node for all of them. | def mark_clump(self, point):
# TODO: flood fill it properly
if point.node:
return
neighbors = len(self.get_neighbors(point))
if neighbors == 1:
node = DeadEnd([point])
elif neighbors == 2:
raise Exception("WTF, 2 neighbors")
else:
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def set_connection_between_nodes(self):\n\n for i, node in enumerate(self.list_empty_nodes):\n line = node.labyrinth_position[0]\n column = node.labyrinth_position[1]\n\n for j in range(i+1, len(self.list_empty_nodes)):\n line_j = self.list_empty_nodes[j].laby... | [
"0.65846676",
"0.6225609",
"0.6146511",
"0.605316",
"0.6015919",
"0.5997633",
"0.5969244",
"0.59334683",
"0.59093934",
"0.5858953",
"0.5842103",
"0.58010113",
"0.57768786",
"0.5756226",
"0.5723973",
"0.5719049",
"0.57177925",
"0.57150555",
"0.56853795",
"0.5685296",
"0.566074... | 0.0 | -1 |
Depthfirst graph traversal, extracts clumps (nodes) and tunnels (edges). Graph must have at least one point that is a junction. | def find_structure(self):
cave_graphs = []
starting_point = None
# firse initalize points
for point in self.points.values():
neighbors = self.get_neighbors(point)
if len(neighbors) != 2 and point.node is None:
starting_point = point
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def construct_junction_graph(self) -> Graph[Cell]:\n if self.maze is None:\n raise ValueError('No current maze to construct a junction graph from!')\n\n junction_graph = Graph()\n visited = defaultdict(bool)\n\n def cell_visitor(cell: Cell) -> None:\n visited[cell]... | [
"0.62955743",
"0.6218852",
"0.60339916",
"0.5890118",
"0.5873582",
"0.5675615",
"0.5669391",
"0.5656545",
"0.56498134",
"0.5575273",
"0.55740166",
"0.55538756",
"0.5547625",
"0.5546689",
"0.55386174",
"0.5508685",
"0.5503386",
"0.5432993",
"0.5432737",
"0.54099274",
"0.539502... | 0.63038146 | 0 |
A reference source of entropy. | def entropy(n_bits):
return n_bits and random.getrandbits(n_bits) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def entropy(self):\n raise NotImplementedError",
"def entropy(self):\n return self._entropy_func",
"def _entropy(self):\n return self.rv.entropy(*self._pymc_dists_to_value(self.args), **self.kwds)",
"def entropy(self):\n return self._normal.entropy()",
"def S(self):\n ... | [
"0.7335538",
"0.7321996",
"0.6929512",
"0.6915944",
"0.6511103",
"0.6434832",
"0.6370721",
"0.6351",
"0.6345588",
"0.6240882",
"0.6234527",
"0.6183247",
"0.6183247",
"0.6111796",
"0.61077815",
"0.6087875",
"0.60816205",
"0.6070592",
"0.6016523",
"0.5976137",
"0.5970436",
"0... | 0.57390875 | 37 |
From 0 to n 1. | def roll(entropy, n):
# Minimum bit depth to cover the full range.
# Note that more bits would be more fair.
bit_depth = math.ceil(math.log2(n))
x = entropy(bit_depth)
# Scale from total range to desired range.
# Numbers with higher odds will be evenly distributed.
return math.floor(x * n... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def I (self, n):",
"def fakultet (n = 1):\n sum = 1\n for i in range(n, 1, -1):\n sum *= i\n return sum",
"def ones(n, offset=0):\n\n if (n == float('inf')):\n return -1\n\n return ((1 << n) - 1) << offset",
"def Arn(r, n):\n ret = 1\n for t in range(n, n-r+1-1, -1):\n ... | [
"0.69229555",
"0.66966933",
"0.6686047",
"0.6685972",
"0.66640633",
"0.6661085",
"0.66186",
"0.65888745",
"0.6527394",
"0.6467458",
"0.64236766",
"0.6413104",
"0.64037323",
"0.6394609",
"0.63714546",
"0.637133",
"0.6354937",
"0.6330853",
"0.63275546",
"0.6323024",
"0.63122994... | 0.0 | -1 |
From first to last. | def in_range(entropy, first, last):
return first + roll(entropy, last - first + 1) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def exchange_first_last(seq):\n return seq[-1:]+seq[1:-1]+seq[0:1]",
"def exchange_first_last(seq):\n first = seq[0:1]\n middle = seq[1:-1]\n last = seq[-1:]\n seq_copy = last + middle + first\n return seq_copy",
"def first_and_last(values):\n first = values[0]\n last = values[-1]\n ... | [
"0.684175",
"0.669462",
"0.667846",
"0.6484993",
"0.6262593",
"0.6100792",
"0.60273415",
"0.59952015",
"0.5988307",
"0.5964163",
"0.5768536",
"0.5752433",
"0.5742823",
"0.5672278",
"0.5632229",
"0.5624323",
"0.5592517",
"0.55782247",
"0.55598646",
"0.5542554",
"0.551485",
"... | 0.0 | -1 |
One of a set of options. | def one_of(entropy, options):
# Coerce to list; could be an iterator or set.
options = list(options)
return options[roll(entropy, len(options))] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def options(self, a: str) -> typing.Any:",
"def option(self, spec):\n return spec.options[self.rng.integers(len(spec.options))]",
"def visit_option(self, state, opt_name, opt_value):\n pass",
"def options_by_name(self):\n pass",
"def _additional_option(self):\n pass",
"def _is... | [
"0.7128821",
"0.6769607",
"0.6563619",
"0.65318555",
"0.64025533",
"0.6402144",
"0.63814133",
"0.6359936",
"0.6351186",
"0.632631",
"0.6319813",
"0.6228393",
"0.62080795",
"0.62018996",
"0.6144289",
"0.6132868",
"0.61311126",
"0.6106209",
"0.6093769",
"0.6092339",
"0.6045443"... | 0.0 | -1 |
From 0 to positive infinity. | def scale(entropy):
# FIXME: Improve generation performance
# for testing viability.
# `scale_` has the desired properties of
# periodically producing very large documents.
x = 0
while entropy(1):
x += 1
return x | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def inf(self):\n return self._inf",
"def isinf(x):\n return False",
"def fill_with_neg_inf(t):\r\n return t.float().fill_(float(\"-inf\")).type_as(t)",
"def isInfinity(self):\n return _libsbml.ASTNode_isInfinity(self)",
"def isInfinite(value):\n if value == float('inf') or value ... | [
"0.74205124",
"0.7011005",
"0.68522996",
"0.68498147",
"0.658942",
"0.65669304",
"0.65312845",
"0.65211093",
"0.6454594",
"0.64146763",
"0.6392522",
"0.6364933",
"0.6337372",
"0.6335443",
"0.6289076",
"0.62520576",
"0.6175854",
"0.61369663",
"0.611988",
"0.6090568",
"0.607692... | 0.0 | -1 |
From 0 to positive infinity. | def scale_(entropy):
# Double scale with each successive 1.
bit_depth = 0
while entropy(1):
bit_depth += 1
# Return a random number within the scale.
return 2 ** bit_depth + entropy(bit_depth) - 1 | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def inf(self):\n return self._inf",
"def isinf(x):\n return False",
"def fill_with_neg_inf(t):\r\n return t.float().fill_(float(\"-inf\")).type_as(t)",
"def isInfinity(self):\n return _libsbml.ASTNode_isInfinity(self)",
"def isInfinite(value):\n if value == float('inf') or value ... | [
"0.7419534",
"0.70103866",
"0.6852276",
"0.68489885",
"0.65879995",
"0.6568186",
"0.65308875",
"0.65205",
"0.64529145",
"0.64138526",
"0.63921684",
"0.63641196",
"0.63368535",
"0.6335251",
"0.6289104",
"0.6252908",
"0.61746687",
"0.6135361",
"0.61183196",
"0.60907626",
"0.607... | 0.0 | -1 |
not authorized access not allowed | def test_not_authenticated_uri(self):
request = self.factory.get(self.uri)
response = self.view(request)
response.render()
self.assertEqual(response.status_code, 401,
'Expected Response Code 401, received {0} instead.'
.format(response.status_code)) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_authenticated_denied(self):",
"def authorized(self):\n pass",
"def forbidden():\n return HttpError(403)",
"def test_user_not_authorized(self):\n response = self.client.post(self.url)\n self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN)",
"def __require_privila... | [
"0.75042206",
"0.7406361",
"0.7399189",
"0.739384",
"0.73844796",
"0.72006446",
"0.7158826",
"0.71275866",
"0.7116086",
"0.7061837",
"0.7053329",
"0.70110494",
"0.7009463",
"0.6971239",
"0.696135",
"0.69366765",
"0.69185925",
"0.68959856",
"0.68959856",
"0.68959856",
"0.68959... | 0.0 | -1 |
ensure that uri is authorized access only | def test_authenticated_uri(self):
request = self.factory.get(self.uri)
force_authenticate(request, self.user)
response = self.view(request)
response.render()
self.assertEqual(response.status_code, 200,
'Expected Response Code 200, received {0} instead.'
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_unauthenticated_resource_allowed(self):\n raise NotImplementedError # FIXME",
"def test_not_authenticated_uri(self):\n request = self.factory.get(self.uri)\n response = self.view(request)\n response.render()\n self.assertEqual(response.status_code, 401,\n '... | [
"0.65171504",
"0.6402486",
"0.63771325",
"0.6375413",
"0.63071775",
"0.63009334",
"0.6289721",
"0.62644935",
"0.6228444",
"0.62223566",
"0.61878365",
"0.61414355",
"0.6134728",
"0.6133376",
"0.6118283",
"0.61019117",
"0.6080933",
"0.6025073",
"0.59571517",
"0.5946507",
"0.593... | 0.6181522 | 11 |
testing upload a triple store file | def test_post(self):
pass | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_upload_file(self):\n pass",
"def test_upload(self):\n with self.client:\n file = dict(\n file=(BytesIO(b'my file contents'), \"foto.jpg\"),\n )\n response = self.client.post('/upload',\n content_type='mu... | [
"0.75622064",
"0.74450475",
"0.7414942",
"0.72579104",
"0.714064",
"0.71367294",
"0.7100109",
"0.709622",
"0.6873781",
"0.6828715",
"0.6760692",
"0.6704941",
"0.6680957",
"0.66789514",
"0.66406935",
"0.65745944",
"0.6552711",
"0.65437436",
"0.6475079",
"0.64600915",
"0.645860... | 0.0 | -1 |
This test changes the netbios name of the server and then verifies that this results in the server's domain SID changing. The new SID is stored in a global variable so that we can perform additional tests to verify that SIDs are rewritten properly in group_mapping.tdb. old_netbiosname is stored so that we can reset con... | def test_056_netbios_name_change_check_sid(request):
depends(request, ["service_cifs_running"], scope="session")
global new_sid
global old_netbiosname
results = GET("/smb/")
assert results.status_code == 200, results.text
old_netbiosname = results.json()["netbiosname"]
old_sid = results.jso... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_058_change_netbios_name_and_check_groupmap(request):\n depends(request, [\"SID_CHANGED\", \"ssh_password\"], scope=\"session\")\n payload = {\n \"netbiosname\": old_netbiosname,\n }\n results = PUT(\"/smb/\", payload)\n assert results.status_code == 200, results.text\n sleep(5)\n\... | [
"0.7362551",
"0.61641616",
"0.6045183",
"0.60308814",
"0.5808337",
"0.58069056",
"0.5755924",
"0.5711386",
"0.56862813",
"0.5601481",
"0.55547637",
"0.55288833",
"0.5508139",
"0.5473006",
"0.5441461",
"0.5417473",
"0.54068434",
"0.5388924",
"0.5378174",
"0.5349858",
"0.532144... | 0.7686053 | 0 |
Create testgroup and verify that groupmap entry generated with new SID. | def test_057_create_new_smb_group_for_sid_test(request):
depends(request, ["SID_CHANGED", "ssh_password"], scope="session")
global group_id
payload = {
"name": "testsidgroup",
"smb": True,
}
results = POST("/group/", payload)
assert results.status_code == 200, results.text
gr... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_create_group(self):\n pass",
"def test_create_group(self):\n pass",
"def test_verify_that_you_can_create_a_new_group():",
"def test_create_group(self):\n groupid = 'villains'\n\n # create the group\n resp = self.app.post('/groups', data=json.dumps({'name':groupid})... | [
"0.7478963",
"0.7478963",
"0.7324722",
"0.7320051",
"0.698248",
"0.6931495",
"0.68939006",
"0.6839453",
"0.68214154",
"0.6734239",
"0.6696365",
"0.6614686",
"0.65505034",
"0.6506986",
"0.6498141",
"0.6479654",
"0.64630705",
"0.6456968",
"0.6449117",
"0.6447869",
"0.6438386",
... | 0.81538206 | 0 |
Verify that changes to netbios name result in groupmap sid changes. | def test_058_change_netbios_name_and_check_groupmap(request):
depends(request, ["SID_CHANGED", "ssh_password"], scope="session")
payload = {
"netbiosname": old_netbiosname,
}
results = PUT("/smb/", payload)
assert results.status_code == 200, results.text
sleep(5)
cmd = "midclt call ... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_056_netbios_name_change_check_sid(request):\n depends(request, [\"service_cifs_running\"], scope=\"session\")\n global new_sid\n global old_netbiosname\n\n results = GET(\"/smb/\")\n assert results.status_code == 200, results.text\n old_netbiosname = results.json()[\"netbiosname\"]\n ... | [
"0.73724425",
"0.63812697",
"0.60749346",
"0.5786616",
"0.5737494",
"0.5689937",
"0.558545",
"0.556925",
"0.5448637",
"0.5431592",
"0.5371331",
"0.5291523",
"0.52891064",
"0.5282398",
"0.52451235",
"0.523351",
"0.52235484",
"0.52166736",
"0.5215772",
"0.5207367",
"0.52060276"... | 0.8209844 | 0 |
Check if object exists in Swift. | def check_object(container, object):
swift_conn = keystone.get_swiftclient()
try:
swift_conn.head_object(container, object)
return True
except ClientException:
LOG.error(
'The object %s in container %s was not found', object, container
)
return False | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def objExists(*args, **kwargs)->bool:\n pass",
"def exists(self, obj):\n return False",
"def _isobject(self, name, exist):\r\n if exist in [2, 5]:\r\n return False\r\n cmd = \"isobject(%s)\" % name\r\n if not self._engine:\r\n msg = \"Session is not open\"\r... | [
"0.7633462",
"0.7457026",
"0.68618387",
"0.6738865",
"0.66530925",
"0.6610566",
"0.6606193",
"0.6532107",
"0.6531226",
"0.65227437",
"0.6456245",
"0.6397228",
"0.6397228",
"0.63877124",
"0.6349197",
"0.6294372",
"0.62620234",
"0.62258947",
"0.6223668",
"0.62103516",
"0.617190... | 0.6523617 | 9 |
This method will copy from other only the leaves & descendant that are requested in self | def copyRequestedFrom (self, other):
if self.isLocalTimeStringRequested():
self.localTimeString=other.localTimeString
self._myHasLocalTimeString=other._myHasLocalTimeString
self._myLocalTimeStringRequested=other._myLocalTimeStringRequested
if self.isUtcTimeS... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def copy_from(self, other):\n assert not self.is_final\n if self.parent is not None:\n assert other.parent is not None\n self.parent.copy_from(other.parent)\n self.isolated_names = copy.copy(other.isolated_names)\n self.modified = copy.copy(other.modified)\n self.read = copy.copy(other.rea... | [
"0.7139034",
"0.68035215",
"0.65542984",
"0.6402804",
"0.6338159",
"0.6317084",
"0.63066095",
"0.62067425",
"0.6183237",
"0.6153278",
"0.60946536",
"0.6041807",
"0.603661",
"0.5989809",
"0.5975044",
"0.5970866",
"0.5968901",
"0.5928488",
"0.59153694",
"0.58945",
"0.5891103",
... | 0.0 | -1 |
This method will copy to self only the leaves & descendant that are set in other | def copySetFrom (self, other):
if other.hasLocalTimeString():
self.localTimeString=other.localTimeString
self._myHasLocalTimeString=other._myHasLocalTimeString
self._myLocalTimeStringRequested=other._myLocalTimeStringRequested
if other.hasUtcTimeString():
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def copy_from(self, other):\n assert not self.is_final\n if self.parent is not None:\n assert other.parent is not None\n self.parent.copy_from(other.parent)\n self.isolated_names = copy.copy(other.isolated_names)\n self.modified = copy.copy(other.modified)\n self.read = copy.copy(other.rea... | [
"0.65994555",
"0.6590117",
"0.63456917",
"0.63343483",
"0.6332817",
"0.6266025",
"0.62527746",
"0.6083085",
"0.60715175",
"0.6068964",
"0.60687524",
"0.60618335",
"0.6056082",
"0.59922147",
"0.59904253",
"0.59889364",
"0.5935985",
"0.5921964",
"0.5910749",
"0.5903574",
"0.589... | 0.0 | -1 |
This method will copy to self only the leaves & descendant that and their "has" values from other. It will leave "requested" fields unchanged | def copyDataFrom (self, other):
self.localTimeString=other.localTimeString
self._myHasLocalTimeString=other._myHasLocalTimeString
self.utcTimeString=other.utcTimeString
self._myHasUtcTimeString=other._myHasUtcTimeString
self.daylightSavingTime=other.daylightSav... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def copy_from(self, other):\n assert not self.is_final\n if self.parent is not None:\n assert other.parent is not None\n self.parent.copy_from(other.parent)\n self.isolated_names = copy.copy(other.isolated_names)\n self.modified = copy.copy(other.modified)\n self.read = copy.copy(other.rea... | [
"0.65413207",
"0.5917658",
"0.58983076",
"0.58842134",
"0.5883233",
"0.5857297",
"0.5756933",
"0.5754315",
"0.567328",
"0.56559527",
"0.5655356",
"0.56519586",
"0.56430566",
"0.5628962",
"0.5605453",
"0.55990183",
"0.557354",
"0.556295",
"0.5561114",
"0.55332273",
"0.55176497... | 0.0 | -1 |
Only numeric members with has flag set to on will be subtracted | def subtractAllNumericHas (self, other):
if self.hasEpoch():
if other.hasEpoch():
self.epoch -= other.epoch
if self.hasUtcOffsetMinutes():
if other.hasUtcOffsetMinutes():
self.utcOffsetMinutes -= other.utcOffsetMinutes
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __neg__(self):\n return 0 - self",
"def __neg__(self):\n return self.neg()",
"def subtractAllNumericHas (self, other):\n \n if self.hasOutErrorPackets():\n if other.hasOutErrorPackets():\n self.outErrorPackets -= other.outErrorPackets\n \n ... | [
"0.62634593",
"0.61539656",
"0.60460675",
"0.60210055",
"0.5773645",
"0.5751537",
"0.5718697",
"0.5712941",
"0.571179",
"0.56675845",
"0.56455714",
"0.56396145",
"0.5638622",
"0.5621065",
"0.55998564",
"0.5568793",
"0.5568793",
"0.5568793",
"0.5551674",
"0.5467386",
"0.545240... | 0.60316527 | 3 |
Only numeric members with has flag set to on will be subtracted | def addAllNumericHas (self, other):
if self.hasEpoch():
if other.hasEpoch():
self.epoch += other.epoch
if self.hasUtcOffsetMinutes():
if other.hasUtcOffsetMinutes():
self.utcOffsetMinutes += other.utcOffsetMinutes
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __neg__(self):\n return 0 - self",
"def __neg__(self):\n return self.neg()",
"def subtractAllNumericHas (self, other):\n \n if self.hasOutErrorPackets():\n if other.hasOutErrorPackets():\n self.outErrorPackets -= other.outErrorPackets\n \n ... | [
"0.6264014",
"0.615425",
"0.6046589",
"0.6032788",
"0.6021112",
"0.5774686",
"0.575271",
"0.5718622",
"0.57138014",
"0.57122934",
"0.5668872",
"0.56468856",
"0.5641599",
"0.56415534",
"0.5621353",
"0.5600475",
"0.55667835",
"0.55667835",
"0.55667835",
"0.5551966",
"0.54674935... | 0.0 | -1 |
Print a line to the output file, discarding duplicate blank lines. | def write(s):
global prev_line
if not (prev_line == "\n" and s == "\n"):
fo.write(s)
prev_line = s | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def write_stripped_line(fout, line):\n fout.write(line)\n fout.write('\\n')",
"def dealCommonline(line):\n\n print \"\\t\\t%s\" % (line.strip('\\n'))",
"def write_line(self, line):\n\n if line[0] != \"(\": # indent all non-label lines.\n line = \" \" * 4 + line\n self.fd.writ... | [
"0.6561397",
"0.6144277",
"0.6068922",
"0.6002885",
"0.59682703",
"0.5850297",
"0.5837288",
"0.5804523",
"0.5775405",
"0.5681184",
"0.56594974",
"0.56477165",
"0.56048447",
"0.5593835",
"0.5592475",
"0.5574469",
"0.55244064",
"0.5516073",
"0.55054593",
"0.54997486",
"0.547703... | 0.5347325 | 47 |
Parse a C constant value in decimal or hex. Return None if the input isn't a constant. | def convert_value(value):
# print "Attempting to match value: %s" % value
m = re.match('^(0(x|X)[0-9a-fA-F]+|[0-9]+)$', value)
if m is None:
return None
value = m.group(1)
if value.startswith("0x") or value.startswith("0X"):
return int(value[2:], 16)
else:
return int(value) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_constant(name, libgmt):\n c_get_enum = libgmt.GMT_Get_Enum\n c_get_enum.argtypes = [ctypes.c_char_p]\n c_get_enum.restype = ctypes.c_int\n\n value = c_get_enum(name.encode())\n\n if value is None or value == -99999:\n raise GMTCLibError(\n \"Constant '{}' doesn't exits in l... | [
"0.5632588",
"0.5586047",
"0.5533818",
"0.55302715",
"0.5484222",
"0.5482968",
"0.54275924",
"0.5395987",
"0.53449136",
"0.5325055",
"0.52999747",
"0.5280379",
"0.5259344",
"0.52487993",
"0.52158546",
"0.519826",
"0.5152143",
"0.51404864",
"0.51237184",
"0.51235414",
"0.51213... | 0.56358886 | 0 |
Convert a C identifier to be a valid occam identifer. | def occamify_name(name):
name = name.replace("_", ".")
if name[0] == ".":
name = "X" + name
if name[-1] == ".":
name += "X"
return name | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def to_identifier(val: Any):\n val = str(val).strip()\n # Replaces spaces, dashes, and slashes to underscores\n val = re.sub(r\"[\\s\\-/\\\\]\", \"_\", val)\n # Remove remaining invalid characters\n val = re.sub(r\"[^0-9a-zA-Z_]\", \"\", val)\n # Identifier can't start with digits\n val = re.s... | [
"0.6382469",
"0.63354176",
"0.5939232",
"0.5869739",
"0.5867305",
"0.5863034",
"0.5823705",
"0.5754403",
"0.5711596",
"0.56707406",
"0.566262",
"0.5643252",
"0.56212616",
"0.55866235",
"0.5584955",
"0.5584267",
"0.55398595",
"0.55394506",
"0.55231905",
"0.55100995",
"0.548896... | 0.0 | -1 |
This method is called when the handler should emit the record. By default, SocketHandler will silently drop a message if it cannot send it. Because this is not desired in our case, we will use a queue that will act as a buffer if the message is not sent | def emit(self, record):
self.buffer.append(record)
while len(self.buffer) != 0:
nextRecord = self.buffer.popleft()
super().emit(nextRecord)
if self.sock is None: # If we failed to send the record
self.buffer.appendleft(nextRecord)
br... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def emit(self, record):\n try:\n # Format: [ [queueMsgID, PID], record ]\n self.queue.put([[config.DUMMYMP_LOG_ID, os.getpid(), self.int_pid], record])\n except:\n # Something went wrong...\n self.handleError(record)",
"def handle_write(self):\n #s... | [
"0.6777097",
"0.67079544",
"0.6660982",
"0.66555536",
"0.66555536",
"0.66555536",
"0.6519431",
"0.6481583",
"0.6451602",
"0.64207643",
"0.64196646",
"0.64065015",
"0.6357897",
"0.6326828",
"0.62853485",
"0.6271823",
"0.62639964",
"0.6251536",
"0.6215217",
"0.61984706",
"0.619... | 0.7365688 | 0 |
The following code is copied from the SocketHandler implementation. One line is changed to prevent all messages from being converted to strings. | def makePickle(self, record):
ei = record.exc_info
if ei:
# just to get traceback text into record.exc_text ...
dummy = self.format(record)
# See issue #14436: If msg or args are objects, they may not be
# available on the receiving end. So we convert the msg % ar... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def handleMessage(msg):",
"def handle_message(self, message):",
"def to_string(msg):\n if type(msg) is bytes:\n msg = str(msg)\n msg = msg[2:]\n return msg[:-1]\n else:\n return msg",
"def handle(self, message):",
"def __processMsg(self, sock, msgData):\n\n pass",
... | [
"0.6507231",
"0.6033136",
"0.5843889",
"0.5815367",
"0.5716884",
"0.5715668",
"0.56667054",
"0.5658734",
"0.5644602",
"0.56359076",
"0.56347317",
"0.5606671",
"0.55791515",
"0.5511831",
"0.5506883",
"0.5450436",
"0.54457396",
"0.54431564",
"0.5422972",
"0.53962946",
"0.538632... | 0.0 | -1 |
| Requests the content of a directory on the machine running Nanome | def _request_directory(self, path, callback=None, pattern="*"):
options = DirectoryRequestOptions()
options._directory_name = path
options._pattern = pattern
id = self._network._send(_Messages.directory_request, options, callback != None)
self._save_callback(id, callback) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def read_dir():\n request()\n sleep_ms( 100 ) # give sometime for the buffer to get data\n try:\n read_response()\n except Exception as err:\n print( 'Error decoding response' )\n print( '[ERROR]', err )\n sleep_ms( 1000 )",
"def test_dir_query():\n response = echo_client(\... | [
"0.7279646",
"0.6351751",
"0.6332403",
"0.60547894",
"0.58797693",
"0.586253",
"0.58039623",
"0.5776779",
"0.5737375",
"0.57306904",
"0.5706204",
"0.57026035",
"0.56860507",
"0.56487966",
"0.5639918",
"0.55764306",
"0.554403",
"0.55420625",
"0.5540011",
"0.548273",
"0.5476476... | 0.5246486 | 63 |
| Reads files on the machine running Nanome, and returns them | def _request_files(self, file_list, callback=None):
id = self._network._send(_Messages.file_request, file_list, callback != None)
self._save_callback(id, callback) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def read_all_files():\n paths = get_all_recording_paths()\n\n return read_by_paths(paths)",
"def get_nasadem_file_list():\n\n global nasadem_file_list\n if nasadem_file_list is None:\n nasadem_file = download_url(nasadem_file_index_url)\n with open(nasadem_file) as f:\n nasad... | [
"0.63308704",
"0.63162225",
"0.6124706",
"0.61032605",
"0.60520303",
"0.6001759",
"0.5981098",
"0.5973027",
"0.59662366",
"0.59262437",
"0.5905288",
"0.5895844",
"0.5888806",
"0.58481973",
"0.5807229",
"0.58071476",
"0.5765757",
"0.57574964",
"0.5742501",
"0.57266575",
"0.570... | 0.0 | -1 |
Helper function for argument parsing. | def int_or_str(text):
try:
return int(text)
except ValueError:
return text | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def parse_arguments(args):",
"def Args(parser):",
"def _pre_argument_parsing(self):\n pass",
"def _parse_args(self, prepared_args):\n pass",
"def parseArguments(self):\n iterator = iter(sys.argv[1:]) # Skip file name\n for argument in iterator:\n if len(argument) < 2... | [
"0.79303455",
"0.7602255",
"0.73190254",
"0.7167153",
"0.68745065",
"0.687013",
"0.6869624",
"0.68274933",
"0.68205035",
"0.67932284",
"0.6792503",
"0.67673117",
"0.6763976",
"0.66961086",
"0.6694033",
"0.66836804",
"0.6668083",
"0.6649227",
"0.6605114",
"0.658573",
"0.657141... | 0.0 | -1 |
The spectrum sits in a buffer with width spec_buffer_pad + spec_buffer_w . The first spec_buffer_pad of it is a copy of the last spec_buffer_pad of it. | def stream_inference_of_microphone_audio(args):
with sd.InputStream(device=args.device, channels=1, callback=update_spectrogram,
blocksize=samples_buffer_block_size,
samplerate=samplerate):
with tf.Session() as sess:
tf.saved_model.loader.load(sess... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def observed_spectrum(spec, wave, resolution, mag=None, mag_band='g', mag_system='AB', \n redshift=None, emline_db=None):\n if redshift is not None:\n spec.redshift(redshift)\n if mag is not None:\n broadband = efficiency.FilterResponse(band=mag_band)\n # Check that ... | [
"0.58118004",
"0.5794949",
"0.5607931",
"0.55611324",
"0.5536402",
"0.54763293",
"0.5458407",
"0.54346955",
"0.5432787",
"0.5346925",
"0.5333904",
"0.5282993",
"0.5275823",
"0.52669376",
"0.526041",
"0.522841",
"0.5217324",
"0.51879936",
"0.51861805",
"0.51780736",
"0.5172873... | 0.0 | -1 |
create database and tables in mysql | def init_database(self):
try:
DatabaseCreation.create_database()
except BaseExceptionHandler as base_exception_handler:
self.logger.error(message=base_exception_handler.error_message) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def create_db():\n db.create_all()\n print('Database structure created successfully')",
"def make_db():\n\n db.create_all()",
"def create_tables():\n db.create_all()",
"def create_tables():\n db.create_all()",
"def create_database():\n with connection:\n connection.execute(... | [
"0.80518013",
"0.8014398",
"0.79978704",
"0.79978704",
"0.79829156",
"0.7973766",
"0.7953593",
"0.7953593",
"0.7953593",
"0.7953593",
"0.7953593",
"0.7953593",
"0.7953593",
"0.7953593",
"0.7953593",
"0.7953593",
"0.7953593",
"0.79528016",
"0.7904342",
"0.7874087",
"0.78698146... | 0.0 | -1 |
Parse Text2Text model training arguments | def parse_arguments(args):
parser = argparse.ArgumentParser(
description="Text2Text: Read input text training files, output item files and train a model"
)
parser.add_argument(
"-i",
"--input-text-path",
type=str,
required=True,
metavar="INPUT_TEXT_PATH",
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_train_args():\n parser = argparse.ArgumentParser('Train a Text Summarization Model')\n\n # parser.add_argument('--hiddenDim', nargs='?', type=int, default=50, help='The size of the hidden dimension to be used for all layers')\n parser.add_argument('--hiddenDim', type=int, default=50, help='The siz... | [
"0.686333",
"0.67426586",
"0.6403633",
"0.63728684",
"0.63588935",
"0.63261265",
"0.63138217",
"0.6302748",
"0.62799126",
"0.6250235",
"0.6242753",
"0.62252027",
"0.6123396",
"0.6101539",
"0.607476",
"0.6056414",
"0.6046505",
"0.60454464",
"0.60431504",
"0.60165226",
"0.59678... | 0.6688534 | 2 |
Note that this method supports the `seed` argument (for consistency with other generators), but its value is ignored because resetting a Constant generator has no effect. | def reset(self, seed=None):
super().reset(seed)
return self | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def temp_seed(cntxt_seed):\n state = np.random.get_state()\n np.random.seed(cntxt_seed)\n try:\n yield\n finally:\n np.random.set_state(state)",
"def seed(self, seed=None):\r\n if seed is None:\r\n seed = self.default_seed\r\n #backport\r\n #seed = self.d... | [
"0.66678673",
"0.66486984",
"0.66190064",
"0.66113573",
"0.6481708",
"0.6450779",
"0.6450779",
"0.6387273",
"0.638019",
"0.6367012",
"0.63657165",
"0.6360408",
"0.6359411",
"0.6357816",
"0.6341527",
"0.6340486",
"0.63117254",
"0.624635",
"0.624635",
"0.62377846",
"0.62114537"... | 0.6098022 | 28 |
Test case for rest_v20_dd_systems_systemid_stats_capacity_get | def test_rest_v20_dd_systems_systemid_stats_capacity_get(self):
pass | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_capacity(self, meta, raven_vars, dispatch, t, raw=False):\n return self.get_interaction().get_capacity(meta, raven_vars, dispatch, t, raw=raw)",
"def get_capacity():\n fs.get_capacity()",
"def test_get_cluster_capacity_monthly_resolution(self):\n url = \"?filter[time_scope_units]=month&fil... | [
"0.6880177",
"0.6838495",
"0.67628455",
"0.6728308",
"0.66688097",
"0.6290439",
"0.62468123",
"0.61392134",
"0.60665524",
"0.6012225",
"0.59929657",
"0.5983629",
"0.5947236",
"0.5928955",
"0.5917592",
"0.59040964",
"0.5896049",
"0.5859963",
"0.58585066",
"0.5814054",
"0.57612... | 0.96901834 | 0 |
make node without archiving, create temp table, take full backup, check that temp table not present in backup catalogue | def test_exclude_temp_tables(self):
fname = self.id().split('.')[3]
backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
node = self.make_simple_node(base_dir="{0}/{1}/node".format(module_name, fname),
set_replication=True,
initdb_params=['--data-checksu... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_backup_compact(self):\n gen = BlobGenerator(\"ent-backup\", \"ent-backup-\", self.value_size, end=self.num_items)\n self._load_all_buckets(self.master, gen, \"create\", 0)\n self.backup_create()\n self.backup_cluster_validate()\n self.backup_compact_validate()",
"def t... | [
"0.59866905",
"0.58030164",
"0.566614",
"0.55969876",
"0.5524487",
"0.55036587",
"0.5501728",
"0.54733956",
"0.5441421",
"0.53914344",
"0.53887075",
"0.5378152",
"0.53320277",
"0.5308021",
"0.5263021",
"0.5219191",
"0.5218431",
"0.52177876",
"0.5212545",
"0.5208883",
"0.52000... | 0.6901967 | 0 |
make node without archiving, create temp table, take full backup, check that temp table not present in backup catalogue | def test_exclude_unlogged_tables(self):
fname = self.id().split('.')[3]
backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')
node = self.make_simple_node(base_dir="{0}/{1}/node".format(module_name, fname),
set_replication=True,
initdb_params=['--data-che... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_exclude_temp_tables(self):\n fname = self.id().split('.')[3]\n backup_dir = os.path.join(self.tmp_path, module_name, fname, 'backup')\n node = self.make_simple_node(base_dir=\"{0}/{1}/node\".format(module_name, fname),\n set_replication=True,\n initdb_params=['--... | [
"0.6903086",
"0.5988097",
"0.58038205",
"0.559825",
"0.5524568",
"0.550428",
"0.5502258",
"0.54732674",
"0.5442118",
"0.53923094",
"0.5389752",
"0.5378277",
"0.5331801",
"0.53092754",
"0.5263534",
"0.52197963",
"0.5218867",
"0.5218319",
"0.52124774",
"0.52093047",
"0.5201064"... | 0.566736 | 3 |
Spec function for a token embedding module. | def bert_module_fn(is_training):
input_ids = tf.compat.v1.placeholder(shape=[None, None], dtype=tf.int32, name="input_ids")
input_mask = tf.compat.v1.placeholder(shape=[None, None], dtype=tf.int32, name="input_mask")
token_type = tf.compat.v1.placeholder(shape=[None, None], dtype=tf.int32, name... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_get_tokens():\n pass",
"def test_decode_token():\n pass",
"def test_char_embedder(self, resource_loader):\n config = {\n \"model_type\": \"tagger\",\n \"example_type\": ENTITY_EXAMPLE_TYPE,\n \"label_type\": ENTITIES_LABEL_TYPE,\n \"model_settin... | [
"0.5766105",
"0.57528055",
"0.56794906",
"0.55031544",
"0.54930705",
"0.5325876",
"0.5264288",
"0.52472454",
"0.52392995",
"0.51481664",
"0.51122683",
"0.50571203",
"0.50538754",
"0.50153184",
"0.50013244",
"0.49968055",
"0.49864978",
"0.4977168",
"0.49732983",
"0.4953704",
"... | 0.50553316 | 12 |
add token to database | def blacklist_token(token, user):
user = User.query.filter_by(username=user).first()
user.login_status = False
token = Token.query.filter_by(token=token).first()
token.blacklist = True
db.session.commit()
return {'Message': 'You have successfully logged out', "Statu... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def saveToken(self, token):\n query = \"INSERT OR REPLACE INTO token (token, id) VALUES (?, 1)\"\n self.db.execute(query, (token,))",
"def save_token(self):\n db.session.add(self)\n db.session.commit()",
"def add_token_to_database(encoded_token, identity_claim):\r\n decoded_token... | [
"0.8094326",
"0.8070803",
"0.74415904",
"0.70355546",
"0.7000242",
"0.6967281",
"0.69559306",
"0.6940046",
"0.6920779",
"0.6872094",
"0.6775218",
"0.67006576",
"0.66358006",
"0.6613867",
"0.6519567",
"0.6519567",
"0.63963455",
"0.62032",
"0.610051",
"0.6077065",
"0.6077065",
... | 0.0 | -1 |
Start at the start and the end, count inwards | def palindrome_itertive(a):
# TODO make this less crappy
start = 0
end = len(a) - 1
while start != end:
# print(end)
# print('start: ', start, ' a: ', a[start])
# print('end: ', end, ' a: ', a[end])
if not a[start] == a[end]:
return False
else:
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def count_up(start, stop):\n while start <=stop:\n print(start)\n start +=1",
"def count(self):\n\n count = 0\n x = self.begin\n\n if self.begin == self.end == None:\n return 0\n\n elif self.begin == self.end:\n return 1\n\n else:\n ... | [
"0.7230575",
"0.6875732",
"0.66416466",
"0.6609699",
"0.6562417",
"0.6481846",
"0.62998545",
"0.628956",
"0.62748414",
"0.62748414",
"0.6273725",
"0.6236967",
"0.6213429",
"0.61929876",
"0.6182156",
"0.61766803",
"0.61409944",
"0.61409944",
"0.61409944",
"0.61409944",
"0.6138... | 0.0 | -1 |
OH GOD HERE WE GO AGAIN AND AGAIN AND AGAIN AND AGAIN | def palindrome_recursive(a):
# Base case
if len(a) <= 1:
return True
else:
if a[0] == a[len(a)-1]:
return palindrome_recursive(a[1:-1])
else:
return False | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def exercise_b2_53():\r\n pass",
"def substantiate():",
"def exercise_b2_27():\r\n pass",
"def exercise_b2_69():\r\n pass",
"def exercise_b2_106():\r\n pass",
"def exercise_b2_113():\r\n pass",
"def exercise_b2_107():\r\n pass",
"def smarter():\r\n pass",
"def exo2():",
"def ... | [
"0.6076375",
"0.5914736",
"0.5894991",
"0.5881642",
"0.5800912",
"0.57918847",
"0.57858425",
"0.57839304",
"0.57633895",
"0.5762886",
"0.57562476",
"0.5729908",
"0.5719242",
"0.5715583",
"0.56889856",
"0.5682348",
"0.5657531",
"0.56277037",
"0.5583101",
"0.55743325",
"0.55732... | 0.0 | -1 |
Returns the longest contiguous palindrome in a given string. Iteratively go through the string and pass all substrings through function to check if they're palindromes. Store the longest. Then increase starting character and do it again. THIS IS BAD. If the whole string is a palindrome, I take _as long as possible_ to ... | def longest_palindrome(a):
# This is some spaghetti if I've ever seen some. In the case where the whole work is
# a palindrome, we can go ahead and skip. BUT ONLY IN THAT INSTANCE BECAUSE IT'S BAD
if palindrome_golf(a):
return a
# Enter the bad
max_so_far = ''
for length in range(1,len(... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def longest_palindrome(string):\n if is_palindrome(string):\n return string\n\n max_len = len(string) - 1\n\n while max_len > 0:\n i = 0\n while (i + max_len) <= len(string):\n sub = string[i:(i + max_len)]\n if is_palindrome(sub):\n return sub\n ... | [
"0.83150655",
"0.79243183",
"0.7793008",
"0.75675213",
"0.74943185",
"0.73650616",
"0.7276467",
"0.72561765",
"0.72025687",
"0.69321364",
"0.6855386",
"0.68493617",
"0.6692047",
"0.6672678",
"0.66698956",
"0.6611336",
"0.65887463",
"0.65847784",
"0.65815246",
"0.65474427",
"0... | 0.7861719 | 2 |
Gather all the images collecting available urls from input file | def collect_images_from_urls(url_filepath, target_folder, image_class_name):
def get_img_from_url(index, url):
"""Closure function invoked by each running downloading Thread"""
try:
with urllib.request.urlopen(url) as response:
if response.headers.get_content_maintype() ... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _read_image_urls(self):\n if not os.path.isfile(self._image_urls_file_name):\n raise IOError, \"'%s' is not found\" % self._image_urls_file_name\n if os.path.getsize(self._image_urls_file_name) == 0:\n raise IOError, \"'%s' is empty\" % self._image_urls_file_name\n fo... | [
"0.7226425",
"0.70590836",
"0.69470996",
"0.69348496",
"0.6923049",
"0.6900815",
"0.68564993",
"0.6853746",
"0.6749816",
"0.6686294",
"0.6652796",
"0.6562838",
"0.6533928",
"0.6515956",
"0.6465455",
"0.64469564",
"0.6442082",
"0.6438901",
"0.6426852",
"0.6349089",
"0.634611",... | 0.67413855 | 9 |
Closure function invoked by each running downloading Thread | def get_img_from_url(index, url):
try:
with urllib.request.urlopen(url) as response:
if response.headers.get_content_maintype() == 'image':
image_filename = image_filename_prefix.format(name=image_class_name,
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def run(self):\n urls_to_download = self._get_links()\n results = ThreadPool(8).imap_unordered(self._download_url, urls_to_download)\n for path in results:\n print(path)",
"def main():\n for i, url in enumerate(opts.thread, start=1):\n opts.archived_md5 = reload_archive(... | [
"0.7098351",
"0.7055904",
"0.68225944",
"0.66464436",
"0.65913904",
"0.6507428",
"0.64913315",
"0.64657086",
"0.64212185",
"0.6403113",
"0.63153106",
"0.6311804",
"0.6286661",
"0.6259997",
"0.62520695",
"0.6230645",
"0.6185179",
"0.61826974",
"0.6145493",
"0.61442566",
"0.613... | 0.0 | -1 |
If file was exist already, rename it and return a new name | def gen_file_name(filename, path=UPLOAD_FOLDER):
i = 1
while os.path.exists(os.path.join(path, filename)):
name, extension = os.path.splitext(filename)
filename = '%s_%s%s' % (name, str(i), extension)
i += 1
return filename | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def fileRenameandReplace(filename,newfilename):\n try:\n os.rename(filename,newfilename)\n logging.info(\"Json file renamed in PD path\")\n except Exception as er:\n print (\"Not able to rename the json file \")\n return False",
"def auto_rename(file_path, new_name):\n \n # Re... | [
"0.7435091",
"0.7346437",
"0.72911143",
"0.724895",
"0.72124314",
"0.7185561",
"0.713919",
"0.69512355",
"0.6867768",
"0.6814744",
"0.6778549",
"0.6761721",
"0.67595124",
"0.67341584",
"0.6674652",
"0.6667342",
"0.6659564",
"0.6628739",
"0.6602175",
"0.65358675",
"0.64996296"... | 0.0 | -1 |
Checks if this intersatellite link could transmit data (stateindependent). | def couldTransmit(self, data, receiver, txLocation, rxLocation, context):
return super(InterSatelliteLink, self).couldTransmit(data, receiver) \
and txLocation.isOrbit() \
and rxLocation.isOrbit() \
and (abs(txLocation.sector - rxLocation.sector) <= 1
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def couldReceive(self, data, transmitter, txLocation, rxLocation, context):\n return super(InterSatelliteLink, self).couldReceive(data, transmitter) \\\n and txLocation.isOrbit() \\\n and rxLocation.isOrbit() \\\n and (abs(txLocation.sector - rxLocation.sector) <... | [
"0.6808816",
"0.66868186",
"0.64477277",
"0.64418393",
"0.62366825",
"0.61757886",
"0.6150189",
"0.6097931",
"0.60884607",
"0.60488987",
"0.6041025",
"0.60021377",
"0.5998871",
"0.5975922",
"0.5969649",
"0.5958305",
"0.59526134",
"0.59449387",
"0.5935071",
"0.592336",
"0.5916... | 0.76803 | 0 |
Checks if this intersatellite link could receive data (stateindependent). | def couldReceive(self, data, transmitter, txLocation, rxLocation, context):
return super(InterSatelliteLink, self).couldReceive(data, transmitter) \
and txLocation.isOrbit() \
and rxLocation.isOrbit() \
and (abs(txLocation.sector - rxLocation.sector) <= 1
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def DataAvailable(self) -> bool:",
"def data_available(self):\n return (self.status & 0x08) != 0",
"def couldTransmit(self, data, receiver, txLocation, rxLocation, context):\n return super(InterSatelliteLink, self).couldTransmit(data, receiver) \\\n and txLocation.isOrbit() \\\n ... | [
"0.6806446",
"0.666152",
"0.6657909",
"0.6534576",
"0.65277207",
"0.65100396",
"0.6355405",
"0.63156337",
"0.63156337",
"0.6288527",
"0.6234863",
"0.62215567",
"0.61767733",
"0.61651605",
"0.61578643",
"0.6138238",
"0.60690147",
"0.6063522",
"0.60616744",
"0.60542154",
"0.603... | 0.71264654 | 0 |
Checks if this is an intersatellite link. | def isISL(self):
return True | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def is_cross_onap_link(self, logical_link):\n for relationship in logical_link[\"relationship-list\"][\"relationship\"]:\n if relationship[\"related-to\"] == \"ext-aai-network\":\n return True\n return False",
"def isAlternateLink(self, rel, type = None): #$NON-NLS-1$\r\n ... | [
"0.6288431",
"0.6154505",
"0.6127506",
"0.59536004",
"0.5880275",
"0.585257",
"0.58179533",
"0.5740787",
"0.5721288",
"0.571853",
"0.56867456",
"0.5679271",
"0.567471",
"0.5648151",
"0.56475735",
"0.559833",
"0.5596475",
"0.5586078",
"0.5565179",
"0.5555051",
"0.55481195",
... | 0.61121464 | 3 |
The basic idea here is to represent the file contents as a long string and iterate through it characterbycharacter (the 'ind' variable points to the current character). Whenever we get to a new tree, we call the function again (recursively) to read it in. | def readTree(text, ind, verbose=False):
if verbose:
print("Reading new subtree", text[ind:][:10])
# consume any spaces before the tree
while text[ind].isspace():
ind += 1
if text[ind] == "(":
if verbose:
print("Found open paren")
tree = []
ind += 1
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def traverse_tree(file, tree):\n\n\tfor node in tree.get_children():\n\t\tpass",
"def fileparse(filename, node):\n\n fd = open(filename)\n line = fd.readline().strip('\\r\\n')\n\n while line != '':\n node.Add(line, node)\n line = fd.readline().strip('\\r\\n')",
"def read_file_into_tree(f... | [
"0.57345337",
"0.5500208",
"0.54999906",
"0.54994",
"0.54745203",
"0.53851414",
"0.5351733",
"0.5224818",
"0.5221484",
"0.5204018",
"0.5189784",
"0.51858944",
"0.51852345",
"0.5182749",
"0.51462406",
"0.51426816",
"0.5098841",
"0.50946444",
"0.50844306",
"0.50804096",
"0.5069... | 0.6211928 | 0 |
queries the given url and places in the params and headers into the request if present. | def query(url, params=None, headers_param=None):
if params is None:
params = {}
logging.info("url={0}\tparams={1}".format(url, params))
headers = {
'Referer': url,
"Content-Type": "text/xml; charset=UTF-8", # implement after checking if this doesn't kill the other scripts
'U... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def query(url):",
"def request(url, headers, params, method=\"GET\"):\n url = UrlManipulation.replace_query_params(url, **params)\n logger.debug(f\"request(): {method} {url}\")\n req = urllib.request.Request(url, headers=headers, method=method)\n try:\n with urllib.request.... | [
"0.71451706",
"0.64857244",
"0.6369296",
"0.6307592",
"0.63027126",
"0.61929387",
"0.6177525",
"0.6103905",
"0.60760415",
"0.6020824",
"0.60137224",
"0.597998",
"0.59702086",
"0.5964929",
"0.59598595",
"0.5957351",
"0.5942728",
"0.59328884",
"0.59190345",
"0.59136254",
"0.586... | 0.6601044 | 1 |
Return the configuration object based on the name. | def get_named_config(config_name: str = 'production'):
if config_name in ['production', 'staging', 'default']:
config = ProdConfig()
elif config_name == 'testing':
config = TestConfig()
elif config_name == 'development':
config = DevConfig()
else:
raise KeyError(f'Unknown... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_config(self, name):\n return self.configs[name][0]",
"def get_config_by_name(name):\r\n attrs = get_config_attributes(name)\r\n if attrs['online']:\r\n config = CONFIGS[name]()\r\n else:\r\n config = CONFIGS[name]\r\n \r\n # setting the Tune Run name attribute\r\n ... | [
"0.8064526",
"0.77655816",
"0.77019644",
"0.74938506",
"0.73495984",
"0.72860664",
"0.72388405",
"0.72321206",
"0.7196328",
"0.7142278",
"0.71287477",
"0.7099421",
"0.69440746",
"0.69259566",
"0.66691816",
"0.65930384",
"0.6522588",
"0.6522556",
"0.65188694",
"0.65184826",
"0... | 0.748673 | 4 |
Getter for the _target trait. | def _get__target(self):
if self._saved_target is None:
self._saved_target = self._metadata.get_callable()()
return self._saved_target | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_target(self):\n return self._target",
"def _target(self):\n return self.__target",
"def target(self):\n return self._target",
"def target(self):\n return self._target",
"def target(self):\n return self._target",
"def target(self):\n return self._target",
... | [
"0.84827393",
"0.82744116",
"0.81823874",
"0.81823874",
"0.81823874",
"0.81823874",
"0.8173378",
"0.8173378",
"0.81621283",
"0.8154736",
"0.8072631",
"0.8058809",
"0.7985514",
"0.7985514",
"0.7984027",
"0.7978245",
"0.7950289",
"0.77790356",
"0.7757075",
"0.764704",
"0.760310... | 0.6959168 | 47 |
Make the functions for adding filters and add them to the namespace automatically. | def _make_functions(namespace):
for fil in registry.filters:
func_name = camel2enthought(fil.id)
class_name = fil.id
if func_name.endswith('_filter'):
func_name = func_name[:-7]
class_name = class_name[:-6]
class_name = class_name + 'Factory'
# Don't ... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def load_custom_filters(environment):\n\n # TODO deprecate ipaddr_index and netmask for the better ipnet ones\n filter_list = {\n 'dpkg_arch': filter_dpkg_arch,\n 'storage_size_num': filter_storage_size_num,\n 'ipnet_hostaddr': filter_ipnet_hostaddr,\n 'ipnet_hostmin': filter_ipne... | [
"0.6854986",
"0.65905815",
"0.6556149",
"0.6516991",
"0.6503513",
"0.6503041",
"0.649308",
"0.64256465",
"0.6318187",
"0.6257711",
"0.62176806",
"0.6180177",
"0.61334944",
"0.6132359",
"0.6121357",
"0.61159486",
"0.6114769",
"0.609798",
"0.6030215",
"0.6022262",
"0.6016461",
... | 0.7930712 | 0 |
Runs the RPKI Validator | def __enter__(self):
utils.kill_port(self.port)
# Must remove these to ensure a clean run
utils.clean_paths(self.rpki_db_paths)
cmds = [f"cd {self.rpki_package_path}",
f"chown -R root:root {self.rpki_package_path}"]
utils.run_cmds(cmds)
# Writes validator... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _start_validator(self):\n\n logging.info(\"Starting RPKI Validator\")\n utils.run_cmds((f\"cd {self.rpki_package_path} && \"\n f\"./{self.rpki_run_name}\"))",
"def run():\n\n parser = argparse.ArgumentParser(description='Run the GOComp PSSE based validation tool on a p... | [
"0.73801863",
"0.64284384",
"0.6258135",
"0.5849748",
"0.58456504",
"0.58381337",
"0.5827633",
"0.58155566",
"0.5787312",
"0.57792974",
"0.57668513",
"0.57668513",
"0.5709736",
"0.5706987",
"0.56957924",
"0.56811833",
"0.56714517",
"0.56623787",
"0.56613994",
"0.56548417",
"0... | 0.0 | -1 |
Sends start cmd to RPKI Validator | def _start_validator(self):
logging.info("Starting RPKI Validator")
utils.run_cmds((f"cd {self.rpki_package_path} && "
f"./{self.rpki_run_name}")) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def start_execution(self):\n self.send_message(\"control.start\",None)",
"async def start_validators(self):\n if self.is_client():\n return\n\n await sleep(random.random() * 3)\n\n cmd = \"/home/martijn/stellar-core/stellar-core run\"\n out_file = open(\"stellar.out\... | [
"0.6607596",
"0.6571173",
"0.6326597",
"0.6210207",
"0.6210207",
"0.6210207",
"0.6210207",
"0.6158169",
"0.613642",
"0.6122255",
"0.60959846",
"0.6072968",
"0.60660356",
"0.60612607",
"0.60051334",
"0.5982089",
"0.5948722",
"0.592256",
"0.589133",
"0.58726084",
"0.5835454",
... | 0.74625295 | 0 |
Loads all trust anchors | def load_trust_anchors(self):
utils.write_to_stdout(f"{datetime.now()}: Loading RPKI Validator\n",
logging.root.level)
time.sleep(60)
while self._get_validation_status() is False:
time.sleep(10)
utils.write_to_stdout(".", logging.root.level)... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def FullTrustAssemblies(self) -> _n_1_t_2:",
"def UserApplicationTrusts(self) -> ApplicationTrustCollection:",
"def FullTrustAssemblies(self) -> _n_2_t_0[StrongName]:",
"def ApplicationTrustManager(self) -> IApplicationTrustManager:",
"def load_verify_locations(self, cafile: Optional[Any] = ..., dummy: Opt... | [
"0.6452937",
"0.6358674",
"0.6343231",
"0.60823315",
"0.60078466",
"0.5811615",
"0.5778859",
"0.5626693",
"0.5504848",
"0.54254216",
"0.54251266",
"0.54206556",
"0.53962106",
"0.53946304",
"0.53521353",
"0.53237087",
"0.5316759",
"0.53055185",
"0.5273949",
"0.5269059",
"0.516... | 0.72097015 | 0 |
Makes query to api of rpki validator | def make_query(self, api_endpoint: str, data=True) -> dict:
result = utils.get_json(os.path.join(self.api_url, api_endpoint),
RPKI_Validator_Wrapper.get_headers())
return result["data"] if data else result | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def request(query):",
"def query(self):",
"def query(self, query):",
"def test_query_endpoint(self):\n\n test_query = {'user': {'email': 'joshua@emmaa.com',\n 'name': 'joshua',\n 'slack_id': '123456abcdef'},\n 'models': [... | [
"0.6170514",
"0.59080476",
"0.5833607",
"0.5753477",
"0.5671307",
"0.5548914",
"0.5526771",
"0.5455396",
"0.54270256",
"0.5394377",
"0.53173655",
"0.53173655",
"0.529548",
"0.52700967",
"0.5267953",
"0.5258905",
"0.52568907",
"0.52481514",
"0.52410793",
"0.52322966",
"0.52301... | 0.55104727 | 7 |
Gets the data from ripe and formats it for csv insertions | def get_validity_data(self) -> dict:
logging.info("Getting data from ripe")
assert self.total_prefix_origin_pairs < 10000000, "page size too small"
# Then we get the data from the ripe RPKI validator
# Todo for later, change 10mil to be total count
return self.make_query("bgp/?p... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def prepare_CSV(self):\n self.drop_columns()\n self.rename_columns()\n self.spilt_columns()\n self.add_vehicle_id_column()\n self.add_source_column()\n self.add_timestamp_columns()\n self.get_colour_columns()\n self.clean_column_formats()\n\n # print(s... | [
"0.67308193",
"0.60329825",
"0.6019134",
"0.5944693",
"0.586528",
"0.5816258",
"0.57726353",
"0.5743871",
"0.5715828",
"0.5697282",
"0.55727077",
"0.55635524",
"0.5538254",
"0.55140436",
"0.5508639",
"0.55046505",
"0.5496556",
"0.54953486",
"0.54451126",
"0.5443631",
"0.54399... | 0.0 | -1 |
logs a message and waits | def _wait(self, time_to_sleep: int, msg: str):
logging.debug(msg)
if logging.root.level == logging.INFO:
# Number of times per second to update tqdm
divisor = 100
for _ in trange(time_to_sleep * divisor,
desc=msg):
time.sle... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"async def step_log(self, context: CallbackContext) -> None:\n try:\n msg = self.telegram_queue.get_nowait()\n await context.bot.send_message(chat_id=self.logging_chat_id, text=msg)\n except queue.Empty:\n pass",
"def _execute(self):\n LOG.info(\"Waiting for a... | [
"0.703519",
"0.7005076",
"0.6724646",
"0.65853786",
"0.6513948",
"0.6503922",
"0.64900374",
"0.63779444",
"0.6374579",
"0.6338678",
"0.63351077",
"0.62966096",
"0.62556356",
"0.62336075",
"0.6178579",
"0.61621654",
"0.6156895",
"0.61005133",
"0.60830873",
"0.6065437",
"0.6064... | 0.6188955 | 14 |
Returns row count of json object for waiting | def _get_validation_status(self) -> bool:
try:
for x in self.make_query("trust-anchors/statuses"):
if x["completedValidation"] is False:
# If anything has not been validated return false
return False
# All are validated. Return tru... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def count(self):\n self._fetch_if_needed()\n return len(self._result_cache.get('rows', []))",
"def count_rows(self):\n with self.conn:\n return len(self.select_all_rows())",
"def row_count(data):\n return int(arcpy.GetCount_management(data).getOutput(0))",
"def rowcount(sel... | [
"0.6802281",
"0.66612387",
"0.66511995",
"0.65624493",
"0.6489967",
"0.6470001",
"0.64694464",
"0.6371715",
"0.6351355",
"0.6314331",
"0.6314331",
"0.62972707",
"0.6276142",
"0.6232271",
"0.6232227",
"0.6218811",
"0.6213197",
"0.6193299",
"0.61728585",
"0.6153976",
"0.6128956... | 0.0 | -1 |
Returns the validity dict for the RPKI Validator to decode results I could have this as a class attribute but too messy I think. | def get_validity_dict() -> dict:
return {"VALID": ROA_Validity.VALID.value,
"UNKNOWN": ROA_Validity.UNKNOWN.value,
"INVALID_LENGTH": ROA_Validity.INVALID_BY_LENGTH.value,
"INVALID_ASN": ROA_Validity.INVALID_BY_ORIGIN.value} | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_validate(self) -> dict:\n response = self.rc.execute(\"GET\",\n self._get_uri(GET_VALIDATE_URI),\n headers=self.header,\n verify=self.verify)\n return response.json()",
"def getKrustyValidi... | [
"0.68762314",
"0.65788156",
"0.6511472",
"0.63827586",
"0.6343963",
"0.62334585",
"0.6198675",
"0.6181131",
"0.6175592",
"0.61523205",
"0.6139875",
"0.61204463",
"0.6046817",
"0.6017709",
"0.5970631",
"0.59177464",
"0.58760285",
"0.5810927",
"0.57986134",
"0.5791891",
"0.5789... | 0.7998628 | 0 |
Gets the headers for all url queries to the validator | def get_headers() -> dict:
return {"Connection": "keep-alive",
"Cache-Control": "max-age=0",
"Upgrade-Insecure-Requests": 1,
"User-Agent": ("Mozilla/5.0 (X11; Linux x86_64)"
" AppleWebKit/537.36 (KHTML, like Gecko) "
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _get_url_http_headers(self) -> Dict[str, str]:\n h = requests.head(self.url, allow_redirects=True)\n return h.headers",
"def getheaders(self):\n return self.urllib3_response.getheaders()",
"def getheaders(self):\n return self.urllib3_response.getheaders()",
"def getheaders(sel... | [
"0.7520884",
"0.6975295",
"0.6975295",
"0.6975295",
"0.6920222",
"0.6895884",
"0.6797614",
"0.67949516",
"0.6744045",
"0.6728178",
"0.6647769",
"0.6647769",
"0.6616169",
"0.65774935",
"0.6571051",
"0.6564471",
"0.6533954",
"0.6524701",
"0.6517692",
"0.6494233",
"0.6491621",
... | 0.644033 | 21 |
Installs RPKI validator with our configs. This might break in the future, but we need to do it this way for now to be able to do what we want with our own prefix origin table. | def install(**kwargs):
config_logging(kwargs.get("stream_level", logging.DEBUG),
kwargs.get("section"))
utils.delete_paths([RPKI_Validator_Wrapper.rpki_package_path,
RPKI_Validator_Wrapper.temp_install_path])
RPKI_Validator_Wrapper._download_v... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _start_validator(self):\n\n logging.info(\"Starting RPKI Validator\")\n utils.run_cmds((f\"cd {self.rpki_package_path} && \"\n f\"./{self.rpki_run_name}\"))",
"def _download_validator():\n\n rpki_url = (\"https://ftp.ripe.net/tools/rpki/validator3/beta/generic/\"\n... | [
"0.63697255",
"0.5358504",
"0.5253388",
"0.5171715",
"0.5128011",
"0.50729746",
"0.5013778",
"0.4977327",
"0.49645743",
"0.48654142",
"0.48506802",
"0.484606",
"0.47760716",
"0.46838087",
"0.4675308",
"0.4669454",
"0.46684492",
"0.46496302",
"0.4635433",
"0.46273148",
"0.4615... | 0.6363485 | 1 |
Downloads validator into proper location | def _download_validator():
rpki_url = ("https://ftp.ripe.net/tools/rpki/validator3/beta/generic/"
"rpki-validator-3-latest-dist.tar.gz")
arin_tal = ("https://www.arin.net/resources/manage/rpki/"
"arin-ripevalidator.tal")
# This is the java version they us... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _download(self):\n self._system.download(\"http://geant4.web.cern.ch/geant4/support/source/\" + self._tar_name)",
"def main():\n sandbox = create_sandbox()\n directory = download_package_to_sandbox(\n sandbox,\n 'https://pypi.python.org/packages/source/c/checkmyreqs/checkmyreqs-0.1... | [
"0.5852008",
"0.5642754",
"0.5526515",
"0.5338583",
"0.53289795",
"0.5327149",
"0.5300025",
"0.5300025",
"0.52865535",
"0.52240986",
"0.522238",
"0.51255095",
"0.51255095",
"0.51233405",
"0.5114986",
"0.5091691",
"0.5079647",
"0.5037147",
"0.5001166",
"0.49831185",
"0.4979095... | 0.7724067 | 0 |
Changes location of input ann for bgp preview file | def _change_file_hosted_location():
# Changes where the file is hosted
path = (f"{RPKI_Validator_Wrapper.rpki_package_path}conf"
"/application-defaults.properties")
prepend = "rpki.validator.bgp.ris.dump.urls="
replace = ("https://www.ris.ripe.net/dumps/riswhoisdump.IPv4... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def OnCustomPathChanged(self, event):\n self._annotations_path = self._file_dialog.value",
"def _get_ann_file(self):\n prefix = 'instances' if 'test' not in self.image_set else 'image_info'\n return os.path.join(self.data_path, 'annotations',\n prefix + '_' + self.... | [
"0.5407435",
"0.52599055",
"0.519646",
"0.51875174",
"0.5149553",
"0.5149553",
"0.5145319",
"0.5119233",
"0.507476",
"0.50581217",
"0.5036149",
"0.49735096",
"0.4945222",
"0.49176285",
"0.49105573",
"0.4907959",
"0.48954073",
"0.4869619",
"0.48695368",
"0.48660442",
"0.485979... | 0.50529623 | 10 |
Prob because of a proxy, but on our server this is necessary | def _change_server_address():
# Changes the server address
path = (f"{RPKI_Validator_Wrapper.rpki_package_path}conf"
"/application.properties")
prepend = "server.address="
replace = "localhost"
replace_with = "0.0.0.0"
utils.replace_line(path, prepend, re... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def is_bad_proxy(pip, url):\n try:\n res = requests.get(\n url,\n proxies={'http':pip},\n headers={'User-agent':'Mozilla/5.0 (X11; Ubuntu; Linux x86_64; rv:60.0) Gecko/20100101 Firefox/60.0'},\n timeout=10\n )\n except Exception as e:\n return ... | [
"0.6536286",
"0.6455781",
"0.6426632",
"0.632419",
"0.62789583",
"0.61999655",
"0.6165126",
"0.60038203",
"0.59746265",
"0.592634",
"0.58581245",
"0.58513933",
"0.58508027",
"0.5772282",
"0.5758716",
"0.5737422",
"0.57222337",
"0.57179177",
"0.57071245",
"0.5704665",
"0.56840... | 0.0 | -1 |
Configure rpki validator to run off absolute paths This is necessary due to script being called from elsewhere In other words not from inside the RPKI dir. | def _config_absolute_paths(path):
# Since I am calling the script from elsewhere these must be
# absolute paths
prepend = "rpki.validator.data.path="
replace = "."
# Must remove trailing backslash at the end
replace_with = RPKI_Validator_Wrapper.rpki_package_path[:-1]
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def validate_paths(self):\n # When we're started with a *.qemuboot.conf arg assume that image\n # artefacts are relative to that file, rather than in whatever\n # directory DEPLOY_DIR_IMAGE in the conf file points to.\n if self.qbconfload:\n imgdir = os.path.realpath(os.path.... | [
"0.56588614",
"0.54540795",
"0.5439257",
"0.5435881",
"0.5407553",
"0.53129953",
"0.5268416",
"0.52518916",
"0.5166516",
"0.5107923",
"0.5076477",
"0.5066876",
"0.5058214",
"0.50226915",
"0.49473757",
"0.49465066",
"0.49405462",
"0.49361816",
"0.4921926",
"0.48854834",
"0.486... | 0.71353936 | 0 |
Plots an xy graph at a certain specified wavelength onto the current axes. Keyword arguments are passed on to matplotlib. | def plot_wavelength_slice(self, offset, axes=None, style='imshow', **kwargs):
if axes is None:
axes = wcsaxes_compat.gca_wcs(self.axes_wcs, slices=("x", "y", offset))
data = self._choose_wavelength_slice(offset)
if data is None:
data = self._choose_wavelength_slice(0)
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def liveplot(x, y, xlim, ylim, title):\n plt.plot(x,y,'b.')\n plt.xlim(xlim)\n plt.ylim(ylim)\n plt.xlabel('North-South Axis')\n plt.ylabel('East-West Axis')\n plt.title(title)\n plt.show()",
"def plot_xyz():\n plt.subplot(3,1,1) # for x axis\n plt.title('x value v.s. time')\n plt.... | [
"0.68592244",
"0.6670617",
"0.6542144",
"0.65134996",
"0.6377094",
"0.62712955",
"0.62569517",
"0.6249064",
"0.6229926",
"0.61167306",
"0.60711694",
"0.60472214",
"0.60371035",
"0.60346633",
"0.60338837",
"0.5984468",
"0.59759843",
"0.5972779",
"0.59544533",
"0.5941109",
"0.5... | 0.0 | -1 |
Plots an xy graph at a certain specified wavelength onto the current axes. Keyword arguments are passed on to matplotlib. | def plot_x_slice(self, offset, axes=None, style='imshow', **kwargs):
if axes is None:
axes = wcsaxes_compat.gca_wcs(self.axes_wcs, slices=("x", offset, "y"))
data = self._choose_x_slice(offset)
if data is None:
data = self._choose_x_slice(0)
if style == 'imshow'... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def liveplot(x, y, xlim, ylim, title):\n plt.plot(x,y,'b.')\n plt.xlim(xlim)\n plt.ylim(ylim)\n plt.xlabel('North-South Axis')\n plt.ylabel('East-West Axis')\n plt.title(title)\n plt.show()",
"def plot_xyz():\n plt.subplot(3,1,1) # for x axis\n plt.title('x value v.s. time')\n plt.... | [
"0.68588203",
"0.6669191",
"0.6541369",
"0.6513319",
"0.63761437",
"0.6271679",
"0.62557006",
"0.62491953",
"0.62296474",
"0.6115451",
"0.6069608",
"0.6046171",
"0.6036858",
"0.6034111",
"0.60327625",
"0.5983629",
"0.59748536",
"0.59711856",
"0.59539765",
"0.5939472",
"0.5929... | 0.0 | -1 |
Plots an interactive visualization of this cube with a slider controlling the wavelength axis. Parameters other than data and wcs are passed to ImageAnimatorWCS, which in turn passes them to imshow. | def animate(self, *args, **kwargs):
i = ImageAnimatorWCS(self.data, wcs=self.axes_wcs, *args, **kwargs)
return i | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def Wave2DShow(ufield, ds, vel=None, vmin=None, vmax=None):\n #max index time and max index space\n maxt = np.shape(snapshots)[0]\n maxk = np.shape(snapshots)[1]\n maxi = np.shape(snapshots)[2] \n\n print \"vmin : \", vmin, \"vmax : \", vmax\n # space axis starting at 0 in x and z (using y coz... | [
"0.6150268",
"0.6055747",
"0.5920359",
"0.5777385",
"0.575942",
"0.57372284",
"0.57306933",
"0.57087874",
"0.5624707",
"0.5564459",
"0.5552165",
"0.5533102",
"0.55292475",
"0.5504385",
"0.5469229",
"0.5465655",
"0.546129",
"0.54549205",
"0.54419166",
"0.5441791",
"0.54239833"... | 0.5334662 | 27 |
Retrieves an xy slice at a wavelength specified by the cube's primary wavelength plus the given offset. | def _choose_wavelength_slice(self, offset):
if 'WAVE' not in self.axes_wcs.wcs.ctype:
raise cu.CubeError(2, "Spectral dimension not present")
if self.data.ndim == 4:
raise cu.CubeError(4, "Can only work with 3D cubes")
axis = -2 if self.axes_wcs.wcs.ctype[0] in ['TIME', ... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _choose_x_slice(self, offset):\n arr = None\n axis = 0\n length = self.data.shape[axis]\n if isinstance(offset, int) and offset >= 0 and offset < length:\n arr = self.data.take(offset, axis=axis)\n\n if isinstance(offset, u.Quantity):\n unit = self.axes_... | [
"0.6906233",
"0.60154533",
"0.57687914",
"0.56916517",
"0.5654022",
"0.55755776",
"0.55728334",
"0.55718255",
"0.5528963",
"0.5498326",
"0.54335445",
"0.5349252",
"0.53329015",
"0.5331418",
"0.53038037",
"0.52538073",
"0.52528626",
"0.52475715",
"0.5232891",
"0.52242994",
"0.... | 0.67115897 | 1 |
Retrieves a lambday slice at an x coordinate specified by the cube's primary wavelength plus the given offset. | def _choose_x_slice(self, offset):
arr = None
axis = 0
length = self.data.shape[axis]
if isinstance(offset, int) and offset >= 0 and offset < length:
arr = self.data.take(offset, axis=axis)
if isinstance(offset, u.Quantity):
unit = self.axes_wcs.wcs.cunit... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _choose_wavelength_slice(self, offset):\n if 'WAVE' not in self.axes_wcs.wcs.ctype:\n raise cu.CubeError(2, \"Spectral dimension not present\")\n if self.data.ndim == 4:\n raise cu.CubeError(4, \"Can only work with 3D cubes\")\n\n axis = -2 if self.axes_wcs.wcs.ctype[... | [
"0.63117456",
"0.5793032",
"0.5629141",
"0.5089525",
"0.5078301",
"0.506176",
"0.50505126",
"0.5043352",
"0.49999565",
"0.49748117",
"0.4926123",
"0.49144813",
"0.49112678",
"0.4907331",
"0.48990658",
"0.48967353",
"0.4890172",
"0.4886623",
"0.48143712",
"0.4807352",
"0.47636... | 0.61754596 | 1 |
Instantiate a new instance of this class using given data. | def _new_instance(cls, data, wcs, errors=None, **kwargs):
return cls(data, wcs, errors=errors, **kwargs) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def from_data(cls, data):\n return object.__new__(cls)",
"def from_data(cls,data):\n\n new_object = cls() # Only this line needs to be updated\n new_object.data = data\n\n return new_object",
"def create(self, cls, data=None):\n return cls(self, initial_data=data)",
"def fr... | [
"0.8485502",
"0.82323295",
"0.8037924",
"0.8033954",
"0.78525287",
"0.7681436",
"0.76791143",
"0.75968486",
"0.7346645",
"0.7328685",
"0.73233855",
"0.7298864",
"0.7253603",
"0.7244204",
"0.7244204",
"0.7244204",
"0.7244204",
"0.72342247",
"0.71200186",
"0.7111342",
"0.704766... | 0.71335787 | 18 |
Converts a given frequency chunk to a SunPy Map. Extra parameters are passed on to Map. | def slice_to_map(self, chunk, snd_dim=None, *args, **kwargs):
if self.axes_wcs.wcs.ctype[1] == 'WAVE' and self.data.ndim == 3:
error = "Cannot construct a map with only one spatial dimension"
raise cu.CubeError(3, error)
if isinstance(chunk, tuple):
item = slice(cu.pi... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _createMap(self):\n width = self.map_size[0] * self.chunk_size\n height = self.map_size[1] * self.chunk_size\n map_array = np.zeros((height, width), dtype=float)\n chunks = {}\n clist = []\n for i in range(0, self.map_size[0]*self.map_size[1]):\n chunks[i+1]... | [
"0.57270765",
"0.5564925",
"0.5475267",
"0.54156667",
"0.54104096",
"0.5340992",
"0.52815837",
"0.51907945",
"0.51874447",
"0.51529014",
"0.5140967",
"0.51343143",
"0.50851405",
"0.5076608",
"0.5042034",
"0.5038399",
"0.5007617",
"0.5004075",
"0.4992073",
"0.49909553",
"0.498... | 0.6020252 | 0 |
For a timelambday cube, returns a lightcurve with curves at the specified wavelength and given ycoordinate. If no y is given, all of them will be used (meaning the lightcurve object could contain more than one timecurve.) | def slice_to_lightcurve(self, wavelength, y_coord=None, x_coord=None):
if self.axes_wcs.wcs.ctype[0] not in ['TIME', 'UTC']:
raise cu.CubeError(1,
'Cannot create a lightcurve with no time axis')
if self.axes_wcs.wcs.ctype[1] != 'WAVE':
raise cu.Cube... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def lightCurve(self, time, filters):\n\n lcMags = np.zeros(time.size, dtype=float)\n\n rise = np.where(time <= self.peakTime)\n lcMags[rise] += self.riseSlope*time[rise]-self.riseSlope*self.peakTime\n decline = np.where(time > self.peakTime)\n lcMags[decline] += self.declineSlope... | [
"0.5951895",
"0.5928167",
"0.5583655",
"0.55513257",
"0.54969233",
"0.5486457",
"0.5382974",
"0.5276939",
"0.5214253",
"0.5212705",
"0.51789206",
"0.5082815",
"0.50349635",
"0.49946722",
"0.4969627",
"0.49492365",
"0.4941575",
"0.49127588",
"0.4905105",
"0.490314",
"0.4884597... | 0.61594796 | 0 |
For a cube containing a spectral dimension, returns a sunpy spectrum. The given coordinates represent which values to take. If they are None, then the corresponding axis is summed. | def slice_to_spectrum(self, *coords, **kwargs):
if 'WAVE' not in self.axes_wcs.wcs.ctype:
raise cu.CubeError(2, 'Spectral axis needed to create a spectrum')
axis = -1 if self.axes_wcs.wcs.ctype[0] == 'WAVE' else -2
pixels = [cu.pixelize(coord, self.axes_wcs, axis) for coord in coords... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def convert_to_spectral_cube(self):\n if self.data.ndim == 4:\n raise cu.CubeError(4, \"Too many dimensions: Can only convert a \" +\n \"3D cube. Slice the cube before converting\")\n if 'WAVE' not in self.axes_wcs.wcs.ctype:\n raise cu.CubeError(2,... | [
"0.6098314",
"0.57695895",
"0.56967276",
"0.5517648",
"0.5394993",
"0.5346096",
"0.5340599",
"0.52352476",
"0.5234346",
"0.52302986",
"0.52094436",
"0.52033246",
"0.5161801",
"0.5134656",
"0.50857544",
"0.5084157",
"0.50615275",
"0.5031639",
"0.49863473",
"0.49710125",
"0.496... | 0.62595874 | 0 |
For a timelambday cube, given a ycoordinate, returns a sunpy spectrogram. Keyword arguments are passed on to Spectrogram's __init__. | def slice_to_spectrogram(self, y_coord, x_coord=None, **kwargs):
if self.axes_wcs.wcs.ctype[0] not in ['TIME', 'UTC']:
raise cu.CubeError(1,
'Cannot create a spectrogram with no time axis')
if self.axes_wcs.wcs.ctype[1] != 'WAVE':
raise cu.CubeError... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def mel_spectrogram(self, y):\n # assert(torch.min(y.data) >= -1)\n # assert(torch.max(y.data) <= 1)\n\n magnitudes, phases = self.stft_fn.transform(y)\n # magnitudes = magnitudes.data\n mel_output = torch.matmul(self.mel_basis, magnitudes)\n mel_output = self.spectral_nor... | [
"0.62373495",
"0.61111325",
"0.5878095",
"0.5321949",
"0.52246",
"0.52145845",
"0.51144654",
"0.50932705",
"0.5055656",
"0.50293887",
"0.50188696",
"0.50037694",
"0.49115393",
"0.4873337",
"0.4850232",
"0.48383042",
"0.48147768",
"0.4789717",
"0.4733066",
"0.4707515",
"0.4701... | 0.6674686 | 0 |
For a hypercube, return a 3D cube that has been cut along the given axis and with data corresponding to the given chunk. | def slice_to_cube(self, axis, chunk, **kwargs):
if self.data.ndim == 3:
raise cu.CubeError(4, 'Can only slice a hypercube into a cube')
item = [slice(None, None, None) for _ in range(4)]
if isinstance(chunk, tuple):
if cu.iter_isinstance(chunk, (u.Quantity, u.Quantity)):... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def explode_along_axis(self, axis):\n # If axis is -ve then calculate the axis from the length of the dimensions of one cube\n if axis < 0:\n axis = len(self.dimensions) + axis\n # To store the resultant cube\n result_cubes = []\n # All slices are initially initialised... | [
"0.63870597",
"0.61239403",
"0.60539335",
"0.5832195",
"0.57542986",
"0.56327647",
"0.559867",
"0.5501042",
"0.5500518",
"0.5481983",
"0.5481307",
"0.54722977",
"0.5436329",
"0.53984386",
"0.53860784",
"0.53848904",
"0.53785336",
"0.5359201",
"0.5354345",
"0.5327404",
"0.5268... | 0.83219737 | 0 |
Converts this cube into a SpectralCube. It will only work if the cube has exactly three dimensions and one of those is a spectral axis. | def convert_to_spectral_cube(self):
if self.data.ndim == 4:
raise cu.CubeError(4, "Too many dimensions: Can only convert a " +
"3D cube. Slice the cube before converting")
if 'WAVE' not in self.axes_wcs.wcs.ctype:
raise cu.CubeError(2, 'Spectral axi... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def spectral_model(self):\n d = self.data\n spec_type = d['SpectrumType'].strip()\n pars, errs = {}, {}\n pars['amplitude'] = d['Flux_Density']\n errs['amplitude'] = d['Unc_Flux_Density']\n pars['reference'] = d['Pivot_Energy']\n\n if spec_type == 'PowerLaw':\n ... | [
"0.6274869",
"0.6003347",
"0.5845092",
"0.5763128",
"0.56499904",
"0.55344087",
"0.55215806",
"0.5233117",
"0.5228521",
"0.5198386",
"0.5195983",
"0.51448613",
"0.51295257",
"0.5123832",
"0.5117463",
"0.51086575",
"0.50924385",
"0.50752395",
"0.50532764",
"0.50532764",
"0.505... | 0.8686489 | 0 |
Returns a numpy array containing the time values for the cube's time dimension, as well as the unit used. | def time_axis(self):
if self.axes_wcs.wcs.ctype[0] not in ['TIME', 'UTC']:
raise cu.CubeError(1, 'No time axis present')
delta = self.axes_wcs.wcs.cdelt[0]
crpix = self.axes_wcs.wcs.crpix[0]
crval = self.axes_wcs.wcs.crval[0]
start = crval - crpix * delta
stop... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def time(self):\n return self.time_array",
"def time_axis_array(self):\n return self._time_axis.get_array()",
"def arr_time(self):\n return self._arr_time",
"def times(self):\n if self._times is None:\n self._times = np.zeros((self.ntimestep), dtype=np.float64)\n ... | [
"0.7211374",
"0.6856966",
"0.68256146",
"0.67285633",
"0.65972865",
"0.6441097",
"0.63960433",
"0.6338288",
"0.6300424",
"0.6298656",
"0.6298656",
"0.62866175",
"0.62780577",
"0.62295645",
"0.6061472",
"0.6057796",
"0.6039089",
"0.60030895",
"0.5996386",
"0.59960365",
"0.5991... | 0.6944582 | 1 |
Returns a numpy array containing the frequency values for the cube's spectral dimension, as well as the axis's unit. | def wavelength_axis(self):
if 'WAVE' not in self.axes_wcs.wcs.ctype:
raise cu.CubeError(2,
'No energy (wavelength, frequency) axis found')
axis = 0 if self.axes_wcs.wcs.ctype[0] == 'WAVE' else 1
delta = self.axes_wcs.wcs.cdelt[axis]
crpix = self... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def frequencies(self):\r\n\r\n self.method['Fs'] = self.method.get('Fs', self.input.sampling_rate)\r\n NFFT = self.method.get('NFFT', 64)\r\n Fs = self.method.get('Fs')\r\n freqs = tsu.get_freqs(Fs, NFFT)\r\n lb_idx, ub_idx = tsu.get_bounds(freqs, self.lb, self.ub)\r\n\r\n ... | [
"0.6470279",
"0.6461034",
"0.64269227",
"0.6334639",
"0.6251372",
"0.61910397",
"0.59662837",
"0.5920204",
"0.5918302",
"0.59053004",
"0.5890902",
"0.5809529",
"0.57999116",
"0.57967234",
"0.5774496",
"0.57175756",
"0.57160854",
"0.5687078",
"0.5675256",
"0.5670857",
"0.56388... | 0.55794877 | 25 |
Returns whether the wcs system and the array are wellaligned. | def _array_is_aligned(self):
rot_matrix = self.axes_wcs.wcs.pc
return np.allclose(rot_matrix, np.eye(self.axes_wcs.wcs.naxis)) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def isaligned(a: np.ndarray, alignment: int) -> bool:\n return (a.ctypes.data % alignment) == 0",
"def is_aligned(self):\n\n return self._bits == 0",
"def has_wcs(self):\n if self.header is None:\n return False\n\n required = 'CRPIX,CRVAL,CTYPE'.split(',')\n keywords =... | [
"0.6622194",
"0.66116005",
"0.64189285",
"0.629337",
"0.6231566",
"0.62093145",
"0.61557496",
"0.61207116",
"0.5808725",
"0.57705253",
"0.5653776",
"0.5611747",
"0.5607932",
"0.5607731",
"0.55909234",
"0.5550369",
"0.5533875",
"0.55202824",
"0.54235834",
"0.5402072",
"0.53951... | 0.74039537 | 0 |
Instantiate a new instance of this class using given data. | def _new_instance(cls, data_list, meta=None, common_axis=None):
return cls(data_list, meta=meta, common_axis=common_axis) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def from_data(cls, data):\n return object.__new__(cls)",
"def from_data(cls,data):\n\n new_object = cls() # Only this line needs to be updated\n new_object.data = data\n\n return new_object",
"def create(self, cls, data=None):\n return cls(self, initial_data=data)",
"def fr... | [
"0.8487179",
"0.8234369",
"0.8037686",
"0.80359334",
"0.78548235",
"0.7683154",
"0.7678993",
"0.7598695",
"0.7346941",
"0.73307866",
"0.7325395",
"0.7300296",
"0.725587",
"0.72462845",
"0.72462845",
"0.72462845",
"0.72462845",
"0.72362065",
"0.7133408",
"0.71174616",
"0.71122... | 0.6748535 | 30 |
Method to slice the cubesequence instance as a single cube Example >>> Say we have three Cubes each cube has common_axis=0 is time and shape=(3,3,3) >>> data_list = [cubeA, cubeB, cubeC] >>> cs = CubeSequence(data_list, meta=None, common_axis=0) >>> return zeroth time slice of cubeB in via normal CubeSequence indexing. | def index_as_cube(self):
return _IndexAsCubeSlicer(self) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def cube_like_tuple_item_to_sequence_items(item, common_axis, common_axis_lengths, n_cube_dims):\n if not hasattr(item, \"__len__\"):\n raise TypeError(\"item must be an iterable of slices and/or ints.\")\n if len(item) <= common_axis:\n raise ValueError(\"item must be include an entry for the ... | [
"0.6331354",
"0.62150717",
"0.60088134",
"0.5788159",
"0.5405186",
"0.52887505",
"0.52854425",
"0.526346",
"0.52061605",
"0.512507",
"0.51214343",
"0.5059634",
"0.50593454",
"0.5031299",
"0.50106156",
"0.5003349",
"0.49384144",
"0.493823",
"0.49368778",
"0.49356455",
"0.49280... | 0.5719029 | 4 |
Plots an xy graph at a certain specified wavelength onto the current axes. Keyword arguments are passed on to matplotlib. | def plot_x_slice(self, offset, **kwargs):
cumul_cube_lengths = np.cumsum(np.array([c.shape[self.common_axis]
for c in self.data]))
sequence_index, cube_index = cu._convert_cube_like_index_to_sequence_indices(
offset, cumul_cube_lengths)
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def liveplot(x, y, xlim, ylim, title):\n plt.plot(x,y,'b.')\n plt.xlim(xlim)\n plt.ylim(ylim)\n plt.xlabel('North-South Axis')\n plt.ylabel('East-West Axis')\n plt.title(title)\n plt.show()",
"def plot_xyz():\n plt.subplot(3,1,1) # for x axis\n plt.title('x value v.s. time')\n plt.... | [
"0.68588203",
"0.6669191",
"0.6541369",
"0.6513319",
"0.63761437",
"0.6271679",
"0.62557006",
"0.62491953",
"0.62296474",
"0.6115451",
"0.6069608",
"0.6046171",
"0.6036858",
"0.6034111",
"0.60327625",
"0.5983629",
"0.59748536",
"0.59711856",
"0.59539765",
"0.5939472",
"0.5929... | 0.0 | -1 |
Plots an xy graph at a certain specified wavelength onto the current axes. Keyword arguments are passed on to matplotlib. | def plot_wavelength_slice(self, offset, **kwargs):
cumul_cube_lengths = np.cumsum(np.array([c.shape[self.common_axis]
for c in self.data]))
sequence_index, cube_index = cu._convert_cube_like_index_to_sequence_indices(
offset, cumul_cube_length... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def liveplot(x, y, xlim, ylim, title):\n plt.plot(x,y,'b.')\n plt.xlim(xlim)\n plt.ylim(ylim)\n plt.xlabel('North-South Axis')\n plt.ylabel('East-West Axis')\n plt.title(title)\n plt.show()",
"def plot_xyz():\n plt.subplot(3,1,1) # for x axis\n plt.title('x value v.s. time')\n plt.... | [
"0.68592244",
"0.6670617",
"0.6542144",
"0.65134996",
"0.6377094",
"0.62712955",
"0.62569517",
"0.6249064",
"0.6229926",
"0.61167306",
"0.60711694",
"0.60472214",
"0.60371035",
"0.60346633",
"0.60338837",
"0.5984468",
"0.59759843",
"0.5972779",
"0.59544533",
"0.5941109",
"0.5... | 0.0 | -1 |
parse case excel file. | def manual_case_parser(self):
data = self.excel_parser()
result = self.process_module_field(data)
self.add_class_name_field(result)
self.process_multi_step_field(result)
return result | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_parse_sample_sheet(self):\n pass",
"def parse_ra():\r\n fname = 'parse/File1.xlsx'\r\n sheet_name = 'Sheet1'\r\n\r\n ra_sheet = get_sheet(fname, sheet_name)\r\n return parse_sheet(ra_sheet)",
"def parse_xlsx(filename):\n from openpyxl import load_workbook\n\n workbook = load_w... | [
"0.66888124",
"0.6109369",
"0.61021197",
"0.60966265",
"0.5916426",
"0.589535",
"0.58326924",
"0.5774381",
"0.56844836",
"0.5633092",
"0.5630392",
"0.56159174",
"0.56018525",
"0.55881256",
"0.55868655",
"0.55625945",
"0.55516446",
"0.55497164",
"0.5522616",
"0.55121005",
"0.5... | 0.67918974 | 0 |
Process the "Module" filed. | def process_module_field(self, data):
result = list()
case_info = data['values']
# add Module filed
for i, v in enumerate(case_info):
if not v['Module']:
v['Module'] = case_info[i - 1]['Module']
else:
module = tuple(self.parser.sp... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def process_module_list(self, modules):",
"def visit_Module(self, node):\n for item in node.body:\n self.visit(item)",
"def visit_Module(self, node):\n for item in node.body:\n self.visit(item)",
"def exec_module(self, module):\n pass",
"def on_module_event(self, ... | [
"0.73333037",
"0.6903211",
"0.6903211",
"0.6841748",
"0.6787638",
"0.6626777",
"0.6554846",
"0.64963454",
"0.6429045",
"0.6391386",
"0.63664407",
"0.63107514",
"0.6293941",
"0.6276409",
"0.6265793",
"0.6207045",
"0.61946833",
"0.61454856",
"0.61390555",
"0.6034528",
"0.603106... | 0.6489552 | 8 |
Add the "ClassName" filed. | def add_class_name_field(data):
for case in data:
case_id = case['No.']
filed_list = case_id.split('_')
filed_list = list(map(lambda x: x.title(), filed_list))
case['ClassName'] = ''.join(filed_list) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def setClassName(self,whichDir):\n self.className = whichDir\n self.setClassMap({whichDir : 1})",
"def addClassRef(clazz):\n\n global h_classes\n header = \"class %s;\" % clazz\n if not header in h_classes:\n h_classes.append(header)",
"def add_class(self, name):\n if name ... | [
"0.6673873",
"0.65873694",
"0.65540683",
"0.65310895",
"0.62807566",
"0.61844677",
"0.61496955",
"0.61109734",
"0.60883236",
"0.5851665",
"0.5794981",
"0.57527643",
"0.57015514",
"0.56917053",
"0.5677711",
"0.5670707",
"0.566091",
"0.56086993",
"0.55906165",
"0.55896807",
"0.... | 0.69511896 | 0 |
Process the multi_step filed. | def multi_step_field(self, info):
result = list()
for i, v in enumerate(self.parser.split(info)):
if re.search(r'^\d+', v):
result.append(v)
else:
result[-1] += ' %s' % v
return result | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def do_step(self) -> None:",
"def process_step(self, request, step, form):\n pass",
"def _step(self):\n pass",
"def process_steps(self, df, **kwargs):\n pass",
"def step(self, **kwargs):\n pass",
"def _step(self) -> None:",
"def perform_step(self) -> None:\n pass",
... | [
"0.6953273",
"0.6896622",
"0.6519482",
"0.6498906",
"0.6467285",
"0.64277387",
"0.63524014",
"0.62364155",
"0.61352557",
"0.61075705",
"0.6049684",
"0.5984105",
"0.5969542",
"0.59558064",
"0.5954331",
"0.5935271",
"0.5926765",
"0.58631474",
"0.58631474",
"0.5861994",
"0.58472... | 0.0 | -1 |
Sample from the provided binary quadratic model. | def sample(self, bqm, chain_strength=1.0, **parameters):
# solve the problem on the child system
child = self.child
# apply the embedding to the given problem to map it to the child sampler
__, target_edgelist, target_adjacency = child.structure
# add self-loops to edgelist to... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def sample(self,noise,s):\n rhs=self.prior.sqrtM*noise\n self.prior.Msolver.solve(s,rhs)",
"def sample(self, bqm, fixed_variables=None, **parameters):\n return super().sample(bqm, fixed_variables=fixed_variables, **parameters)",
"def sample(self, bqm, **parameters):\n return self.ch... | [
"0.5944321",
"0.58827317",
"0.57604975",
"0.56414646",
"0.5592896",
"0.5581259",
"0.55090886",
"0.54022413",
"0.5325893",
"0.5319684",
"0.53083277",
"0.53047055",
"0.5290728",
"0.52858907",
"0.5271392",
"0.5254466",
"0.52531403",
"0.52415967",
"0.52349377",
"0.5205364",
"0.52... | 0.4778152 | 97 |
Sample from the provided binary quadratic model. | def sample(self, bqm, chain_strength=1.0, **parameters):
# solve the problem on the child system
child = self.child
# apply the embedding to the given problem to map it to the child sampler
__, __, target_adjacency = child.structure
# get the embedding
embedding = self... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def sample(self,noise,s):\n rhs=self.prior.sqrtM*noise\n self.prior.Msolver.solve(s,rhs)",
"def sample(self, bqm, fixed_variables=None, **parameters):\n return super().sample(bqm, fixed_variables=fixed_variables, **parameters)",
"def sample(self, bqm, **parameters):\n return self.ch... | [
"0.5944321",
"0.58827317",
"0.57604975",
"0.56414646",
"0.5592896",
"0.5581259",
"0.55090886",
"0.54022413",
"0.5325893",
"0.5319684",
"0.53083277",
"0.53047055",
"0.5290728",
"0.52858907",
"0.5271392",
"0.5254466",
"0.52531403",
"0.52415967",
"0.52349377",
"0.5205364",
"0.52... | 0.0 | -1 |
determine from an adjacency the list of edges if (u, v) in edges, then (v, u) should not be | def _adjacency_to_edges(adjacency):
edges = set()
for u in adjacency:
for v in adjacency[u]:
try:
edge = (u, v) if u <= v else (v, u)
except TypeError:
# Py3 does not allow sorting of unlike types
if (v, u) in edges:
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def isUndirected(G):\n for v in G:\n if v in G[v]:\n return False\n for w in G[v]:\n if v not in G[w]:\n return False\n return True",
"def de2ue(edges):\n return set(de for de in edges if tuple(reversed(de)) in edges)",
"def test_adjacent_none(graph_w... | [
"0.70223045",
"0.67823124",
"0.6704551",
"0.663785",
"0.65423083",
"0.65288144",
"0.6453709",
"0.6431163",
"0.64235234",
"0.63841563",
"0.6299269",
"0.6283511",
"0.6264669",
"0.6231787",
"0.6221642",
"0.6220229",
"0.6163761",
"0.6078412",
"0.60337824",
"0.60281676",
"0.602758... | 0.61262304 | 17 |
Validation of the implementaiton of periodic angle axis in Magnetic (MagFEMM) and Force (ForceMT) modules | def test_FEMM_periodicity_time_no_periodicity_a():
SPMSM_015 = load(join(DATA_DIR, "Machine", "SPMSM_015.json"))
assert SPMSM_015.comp_periodicity() == (9, False, 9, True)
simu = Simu1(name="test_FEMM_periodicity_time_no_periodicity_a", machine=SPMSM_015)
# Definition of the enforced output of the e... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_FEMM_periodicity_angle():\n\n SPMSM_015 = load(join(DATA_DIR, \"Machine\", \"SPMSM_015.json\"))\n\n assert SPMSM_015.comp_periodicity() == (9, False, 9, True)\n\n simu = Simu1(name=\"test_FEMM_periodicity_angle\", machine=SPMSM_015)\n\n # Definition of the enforced output of the electrical mod... | [
"0.6782517",
"0.60290766",
"0.6012614",
"0.58263516",
"0.5755218",
"0.56247103",
"0.5583029",
"0.5559526",
"0.55149376",
"0.54994637",
"0.5498538",
"0.54675615",
"0.5454319",
"0.5441296",
"0.54299664",
"0.5414825",
"0.54081666",
"0.53792536",
"0.53736025",
"0.53621024",
"0.53... | 0.56348616 | 5 |
Validation of the implementaiton of periodic angle axis in Magnetic (MagFEMM) and Force (ForceMT) modules | def test_FEMM_periodicity_time():
SPMSM_015 = load(join(DATA_DIR, "Machine", "SPMSM_015.json"))
assert SPMSM_015.comp_periodicity() == (9, False, 9, True)
simu = Simu1(name="test_FEMM_periodicity_time", machine=SPMSM_015)
# Definition of the enforced output of the electrical module
I0_rms = 250 ... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_FEMM_periodicity_angle():\n\n SPMSM_015 = load(join(DATA_DIR, \"Machine\", \"SPMSM_015.json\"))\n\n assert SPMSM_015.comp_periodicity() == (9, False, 9, True)\n\n simu = Simu1(name=\"test_FEMM_periodicity_angle\", machine=SPMSM_015)\n\n # Definition of the enforced output of the electrical mod... | [
"0.67807055",
"0.6025987",
"0.6009556",
"0.582327",
"0.57532835",
"0.5632618",
"0.5626842",
"0.5582642",
"0.55583394",
"0.55183727",
"0.5498292",
"0.5465175",
"0.54535043",
"0.54445416",
"0.54298043",
"0.54143214",
"0.5408169",
"0.53782576",
"0.53738904",
"0.53651005",
"0.535... | 0.54969805 | 11 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.