self.N:\r\n print('Bad Parameter: Reported winner tally')\r\n \r\n if len(self.round_sched) < 1 or not self.check_inc_sched(self.round_sched):\r\n print('Bad Parameter: Round Schedule')\r\n\r\n if self.alpha <= 0 or self.alpha >= .5:\r\n print('Bad Parameter: Alpha')","def test_build_defaults(self, args, expected):\n sch = scheme.Scheme(*args)\n defaults = sch.build_defaults()\n\n assert defaults == expected","def checkParameters(self):\n EDVerbose.DEBUG(\"EDPluginControlAbsorptionv0_1.checkParameters\")\n self.checkMandatoryParameters(self.getDataInput(), \"Data Input is None\")","def checkParameters(self):\n self.DEBUG(\"EDPluginExecDatGnomv1_0.checkParameters\")\n self.checkMandatoryParameters(self.dataInput, \"Data Input is None\")\n self.checkMandatoryParameters(self.dataInput.inputCurve, \"No input Curve file provided\")","def validate_parameters(self):\n\n flag = True\n warnings = \"\"\n # Check radius\n r = self.parameters.get('r', 0)\n if type(r) not in [int, float]:\n flag = False\n warnings += \"Radius r must be a float value\\n\"\n else:\n if r <= 0:\n flag = False\n warnings += \"Radius r must be higher than 0\\n\"\n # Check if is full penetrating\n op = self.parameters.get('full', False)\n\n if not op:\n # Check observation well length\n if 'd' in self.parameters and 'l' in self.parameters:\n d = self.parameters.get('d', -1)\n l = self.parameters.get('l', -1)\n if type(l) not in [int, float]:\n flag = False\n warnings += \"Depth of well bottom must be a float value\\n\"\n else:\n if l < 0:\n flag = False\n warnings += \"Depth l must be higher than 0\\n\"\n if type(d) not in [int, float]:\n flag = False\n warnings += \"Depth of well screen must be a float value\\n\"\n else:\n if d < 0 or d > l:\n flag = False\n warnings += \"Depth d must be in range 0 <= d <= l\\n\"\n # Check piezometer depth\n elif 'z' in self.parameters:\n z = self.parameters.get('z', -1)\n if type(z) not in [int, float]:\n flag = False\n warnings += \"Depth of piezometer must be a float value\\n\"\n else:\n if z < 0:\n flag = False\n warnings += \"Depth z must be higher than 0\\n\"\n else:\n flag = False\n warnings += \"Well don't contain well depth attributes\\n\"\n return(flag, warnings) # End Function","def test_kw_args_with_defaults():\n assert arguments.fun_opt_kw_params() == ('blue', 'red', 'yellow', 'orange')","def _check_vals(self):\n\n try:\n self.is_set = True\n self.pack()\n except Exception as err:\n # Set default values again\n raise ValueError(\"Invalid arguments. Could not packed since: {}\".format(err))\n self.__init__()","def test_default_parameters(self):\n\n assert self.test_shape.rotation_angle == 360","def checkParameters(self):\n self.DEBUG(\"EDPluginExecDatcmpv2_0.checkParameters\")\n self.checkMandatoryParameters(self.getDataInput(), \"Data Input is None\")\n self.checkMandatoryParameters(self.getDataInput().inputCurve, \"No input 1D curves file provided\")","def _check_valid_basic(self, get_params):\n try:\n if get_params(self.variable):\n return self.default\n except: # noqa e722\n pass\n return not self.default","def _check_params(self):\n pass","def test_build_defaults_failure(self, args):\n sch = scheme.Scheme(*args)\n with pytest.raises(errors.InvalidSchemeError):\n sch.build_defaults()","def assertCorrConfig() :\n # eventually we will want a wait on C3Gmax8 or C3GMax24 astrobands \n if ( subarrayOwnsCorrelator(subarrayNo,CORR_WIDEBAND) or subarrayOwnsCorrelator(subarrayNo,CORR_SPECTRAL) ) :\n print \"This command is currently a no-op for non-C3G correlators\"\n return\n if ( subarrayOwnsNoCorrelator( subarrayNo ) ) :\n print \"You need to add a C3G correlator to use this command!\"\n return\n s.assertCorrelatorConfiguration()","def check_invalid_args_general(config):\n # Not mathematically correct, but might be required if prior is not\n # appropriate.\n if hasattr(config, 'kl_scale') and config.kl_scale != 1.0:\n warnings.warn('Prior matching term will be scaled by %f.'\n % config.kl_scale)\n\n if hasattr(config, 'store_final_model') and \\\n hasattr(config, 'train_from_scratch') and \\\n config.store_final_model and config.train_from_scratch:\n warnings.warn('Note, when training from scratch, the final model is ' +\n 'only trained on the last task!')","def checkParameters(self):\n EDVerbose.DEBUG(\"EDPluginExecGnomv0_1.checkParameters\")\n self.checkMandatoryParameters(self.dataInput, \"Data Input is None\")\n self.checkMandatoryParameters(self.dataInput.experimentalDataQ, \"Scattering vector values are missing\")\n self.checkMandatoryParameters(self.dataInput.experimentalDataValues, \"Experimental intensity values are missing\")","def f_check_adr_parameters_correctness(dict):\n\n if int(dict[\"operation_mode_num\"]) not in (0, 1, 2, 3, 4, 5, 6):\n print('\\n Error!!! Operation mode is wrong!\\n')\n sys.exit(' Program stopped!')\n\n if int(dict[\"FFT_size_samples\"]) not in (2048, 4096, 8192, 16384, 32768):\n print('\\n Error!!! FFT size is wrong!\\n')\n sys.exit(' Program stopped!')\n\n if int(dict[\"spectra_averaging\"]) < 16 or int(dict[\"spectra_averaging\"]) > 32768:\n print('\\n Error!!! Spectra averaging number is wrong!\\n')\n sys.exit(' Program stopped!')\n\n if int(dict[\"start_line_freq\"]) not in (0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16): # 0 … (SFFT-1024)/1024\n print('\\n Error!!! Start frequency line is wrong!\\n')\n sys.exit(' Program stopped!')\n\n if int(dict[\"width_line_freq\"]) not in (0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16):\n print('\\n Error!!! Frequency width line is wrong!\\n')\n sys.exit(' Program stopped!')\n\n if int(dict[\"width_line_freq\"]) > ((int(dict[\"FFT_size_samples\"]) - int(dict[\"start_line_freq\"]) * 1024) / 1024): # 1 … (SFFT-SLINE*1024)/1024\n print('\\n Error!!! Frequency width is bigger than FFT size allows!\\n')\n sys.exit(' Program stopped!')\n\n if int(dict[\"clock_source\"]) not in (0, 1):\n print('\\n Error!!! Clock source is wrong!\\n')\n sys.exit(' Program stopped!')\n\n if int(dict[\"sum_diff_mode_num\"]) not in (0, 1):\n print('\\n Error!!! Sum-diff mode is wrong!\\n')\n sys.exit(' Program stopped!')\n\n if int(dict[\"data_file_size\"]) < -1 or int(dict[\"data_file_size\"]) > 4096:\n print('\\n Error!!! File size value is wrong!\\n')\n sys.exit(' Program stopped!')\n\n '''\n if (int(dict[\"chan_diff_delay\"]) < 0 or int(parameters_dict[\"chan_diff_dalay\"]) > 1024):\n print('\\n Error!!! Channel difference delay is wrong!\\n')\n sys.exit(' Program stopped!')\n '''\n\n # print('\\n ADR parameters from file are correct!\\n')\n\n return dict","def checkNeededParams(self):\n for clp,value in self.neededParamsNames.items():\n if value[0] not in self.neededParams:\n print >> sys.stderr, clp+\" is a mandatory parameter \"\n self.printUsage()\n sys.exit(1)","def test_default_argument_null(self):\n @converters.wrap\n def inner_test(param: int = 14):\n \"\"\"Make sure the default was used.\"\"\"\n self.assertEqual(param, 14)\n inner_test(param=None)","def test__init__bound_and_default(self, extras, raises):\n kwargs = dict(\n kind=POSITIONAL_ONLY,\n bound=True,\n **extras,\n )\n\n if not raises:\n assert FParameter(**kwargs).bound\n return\n\n with pytest.raises(TypeError) as excinfo:\n FParameter(**kwargs)\n assert excinfo.value.args[0] == \\\n 'bound arguments must have a default value'","def check_conv_config(self):\n conv_config = self.conv_config\n config = self.base_model.config\n\n new_params_1 = [k for k in conv_config.keys() if not k.endswith(\"_rate_multiplier\")]\n new_params_2 = []\n\n for k, v in conv_config.items():\n if isinstance(v, dict):\n for p in v[\"params\"]:\n if p not in new_params_2:\n new_params_2.append(p)\n\n # order doesn't matter\n assert set(new_params_1) == set(new_params_2), \"New parameters are not consistent, double check conv_config...\"\n\n # also check if new params are in config or not\n missing_params = \"\"\n for new_p in new_params_1:\n if not config.get(new_p, False):\n missing_params += f\"{new_p}, \"\n\n # remove the period if there are missing parameters..\n if missing_params != \"\":\n missing_params = missing_params[:-2]\n\n assert missing_params == \"\", f\"{missing_params} are missing in the config\"","def check_required(self):\n for argument in self.arguments:\n if argument.required:\n raise ArgumentRequiredError(argument, self.tagname)\n else:\n self.kwargs[argument.name] = argument.get_default()","def check_common_defaults(cfg):\n assert cfg.cluster.name.startswith('elasticblast') # Needed to run ElasticBLAST on NCBI AWS account see SYS-360205\n if cfg.cloud_provider.cloud == CSP.GCP:\n assert cfg.cluster.machine_type == constants.ELB_DFLT_GCP_MACHINE_TYPE\n else:\n assert cfg.cluster.machine_type == constants.ELB_DFLT_AWS_MACHINE_TYPE\n\n assert cfg.cluster.use_preemptible == constants.ELB_DFLT_USE_PREEMPTIBLE\n assert cfg.blast.options == f'-outfmt {int(constants.ELB_DFLT_OUTFMT)}'\n assert cfg.blast.db_source.name == cfg.cloud_provider.cloud.name\n assert cfg.blast.db_mem_margin == constants.ELB_BLASTDB_MEMORY_MARGIN","def validate_parameters(self):\n\n flag = True\n warnings = \"\"\n # Check radius\n r = self.parameters.get('rw', 0)\n if type(r) not in [int, float]:\n flag = False\n warnings += \"Well radius rw must be a float value\\n\"\n else:\n if r <= 0:\n flag = False\n warnings += \"Well radius rw must be higher than 0\\n\"\n # Check if is full penetrating\n op = self.parameters.get('full', False)\n\n if not op:\n # Check observation well length\n if 'd' in self.parameters and 'l' in self.parameters:\n d = self.parameters.get('d', -1)\n l = self.parameters.get('l', -1)\n if type(l) not in [int, float]:\n flag = False\n warnings += \"Depth of well bottom must be a float value\\n\"\n else:\n if l < 0:\n flag = False\n warnings += \"Depth l must be higher than 0\\n\"\n if type(d) not in [int, float]:\n flag = False\n warnings += \"Depth of well screen must be a float value\\n\"\n else:\n if d < 0 or d > l:\n flag = False\n warnings += \"Depth d must be in range 0 <= d <= l\\n\"\n return(flag, warnings) # End Function","def provides_defaults_for(self, rule):\n return not self.is_build_only and \\\n self.endpoint == rule.endpoint and self != rule and \\\n self.arguments == rule.arguments","def _check_params(self):\n if self.k_initial <= 0 :\n raise ValueError('Initial K should be 1 or more.')","def check_params(self, name, fs_in, fs_out, highpass_cutoff, highpass_order,\n lowpass_cutoff, lowpass_order, ref_channels, channels_to_ref,\n channel_numbers, data_std, pre_context, post_context):\n if not isinstance(name, str):\n raise TypeError('name must be a string, not %s' % name)\n if fs_in <= 0:\n raise ValueError('fs_in should not be less than 0.')\n if fs_out <= 0:\n raise ValueError('fs_out should not be less than 0.')\n if highpass_cutoff < 0:\n raise ValueError('highpass_cutoff should not be less than 0.')\n if highpass_order < 0:\n raise ValueError('highpass_order should not be less than 0.')\n if lowpass_cutoff < 0:\n raise ValueError('lowpass_cutoff should not be less than 0.')\n if lowpass_order < 0:\n raise ValueError('lowpass_order should not be less than 0.')\n if not isinstance(ref_channels, list) and ref_channels is not None:\n raise ValueError('ref_channels must be a list.')\n if not isinstance(channels_to_ref, list) and channels_to_ref is not None:\n raise ValueError('channels_to_ref must be a list.')\n if not isinstance(channel_numbers, (list, str)) \\\n and channel_numbers is not None:\n raise ValueError('c hannel_numbers must be a list.')\n if data_std <= 0:\n raise ValueError('data_std must be greater than 0.')\n if pre_context < 0:\n raise ValueError('pre_context should not be less than 0.')\n if post_context < 0:\n raise ValueError('post_context should not be less than 0.')","def validate_arguments(self):\n if not self.args[0].is_constant():\n raise ValueError(\"The first argument to kron must be constant.\")","def ensure_default_constraints(self):\r\n positive_strings = ['variance', 'lengthscale', 'precision', 'decay', 'kappa']\r\n # param_names = self._get_param_names()\r\n currently_constrained = self.all_constrained_indices()\r\n to_make_positive = []\r\n for s in positive_strings:\r\n for i in self.grep_param_names(\".*\" + s):\r\n if not (i in currently_constrained):\r\n to_make_positive.append(i)\r\n if len(to_make_positive):\r\n self.constrain_positive(np.asarray(to_make_positive))","def checkDataParameters(self):\n while True:\n overideSamplesFlag = input(\"Default data parameters are:-\\n\\n Number of samples = %d\\n Number of replicates = %d\\n Number of QC replicates = %d\\n Number of solvent replicates = %d\\n File polarity mode = %s\\n Column type = %s\\n\\nChange these sample parameters (Y or N)? [N]: \" %\n (self.numberOfSamples, self.numberOfTechReps, self.numberOfQCReps, self.numberOfSolventReps, self.filePolarityMode, self.columnType)) or 'N'\n if overideSamplesFlag.upper() == 'N':\n break\n elif overideSamplesFlag.upper() == 'Y':\n self.setNumSamples()\n self.__setNumberOfTechReps__()\n self.__setNumberOfQCReps__()\n self.__setNumberOfSolventReps__()\n self.__setFilePolarityMode__()\n self.__setColumnType__()\n break\n else:\n print(\"\\nY or N required!\")","def test_reset_params(self):\n\t\t\n\t\tparams = DEFAULT_PARAMS.copy()\n\t\tparams['fit']=PL\n\t\tvalid = self.watcher.valid_params(params)\n\t\tself.assertTrue(valid)\n\t\tparams = self.watcher.normalize_params(params)\n\t\tself.assertEqual(params['fit'], POWER_LAW)\n\t\t\n\t\tparams = DEFAULT_PARAMS.copy()\n\t\tparams['fit']=TPL\n\t\tvalid = self.watcher.valid_params(params)\n\t\tself.assertFalse(valid)\n\t\t\n\t\tparams = DEFAULT_PARAMS.copy()\n\t\tparams['fit']=TPL\n\t\tparams[PL_PACKAGE]=POWERLAW_PACKAGE\n\t\tparams[XMAX]=XMAX_FORCE\n\n\t\tvalid = self.watcher.valid_params(params)\n\t\tself.assertTrue(valid)\n\t\tparams = self.watcher.normalize_params(params)\n\t\tself.assertEqual(params['fit'], TRUNCATED_POWER_LAW)","def _verify_arguments(self, kwargs: dict[str, Any]):\n geom_stat_args = kwargs.keys() | self._stat._kwargs.keys()\n unknown = (\n geom_stat_args\n - self.aesthetics()\n - self.DEFAULT_PARAMS.keys() # geom aesthetics\n - self._stat.aesthetics() # geom parameters\n - self._stat.DEFAULT_PARAMS.keys() # stat aesthetics\n - { # stat parameters\n \"data\",\n \"mapping\",\n \"show_legend\", # layer parameters\n \"inherit_aes\",\n \"raster\",\n }\n ) # layer parameters\n if unknown:\n msg = (\n \"Parameters {}, are not understood by \"\n \"either the geom, stat or layer.\"\n )\n raise PlotnineError(msg.format(unknown))","def checkParameters(self):\n self.DEBUG(\"EDPluginControlStitchImagev1_0.checkParameters\")\n self.checkMandatoryParameters(self.getDataInput(), \"Data Input is None\")\n self.checkMandatoryParameters(self.getDataInput().getInputImages(), \"No input Images\")","def BOUNDED_default(self):\n sstream = RosettaFunctionConstructs._ATOMPAIR\n sstream += \"BOUNDED {lower_bound: >.3f} {upper_bound: >.3f} 1 0.5 #\"\n return sstream","def default_hparams():\n return {\n \"value\": 0.,\n \"name\": \"constant_connector\"\n }","def optional_parameters(self):\n return ['bunches', 'target_thickness']","def changeRingSetting(self):\n #Input code to accommodate function of Ring setting","def _check_valid_config(self):\n default_keys = self.default_config.keys()\n current_keys = self.config.keys()\n\n if default_keys != current_keys:\n msg = f\"Config must have the following keys : {list(default_keys)}\"\n self.logger.critical(msg)\n sys.exit(0)","def check_params():\n print INITIAL_SCHEDULE\n print SCHEDULE_SA[:10]\n print CONTROL_DECISIONS\n\n print \"T_SLOT= %f\" % T_SLOT\n print \"R=%f\" % R\n print \"A=%f\" % A\n print \"A_IO=%f\" % A_IO\n print \"Q_INT=%d\" % Q_INT","def is_ring(self): # -> bool:\n ...","def test_validate_has_default(self, args, value):\n sch = scheme.Scheme(*args)\n sch.validate(value)","def test_defaults(self):\n varp = VarPositional()\n fparam = self.assert_iterable_and_get_fparam(varp)\n assert fparam.name == 'args'\n assert fparam.type == empty\n assert not fparam.converter\n assert not fparam.validator\n assert not fparam.metadata","def __Opt_value_depends_on_another_correct(self):\n strTestName = 'Test of value propagation onto optional parameters'\n RxCSObject = _RxCSobject()\n\n RxCSObject.paramAddMan('parameter1', 'Reference parameter #1')\n RxCSObject.paramAddMan('parameter2', 'Reference parameter #2')\n\n RxCSObject.paramAddOpt('optpar1', 'Optional parameter #1', default='$$parameter1')\n RxCSObject.paramType('optpar1', int)\n RxCSObject.paramHE('optpar1', 4)\n RxCSObject.paramLE('optpar1', 4)\n\n RxCSObject.paramAddOpt('optpar2', 'Optional parameter #1', default='$$parameter2')\n RxCSObject.paramType('optpar2', int)\n RxCSObject.paramHE('optpar2', 1)\n RxCSObject.paramLE('optpar2', 1)\n \n RxCSObject.parameter1 = 4\n RxCSObject.parameter2 = 1\n \n self.__parametersCheck_error(RxCSObject, 'correct', strTestName)","def test_default_argument(self):\n @converters.wrap\n def inner_test(param: int = 5):\n \"\"\"Make sure the default was used.\"\"\"\n self.assertEqual(param, 5)\n inner_test()","def _checkSettings(self):\n geomsThatNeedMeshSize = (\"1D slab\", \"1D cylinder\")\n if self.geometry in geomsThatNeedMeshSize:\n if self.meshSubdivisionsPerCm is None:\n raise ValueError(\n \"{} geometry requires `mesh points per cm` to be defined in cross sections.\".format(\n self.geometry\n )\n )\n if self.criticalBuckling != False:\n raise ValueError(\n \"{} geometry cannot model critical buckling. Please disable\".format(\n self.geometry\n )\n )","def test_tooFewModeParameters(self):\n self._sendModeChange(\"+o\")\n self._checkModeChange([])\n errors = self.flushLoggedErrors(irc.IRCBadModes)\n self.assertEqual(len(errors), 1)\n self.assertSubstring(\"Not enough parameters\", errors[0].getErrorMessage())","def check_invalid_bbb_args(config):\n if config.mnet_only and config.hyper_gauss_init:\n warnings.warn('Option \"hyper_gauss_init\" has no effect if no ' +\n 'hypernetwork is used.')\n if config.keep_orig_init and not \\\n (config.mnet_only or config.hyper_gauss_init):\n warnings.warn('Option \"keep_orig_init\" has no effect if main ' +\n 'network has no parameters or option ' +\n '\"hyper_gauss_init\" is not activated.')\n if not config.mnet_only and config.hyper_gauss_init and \\\n config.normal_init:\n warnings.warn('Option \"normal_init\" has no effect if ' +\n '\"hyper_gauss_init\" is activated.')\n if config.mnet_only and not config.keep_orig_init and \\\n config.normal_init:\n warnings.warn('Option \"normal_init\" has no effect for main net ' +\n 'initialization if \"keep_orig_init\" is not ' +\n 'activated.')\n if config.local_reparam_trick:\n if hasattr(config, 'dropout_rate') and config.dropout_rate != -1:\n raise ValueError('Dropout not implemented for network with ' +\n 'local reparametrization trick.')\n if hasattr(config, 'specnorm') and config.specnorm:\n raise ValueError('Spectral norm not implemented for network ' +\n 'with local reparametrization trick.')\n if hasattr(config, 'batchnorm') and config.batchnorm or \\\n hasattr(config, 'no_batchnorm') and not config.no_batchnorm:\n raise ValueError('Batchnorm not implemented for network ' +\n 'with local reparametrization trick.')\n if not config.local_reparam_trick and config.disable_lrt_test:\n warnings.warn('Option \"disable_lrt_test\" has no effect if the local-'\n 'reparametrization trick is not used.')\n\n if hasattr(config, 'mean_only') and config.mean_only:\n if hasattr(config, 'kl_scale') and config.kl_scale != 0 or \\\n hasattr(config, 'kl_schedule') and config.kl_schedule != 0:\n raise ValueError('Prior-matching is not applicable for ' +\n 'deterministic networks.')\n if config.regularizer != 'mse':\n raise ValueError('Only \"mse\" regularizer can be applied to ' +\n 'deterministic networks.')\n if config.local_reparam_trick:\n raise ValueError('Local-reparametrization trick cannot be ' +\n 'applied to non-Gaussian networks.')\n if config.hyper_gauss_init:\n raise ValueError('Gaussian-hypernet init cannot be applied to ' +\n 'non-Gaussian networks.')\n if hasattr(config, 'use_prev_post_as_prior') and \\\n config.use_prev_post_as_prior:\n raise ValueError('Option \"use_prev_post_as_prior\" cannot be ' +\n 'enforced for deterministic networks.')\n if config.train_sample_size > 1:\n warnings.warn('A \"train_sample_size\" greater than 1 doesn\\'t ' +\n 'make sense for a deterministic network.')\n if config.val_sample_size > 1:\n warnings.warn('A \"val_sample_size\" greater than 1 doesn\\'t ' +\n 'make sense for a deterministic network.')\n if config.disable_lrt_test:\n warnings.warn('Option \"disable_lrt_test\" not applicable to ' +\n 'deterministic networks.')\n if config.use_logvar_enc:\n warnings.warn('Option \"use_logvar_enc\" not applicable to ' +\n 'deterministic networks.')\n if config.regularizer != 'mse':\n if hasattr(config, 'hnet_reg_batch_size') and \\\n config.hnet_reg_batch_size != -1:\n raise NotImplementedError('Mini-batching of regularizer other ' +\n 'than the MSE reg is not implemented ' +\n 'yet.')\n\n if config.radial_bnn:\n if config.local_reparam_trick:\n raise ValueError('Local-reparametrization trick is not compatible '+\n 'with Radial BNNs since the weights posterior is '+\n 'not Gaussian anymore.')\n if config.regularizer != 'mse':\n raise NotImplementedError('Only the MSE regularizer has been ' +\n 'implemented for radial BNN ' +\n 'distributions.')\n if hasattr(config, 'use_prev_post_as_prior') and \\\n config.use_prev_post_as_prior:\n raise NotImplementedError('Option \"use_prev_post_as_prior\" not ' +\n 'implemented for Radial BNN.')","def _validate_parameter_combinations(self):\n parameters = [\"type\", \"path\", \"mode\", \"default\", \"min\", \"max\"]\n parameters = {key: getattr(self, key, None) for key in parameters}\n type = parameters.pop(\"type\")\n\n # validate parameter combination\n if type in self._TYPE_COMBINATION_MAPPING:\n valid_parameters = self._TYPE_COMBINATION_MAPPING[type]\n for key, value in parameters.items():\n if key not in valid_parameters and value is not None:\n msg = \"Invalid parameter for '{}' Input, parameter '{}' should be None but got '{}'\"\n raise ValidationException(\n message=msg.format(type, key, value),\n no_personal_data_message=msg.format(\"[type]\", \"[parameter]\", \"[parameter_value]\"),\n error_category=ErrorCategory.USER_ERROR,\n target=ErrorTarget.PIPELINE,\n )","def _getIsValidParameters(self):\n return True, ''","def checkParameters(self):\n self.DEBUG(\"EDPluginWaitMultiFile.checkParameters\")\n self.checkMandatoryParameters(self.dataInput, \"Data Input is None\")\n self.checkMandatoryParameters(self.dataInput.expectedFile, \"Data Input is None\")\n self.checkMandatoryParameters(self.dataInput.expectedSize, \"Data Input is None\")","def check_common_args(args, function_name,\n valid_functions=['gaperture', 'gmap', 'gfind'],\n allow_no_coords=False):\n\n try:\n function_name = function_name.strip().lower()\n except AttributeError:\n raise gPhotonArgsError(\"Invalid function: {f}\".format(f=function_name))\n\n if not function_name in valid_functions:\n raise gPhotonArgsError(\"Invalid function: {f}\".format(f=function_name))\n\n try:\n args.band = args.band.strip()\n except AttributeError:\n raise SystemExit(\"Invalid band: {b}\".format(b=args.band))\n\n # This will ensure calpath has a trailing '/'.\n if function_name in ['gaperture', 'gmap']:\n args.calpath = os.path.join(args.calpath, '')\n # [Future]: Consider fixing this statement. This is breaking nosetests,\n # but it's not a bad idea...\n # if not os.path.isdir(args.calpath):\n # raise SystemExit(\"Calibration path not found: \" + args.calpath)\n\n if (not (args.ra and args.dec) and not args.skypos and\n not allow_no_coords):\n raise SystemExit(\"Must specify either both RA/DEC or SKYPOS.\")\n elif (args.ra and args.dec) and args.skypos:\n if not (args.ra == args.skypos[0] and args.dec == args.skypos[1]):\n raise SystemExit(\"Must specify either RA/DEC or SKYPOS, not both.\")\n elif (args.ra and args.dec) and not args.skypos:\n args.skypos = [args.ra, args.dec]\n elif not (args.ra and args.dec) and args.skypos:\n args.ra, args.dec = args.skypos\n\n if args.suggest and function_name in ['gfind', 'gaperture']:\n (args.ra, args.dec, args.radius, args.annulus1,\n args.annulus2) = dbt.suggest_parameters(args.band, args.skypos,\n verbose=0)\n args.skypos = [args.ra, args.dec]\n if args.verbose:\n print(\"Recentering on [\"+str(args.ra)+\", \"+str(args.dec)+\"]\")\n print(\"Setting radius to \"+str(args.radius))\n print(\"Setting annulus to [\"+str(args.annulus1)+\", \"+\n str(args.annulus2)+\"]\")\n\n if args.skypos:\n if np.array(args.skypos).shape != (2,):\n raise gPhotonArgsError(\n \"Skypos (--skypos) must be a 2-element array.\")\n args.ra, args.dec = args.skypos\n\n if args.ra and not 0. <= args.ra <= 360.:\n raise SystemExit(\n \"RA of {ra} does not satisfy 0 <= RA <= 360\".format(ra=args.ra))\n\n if args.dec and not -90 <= args.dec <= 90:\n raise SystemExit(\n \"Dec of {dec} does not satisfy -90 <= DEC <= 90\".format(\n dec=args.dec))\n\n if args.detsize and args.detsize <= 0.:\n raise SystemExit(\"Effective field diameter (--detsize) must be > 0\")\n\n if args.maxgap and args.maxgap <= 0.:\n raise SystemExit(\"Maximum gap length (--maxgap) must be > 0 seconds.\")\n if args.minexp and args.minexp <= 0.:\n raise SystemExit(\"Minimum valid exposure depth (--minexp) must be > 0\"\n \" seconds.\")\n\n if args.retries and args.retries <= 0.:\n raise SystemExit(\"Number of retries (--retries) must be > 0.\")\n\n # tmin / tmax must be defined and reasonable\n if not args.tmin or args.tmin <= 0.:\n raise SystemExit(\"T0 (--t0) must be > 0.\")\n if not args.tmax or args.tmax <= 0.:\n raise SystemExit(\"T1 (--t1) must be > 0.\")\n if args.tmin >= args.tmax:\n raise SystemExit(\"Minimum time (--t0) must be < maximum time (--t1).\")\n\n if args.trange:\n if np.array(args.trange).shape == (2, ):\n args.trange = [args.trange]\n if not (len(np.array(args.trange).shape) == 2 and\n np.array(args.trange).shape[1] == 2):\n raise SystemExit(\"trange (--trange) must be a pairwise list.\")\n # Individually check the entries for sanity\n for t in args.trange:\n if t[0] <= 0 or t[1] <= 0:\n raise SystemExit('Times must be positive: {t}'.format(t=t))\n if t[1] <= t[0]:\n raise SystemExit('Start time ({t0}) must preceed end time'\n ' ({t1})'.format(t0=t[0], t1=t[1]))\n elif not allow_no_coords and function_name in ['gmap', 'gaperture']:\n args.trange = dbt.fGetTimeRanges(args.band, args.skypos,\n trange=[args.tmin, args.tmax],\n maxgap=args.maxgap, minexp=args.minexp,\n detsize=args.detsize,\n skyrange=args.skyrange)\n else:\n # If no coordinates specified then use a huge time range for now.\n args.trange = [args.tmin, args.tmax]\n\n return args","def test_no_default_value(self):\n dim = Dimension(\"yolo\", \"uniform\", -3, 4)\n assert dim.default_value is None","def _handleRequestCableCheckParameters(self, data):\r\n print(\"\\\"Request Cable Check Parameters\\\" received\")\r\n message = self.whitebeet.v2gParseRequestCableCheckParameters(data)\r\n if 'dc' in message:\r\n print(\"SOC: {}%\".format(message['dc']['soc']))\r\n try:\r\n self.whitebeet.v2gSetDcCableCheckParameters(0, 1)\r\n except Warning as e:\r\n print(\"Warning: {}\".format(e))\r\n except ConnectionError as e:\r\n print(\"ConnectionError: {}\".format(e))","def test_validate_default_kw_only_follows_non_default_kw_only(self):\n fsig = FSignature(\n [forge.kwarg('a', default=None), forge.kwarg('b')],\n __validate_parameters__=False,\n )\n fsig.validate()","def test_default_parse_args(self):\n self.assertEqual(self.args.router, poll.DEFAULT_ROUTER)\n self.assertEqual(self.args.port, poll.DEFAULT_PORT)\n self.assertEqual(self.args.interval, poll.DEFAULT_INTERVAL)\n self.assertEqual(self.args.community, poll.DEFAULT_COMMUNITY)\n self.assertEqual(self.args.iterations, poll.DEFAULT_ITERATIONS)","def test_config_option_required_default():\n class Config(config.Config):\n a = config.option(int, required=True, default=12, help=\"\")\n\n c = config.structure({}, Config)\n assert c.a == 12\n\n c = config.structure({\"a\": 23}, Config)\n assert c.a == 23\n\n with pytest.raises(config.ConfigError):\n config.structure({\"a\": None}, Config)","def test_set_outside_bounds_default_value(self):\n with pytest.raises(ValueError):\n Real(\"yolo\", \"uniform\", -3, 2, default_value=5)","def test_defaults(self):\n params = DefaultsInterface()\n # make sure from_param_server can be called repeatedly\n params.from_param_server()\n\n self.assertEqual(params.verbosity_param_w_default, 'info')\n\n self.assertEqual(params.int_param_w_default, 1)\n self.assertAlmostEqual(params.double_param_w_default, 1.1)\n self.assertEqual(params.str_param_w_default, \"Hello World\")\n self.assertEqual(params.bool_param_w_default, True)\n self.assertEqual(params.long_param_w_default_int, 1)\n self.assertEqual(params.long_param_w_default_int_str, -1)\n self.assertEqual(params.long_param_w_default_long_string, 9223372036854775807)\n\n self.assertEqual(params.vector_int_param_w_default, [1, 2, 3])\n self.assertEqual(params.vector_double_param_w_default, [1.1, 1.2, 1.3])\n self.assertEqual(params.vector_string_param_w_default, [\"Hello\", \"World\"])\n\n self.assertEqual(params.map_param_w_default, {\"Hello\": \"World\"})\n self.assertEqual(params.enum_int_param_w_default, 1)\n self.assertEqual(params.enum_str_param_w_default, \"One\")","def _check_args(self):\n if not isinstance(self.digits, str):\n raise TypeError('digits must be of type string.')\n if isinstance(self.n_points, float):\n self.n_points = int(self.n_points)\n if not isinstance(self.n_points, int):\n raise TypeError('n_points must be of type integer.')\n if self.n_points < 0:\n raise ValueError('n_points must be positive.')","def test_defaultValues(self):\n argV = []\n self.usage.parseOptions(argV)\n self.failUnlessEqual(self.usage.opts['fooint'], 392)\n self.assert_(isinstance(self.usage.opts['fooint'], int))\n self.failUnlessEqual(self.usage.opts['foofloat'], 4.23)\n self.assert_(isinstance(self.usage.opts['foofloat'], float))\n self.failUnlessEqual(self.usage.opts['eggint'], None)\n self.failUnlessEqual(self.usage.opts['eggfloat'], None)","def test_glass_capacity__has_expected_default_value():\n glass = moet.create_glass(\"A\")\n assert glass.capacity == 250","def test_default_arguments() -> None:\n\n @argcomb(a=\"b\")\n def f(a: int = 1, b: int = 2) -> None:\n ...\n\n # valid since ``a`` is the default value\n f(a=1)\n\n with pytest.raises(InvalidArgumentCombination):\n # invalid since ``b`` is the default value\n f(a=2, b=2)","def _check_param_grad_parity(\n _baseline_model: nn.Module,\n _test_model: nn.Module,\n ):\n self.assertEqual(len(list(_baseline_model.parameters())), 1)\n self.assertEqual(len(list(_test_model.parameters())), 1)\n for flat_param, orig_param in zip(\n _baseline_model.parameters(), _test_model.parameters()\n ):\n # Baseline is permitted to have padding\n self.assertGreaterEqual(flat_param.numel(), orig_param.numel())\n unpadded_param_numel = orig_param.numel()\n # For `NO_SHARD`, `use_orig_params=True` presents unflattened\n # parameters, while `False` presents flattened ones\n torch.testing.assert_close(\n flat_param[:unpadded_param_numel], orig_param.flatten()\n )\n # Gradient numel is different if right after `no_sync()` since\n # the gradient is unsharded, while the parameter is sharded\n unpadded_grad_numel = orig_param.grad.numel()\n # For `use_orig_params=False`, the unsharded gradient is\n # flattened, while for `True`, it is unflattened\n torch.testing.assert_close(\n flat_param.grad[:unpadded_grad_numel].reshape(\n orig_param.grad.shape\n ),\n orig_param.grad,\n )","def _check_input(self, **kwargs):\n\n combi_a = ['nxny', 'dxdy', 'ul_corner']\n combi_b = ['nxny', 'dxdy', 'll_corner']\n if all(kwargs[k] is not None for k in combi_a):\n nx, ny = kwargs['nxny']\n dx, dy = kwargs['dxdy']\n x0, y0 = kwargs['ul_corner']\n if (dx <= 0.) or (dy >= 0.):\n raise ValueError('dxdy and input params not compatible')\n origin = 'upper-left'\n elif all(kwargs[k] is not None for k in combi_b):\n nx, ny = kwargs['nxny']\n dx, dy = kwargs['dxdy']\n x0, y0 = kwargs['ll_corner']\n if (dx <= 0.) or (dy <= 0.):\n raise ValueError('dxdy and input params not compatible')\n origin = 'lower-left'\n else:\n raise ValueError('Input params not compatible')\n\n self._nx = int(nx)\n self._ny = int(ny)\n if (self._nx <= 0) or (self._ny <= 0):\n raise ValueError('nxny not valid')\n self._dx = float(dx)\n self._dy = float(dy)\n self._x0 = float(x0)\n self._y0 = float(y0)\n self._origin = origin\n\n # Check for pixel ref\n self._pixel_ref = kwargs['pixel_ref'].lower()\n if self._pixel_ref not in ['corner', 'center']:\n raise ValueError('pixel_ref not recognized')","def check_default(self, sec, name, default):\n if default is None:\n raise\n\n # print debug message saying default value was used\n if not default:\n default_text = 'empty string'\n else:\n default_text = default\n\n msg = \"Setting [{}] {} to default value ({})\".format(sec,\n name,\n default_text)\n if self.logger:\n self.logger.debug(msg)\n else:\n print('DEBUG: {}'.format(msg))\n\n # set conf with default value so all defaults can be added to\n # the final conf and warning only appears once per conf item\n # using a default value\n self.set(sec, name, default)","def getParameters(self, greenRectangleStartPoint, clearanceRectangleStartPoint, greenTime, clearanceTime, \n distance_Green, distance_Clearance, evTrajectoryTimePoint, evTrajectoryDistancePoint, \n transitTrajectoryTimePoint, transitTrajectoryDistancePoint, truckTrajectoryTimePoint, \n truckTrajectoryDistancePoint, carTrajectoryTimePoint, carTrajectoryDistancePoint, \n connectedVehicleTrajectoryTimePoint, connectedVehicleTrajectoryDistancePoint, textString, xAxisRange):\n self.greenRectangleStartPoint = greenRectangleStartPoint\n self.clearanceRectangleStartPoint = clearanceRectangleStartPoint\n self.greenTime = greenTime\n self.clearanceTime = clearanceTime\n self.distance_Green = distance_Green\n self.distance_Clearance = distance_Clearance\n self.evTrajectoryTimePoint, self.evTrajectoryDistancePoint = evTrajectoryTimePoint, evTrajectoryDistancePoint,\n self.transitTrajectoryTimePoint, self.transitTrajectoryDistancePoint = transitTrajectoryTimePoint, transitTrajectoryDistancePoint\n self.truckTrajectoryTimePoint, self.truckTrajectoryDistancePoint = truckTrajectoryTimePoint, truckTrajectoryDistancePoint\n self.carTrajectoryTimePoint, self.carTrajectoryDistancePoint = carTrajectoryTimePoint, carTrajectoryDistancePoint\n self.connectedVehicleTrajectoryTimePoint, self.connectedVehicleTrajectoryDistancePoint = connectedVehicleTrajectoryTimePoint, connectedVehicleTrajectoryDistancePoint\n self.textString = textString\n self.xAxisRange = xAxisRange","def check_params(self):\n raise NotImplementedError","def getDefaultBrush(*args, **kwargs)->AnyStr:\n pass","def _validatePypetParameters(self, runParams):\n\n # fix rng seed, which is saved as a string if None\n if \"seed\" in runParams:\n if runParams[\"seed\"] == \"None\":\n runParams[\"seed\"] = None\n return runParams","def check_params(self, X: TwoDimArray, y: OneDimArray = None) -> None:\n\n super().check_params(X)","def check_params(self, X: TwoDimArray, y: OneDimArray = None) -> None:\n\n super().check_params(X)","def check_params(self, X: TwoDimArray, y: OneDimArray = None) -> None:\n\n super().check_params(X)","def check_params_set():\n critical = {'machineinfo' : MACHINEID, \n 'error_serverinfo' : ERROR_SERVER, \n 'serverinfo' : SERVER}\n for i, val in critical.iteritems():\n if not val:\n print \"ERROR: Set value for \\\"%s\\\" in baseconfig.cfg file first\\n\" % i\n sys.exit(1)","def bond_check(distance, minimum=0, maximum=1.5): # when variables are set equal to => default\n if distance > minimum and distance < maximum:\n return True\n return False","def test_blank(self):\n self._calibration_test(\"blank\")","def test_mismatchedParams(self):\n self.assertRaises(irc.IRCBadModes, irc.parseModes, \"+k\", [], self.paramModes)\n self.assertRaises(\n irc.IRCBadModes,\n irc.parseModes,\n \"+kl\",\n [\"foo\", \"10\", \"lulz_extra_param\"],\n self.paramModes,\n )","def test_defaults(self):\n vark = VarKeyword()\n name, fparam = self.assert_mapping_and_get_fparam(vark)\n assert name == 'kwargs'\n assert fparam.type == empty\n assert not fparam.converter\n assert not fparam.validator\n assert not fparam.metadata","def apply_default_constraints(self):\n try:\n self.apply_secthresh(pipeline_weaksec(self.koi))\n except NoWeakSecondaryError:\n logging.warning('No secondary eclipse threshold set for {}'.format(self.koi))\n self.set_maxrad(default_r_exclusion(self.koi))","def test_no_default_value(self):\n dim = Integer(\"yolo\", \"uniform\", -3, 4)\n assert dim.default_value is None","def test_nondefault_nonbonded_cutoff(self):\n topology = Molecule.from_smiles(\"[#18]\").to_topology()\n topology.box_vectors = [3, 3, 3] * unit.nanometer\n\n force_field = ForceField()\n\n vdw_handler = vdWHandler(version=0.4)\n vdw_handler.cutoff = 7.89 * unit.angstrom\n vdw_handler.scale14 = 1.0\n\n vdw_handler.add_parameter(\n {\n \"smirks\": \"[#18:1]\",\n \"epsilon\": 1.0 * unit.kilojoules_per_mole,\n \"sigma\": 1.0 * unit.angstrom,\n }\n )\n force_field.register_parameter_handler(vdw_handler)\n\n electrostatics_handler = ElectrostaticsHandler(version=0.3)\n electrostatics_handler.cutoff = 7.89 * unit.angstrom\n electrostatics_handler.periodic_potential = \"PME\"\n force_field.register_parameter_handler(electrostatics_handler)\n\n library_charges = LibraryChargeHandler(version=0.3)\n library_charges.add_parameter(\n {\n \"smirks\": \"[#18:1]\",\n \"charge1\": 0.0 * unit.elementary_charge,\n }\n )\n force_field.register_parameter_handler(library_charges)\n\n system = force_field.create_openmm_system(topology)\n\n found_cutoff = (\n system.getForce(0).getCutoffDistance().value_in_unit(openmm_unit.angstrom)\n )\n\n assert abs(found_cutoff - 7.89) < 1e-6","def __check_args_val(self):\n if self.__num_prev_scans < 0:\n error_msg = \"num_prev_scans must be greater than or equal to zero\"\n raise ValueError(error_msg)","def test_init_with_default_value(self):\n with pytest.raises(NotImplementedError):\n Dimension(\"yolo\", \"uniform\", -3, 4, default_value=4)","def check_params(params):\n\n required = ['initlandmarks']\n for r in required:\n assert r in params.keys(), 'Params must include {}'.format(r)","def is_default(dimension):\n\n print(f'{dimension}-dimensional space'.upper())\n\n while(True):\n is_default = input('Default parameters? ')\n try:\n if is_default == 'y' or is_default == 'yes': \n return True\n elif is_default == 'n' or is_default == 'no':\n return False\n except Exception as e:\n print('Exception: '.upper(), e)\n traceback.print_tb(e.__traceback__)","def test_missing_arg_repr():\n argspec = inspect.getfullargspec(exceptional.wrap)\n assert repr(argspec.kwonlydefaults[\"message\"]) == \"<MISSING>\"","def validate_client_parameters(cmd, namespace):\n n = namespace\n\n if not n.connection_string:\n n.connection_string = get_config_value(cmd, 'communication', 'connection_string', None)","def check_valid_keys(self, obj):\n invalid_keys = [\n x for x in obj if x not in self.defaults\n ]\n if invalid_keys:\n raise ValueError(\n \"No such model parameters: %s. Valid parameters are: %s\"\n % (\" \".join(invalid_keys), \" \".join(self.defaults)))","def getDefaultParams():\n defpar = [\n # coordinate system\n ['crd_sys', \"'sph'\", 'Coordinate system'],\n ['nx', '[60, 40, 30]', 'Number of grid points in the first dimension'],\n ['xbound', '[0.1*au, 30.*au, 110.*au, 250.*au]', 'Number of radial grid points'],\n ['ny', '[10,30, 30, 10]',\n 'Number of grid points in the second dimension'],\n ['ybound', '[0.1, pi/6., pi/2., 5.*pi/6., 3.04]',\n 'Number of radial grid points'],\n ['nz', '[361]', 'Number of grid points in the third dimension'],\n ['zbound', '[0., 2.0*pi]', 'Number of radial grid points'],\n # star related\n ['tstar', '[3900.0]', 'Temperature of star'],\n ['mstar', '[1.0*ms]', 'Mass of the star(s)'],\n ['rstar', '[2.5*rs]', 'Radius of star'],\n # gas density \n ['Rin', '[0.1*au, 80*au]', 'inner bounding edge'],\n ['Rin_w', '[0, 1*au]', 'gaussian taper before inner edge'], \n ['Rout', '[30*au, 120*au]', 'outer bounding edge'],\n ['Rout_w', '[1*au, 1*au]', 'gaussian taper after outer edge'], \n ['sigp', '[-1.0, -1.5]', 'power-law surface density'],\n ['sig0', '[1e2, 1e1]', 'surface density at Rin in g/cm^2'], \n ['ring_r', '[50*au]', 'location of gaussian ring'], \n ['ring_win', '[5*au]', 'width of gaussian ring in inner radius'],\n ['ring_wout', '[5*au]', 'width of gaussian ring in outer radius'], \n ['ring_a', '[1e2]', 'surface density at center of ring in g/cm^2]'], \n ['cutgdens', '1e-30', 'cut for density'], \n ['Rt', '100*au', 'radius for scale height'], \n ['Ht', '10*au', 'scale height'], \n ['qheight', '1.25', 'height power-law'], \n # gas species\n ['gasspec_mol_name', \"['12co']\", 'name of molecule'],\n ['gasspec_mol_abun', '[5e-5]', 'mass abundance '],\n ['gasspec_mol_dbase_type', \"['leiden']\", ''],\n ['gasspec_mol_freezeout_dfact', '[1e-3]',\n 'Factor by which the molecular abundance should be decreased in the freeze-out zone'],\n ['mol_freeze_Ht', '[24*au]', 'Height at Rt, with index=qheight, for freeze out to happen'],\n ['mol_freeze_del_hfrac', '0.2', 'Gaussian taper for freeze-out. del H = h * hfrac'],\n ['mol_snowR', '[20*au]', 'Radius when freeze out begins to happen'],\n # dust density\n # flat power-law parts\n ['dRin', '[0.1*au, 80*au]', 'inner bounding edge'],\n ['dRin_w', '[0, 1*au]', 'gaussian taper before inner edge'], \n ['dRout', '[30*au, 120*au]', 'outer bounding edge'],\n ['dRout_w', '[1*au, 1*au]', 'gaussian taper after outer edge'], \n ['dsigp', '[-1.0, -1.5]', 'power-law surface density'],\n ['dsig0', '[1e2, 1e1]', 'surface density at Rin'],\n # Lynden-Bell parts\n ['dLB_Rin', '[0.1*au]', 'inner bounding radius'], \n ['dLB_Rsig', '[30*au]', 'charcteristic radius'],\n ['dLB_sigp', '[-1.0]', 'power-law exponent. Careful, the sign is different from the usual function by a negative sign for consistency with flat power-law'], \n ['dLB_sig0', '[1e2]', 'surface density'], \n # ring parts\n ['dring_r', '[50*au]', 'location of gaussian ring'],\n ['dring_win', '[5*au]', 'width of gaussian ring in inner radius'],\n ['dring_wout', '[5*au]', 'width of gaussian ring in outer radius'], \n ['dring_a', '[1e2]', 'surface density at center of ring in g/cm^2]'],\n ['cutddens', '1e-30', 'cut for dust density'],\n ['dRt', '[100*au]', 'radius for scale height for each grain size'], \n ['dHt', '[10*au]', 'scale height for each grain size'], \n ['dqheight', '[1.25]', 'scale height power-law for dust'], \n # temperature\n ['T0mid', '50', 'mid plane temperature at Rt'],\n ['T0atm', '50', 'atmosphere temperature at Rt'],\n ['zqratio', '3', 'factor of Ht of where temperature transition occurs'],\n ['qmid', '-0.5', 'midplane temperature exponent'],\n ['qatm', '-0.5', 'atmosphere temperature exponent'],\n ['hdel', '2', 'temperature transition exponent '],\n ['cuttemp', '10', 'temperature cut'], \n # alignment\n ['altype', \"'toroidal'\", 'alignment type']\n ]\n\n return defpar","def __optional_is_not_given(self):\n\n strTestName = 'Optional parameter is not given (incorrect)'\n RxCSObject = _RxCSobject()\n\n RxCSObject.paramAddOpt('optional_parameter', 'Optional parameter')\n\n self.__parametersCheck_error(RxCSObject, 'correct', strTestName)","def _init_checked(self):\n assert all(\n len(val) <= 2\n or (\n len(val) == 3\n and all(\n self.extra_parameters[parent_var] == self.fuse_parameter\n for parent_var in val\n )\n )\n for val in self.reversed_extra_parameters.values()\n )\n assert all(\n (\n any(\n parent_var in self.left_sided_parameters\n or parent_var in self.right_sided_parameters\n for parent_var in parent_vars\n )\n and any(\n parent_var in self.both_sided_parameters\n for parent_var in parent_vars\n )\n )\n or all(\n self.extra_parameters[parent_var] == self.fuse_parameter\n for parent_var in parent_vars\n )\n for parent_vars in self.reversed_extra_parameters.values()\n if len(parent_vars) == 2\n )","def check_arg_compatibility(args: argparse.Namespace):\n\n # Require at least one stopping criteria\n check_condition(any((args.max_samples,\n args.max_updates,\n args.max_seconds,\n args.max_checkpoints,\n args.max_num_epochs,\n args.max_num_checkpoint_not_improved)),\n 'Please specify at least one stopping criteria: --max-samples --max-updates --max-checkpoints '\n '--max-num-epochs --max-num-checkpoint-not-improved')\n\n # Check and possibly adapt the parameters for source factors\n n_source_factors = len(args.validation_source_factors)\n if len(args.source_factors_combine) > 1:\n check_condition(n_source_factors == len(args.source_factors_combine),\n 'The number of combination strategies for source '\n 'factors does not match the number of source factors.')\n else:\n # Length 1: expand the list to the appropriate length\n args.source_factors_combine = args.source_factors_combine * n_source_factors\n if len(args.source_factors_share_embedding) > 1:\n check_condition(n_source_factors == len(args.source_factors_share_embedding),\n 'The number of vocabulary sharing flags for source '\n 'factors does not match the number of source factors.')\n else:\n # Length 1: expand the list to the appropriate length\n args.source_factors_share_embedding = args.source_factors_share_embedding * n_source_factors\n\n # Check and possibly adapt the parameters for target factors\n n_target_factors = len(args.validation_target_factors)\n if len(args.target_factors_combine) > 1:\n check_condition(n_target_factors == len(args.target_factors_combine),\n 'The number of combination strategies for target '\n 'factors does not match the number of target factors.')\n else:\n # Length 1: expand the list to the appropriate length\n args.target_factors_combine = args.target_factors_combine * n_target_factors\n if len(args.target_factors_share_embedding) > 1:\n check_condition(n_target_factors == len(args.target_factors_share_embedding),\n 'The number of vocabulary sharing flags for target '\n 'factors does not match the number of target factors.')\n else:\n # Length 1: expand the list to the appropriate length\n args.target_factors_share_embedding = args.target_factors_share_embedding * n_target_factors","def test_config_option_required_no_default():\n class Config(config.Config):\n a = config.option(int, required=True, help=\"\")\n\n with pytest.raises(config.ConfigError):\n config.structure({}, Config)\n\n with pytest.raises(config.ConfigError):\n config.structure({\"a\": None}, Config)\n\n c = config.structure({\"a\": 12}, Config)\n assert c.a == 12","def updateParameters(self):\n\n if self.params[1].value:\n if arcpy.Exists(self.params[1].value):\n try:\n min_value = arcpy.GetRasterProperties_management(self.params[1].value, \"MINIMUM\")[0]\n\n if str(self.params[8].value) != str(self.params[1].value):\n self.params[7].value = True\n self.params[8].value = str(self.params[1].value)\n else:\n self.params[7].value = False\n\n if str(min_value) == \"0\":\n if self.params[7].value == True:\n self.params[2].value = True\n self.params[3].enabled = True\n self.params[7].value = False\n else:\n self.params[2].value = False\n self.params[3].enabled = False\n\n except arcpy.ExecuteError:\n pass\n\n if self.params[2].value == True:\n self.params[3].enabled = True\n else:\n self.params[3].enabled = False"],"string":"[\n \"def check_raw_parameters(self):\\n # exclude some irrelevant or mandatory parameters\\n excluded_keys = (\\\"cmd\\\", \\\"client\\\", \\\"resource_group_name\\\", \\\"name\\\")\\n # check whether the remaining parameters are set\\n # the default value None or False (and other empty values, like empty string) will be considered as not set\\n is_changed = any(v for k, v in self.context.raw_param.items() if k not in excluded_keys)\\n\\n # special cases\\n # some parameters support the use of empty string or dictionary to update/remove previously set values\\n is_default = (\\n self.context.get_cluster_autoscaler_profile() is None and\\n self.context.get_api_server_authorized_ip_ranges() is None and\\n self.context.get_nodepool_labels() is None and\\n self.context.get_nodepool_taints() is None\\n )\\n\\n if not is_changed and is_default:\\n reconcilePrompt = 'no argument specified to update would you like to reconcile to current settings?'\\n if not prompt_y_n(reconcilePrompt, default=\\\"n\\\"):\\n # Note: Uncomment the followings to automatically generate the error message.\\n option_names = [\\n '\\\"{}\\\"'.format(format_parameter_name_to_option_name(x))\\n for x in self.context.raw_param.keys()\\n if x not in excluded_keys\\n ]\\n error_msg = \\\"Please specify one or more of {}.\\\".format(\\n \\\" or \\\".join(option_names)\\n )\\n raise RequiredArgumentMissingError(error_msg)\",\n \"def test_checkParameters(self):\\n self.failUnlessEqual(self.nice.opts['long'], \\\"Alpha\\\")\\n self.failUnlessEqual(self.nice.opts['another'], \\\"Beta\\\")\\n self.failUnlessEqual(self.nice.opts['longonly'], \\\"noshort\\\")\\n self.failUnlessEqual(self.nice.opts['shortless'], \\\"Gamma\\\")\",\n \"def check_config(self):\\n assert 'AUTO' in self.config\\n assert 'LAT' in self.config\\n assert 'LON' in self.config\\n assert 'ALL_CHANNELS' in self.config\\n for key in self.extract_servo_channels():\\n assert 'STATUS' in self.config[key]\\n self.config[key]['STATUS'] = float(self.config[key]['STATUS'])\\n assert 0.0 <= self.config[key]['STATUS'] <= 1.0\\n\\n if not 'SUNRISE_BUFFER' in self.config[key]:\\n self.config[key]['SUNRISE_BUFFER'] = 0\\n if not 'SUNSET_BUFFER' in self.config[key]:\\n self.config[key]['SUNSET_BUFFER'] = 0\",\n \"def has_default_parameters(self):\\n return self._compat_flags[0] & (0x1 << 0)\",\n \"def test_default_parameters(self):\\n\\n assert self.test_shape.center_coordinate == (0.0, 0.0, 0.0)\",\n \"def test_defaults(self):\\n fparam = FParameter(POSITIONAL_ONLY)\\n assert fparam.kind == POSITIONAL_ONLY\\n for k, v in FPARAM_DEFAULTS.items():\\n assert getattr(fparam, k) == v\",\n \"def test_default_parameters(self):\\n\\n assert self.test_shape.rotation_angle == 360\\n assert self.test_shape.extrude_both\",\n \"def test_drudge_has_default_properties(free_alg):\\n\\n assert isinstance(free_alg.num_partitions, int)\\n assert free_alg.full_simplify\\n assert not free_alg.simple_merge\",\n \"def check_params(self):\\r\\n \\r\\n # TODO: More cases?\\r\\n\\r\\n if self.N <= 0:\\r\\n print('Bad Parameter: N')\\r\\n \\r\\n if self.Ha_tally <= 0 or self.Ha_tally > self.N:\\r\\n print('Bad Parameter: Reported winner tally')\\r\\n \\r\\n if len(self.round_sched) < 1 or not self.check_inc_sched(self.round_sched):\\r\\n print('Bad Parameter: Round Schedule')\\r\\n\\r\\n if self.alpha <= 0 or self.alpha >= .5:\\r\\n print('Bad Parameter: Alpha')\",\n \"def test_build_defaults(self, args, expected):\\n sch = scheme.Scheme(*args)\\n defaults = sch.build_defaults()\\n\\n assert defaults == expected\",\n \"def checkParameters(self):\\n EDVerbose.DEBUG(\\\"EDPluginControlAbsorptionv0_1.checkParameters\\\")\\n self.checkMandatoryParameters(self.getDataInput(), \\\"Data Input is None\\\")\",\n \"def checkParameters(self):\\n self.DEBUG(\\\"EDPluginExecDatGnomv1_0.checkParameters\\\")\\n self.checkMandatoryParameters(self.dataInput, \\\"Data Input is None\\\")\\n self.checkMandatoryParameters(self.dataInput.inputCurve, \\\"No input Curve file provided\\\")\",\n \"def validate_parameters(self):\\n\\n flag = True\\n warnings = \\\"\\\"\\n # Check radius\\n r = self.parameters.get('r', 0)\\n if type(r) not in [int, float]:\\n flag = False\\n warnings += \\\"Radius r must be a float value\\\\n\\\"\\n else:\\n if r <= 0:\\n flag = False\\n warnings += \\\"Radius r must be higher than 0\\\\n\\\"\\n # Check if is full penetrating\\n op = self.parameters.get('full', False)\\n\\n if not op:\\n # Check observation well length\\n if 'd' in self.parameters and 'l' in self.parameters:\\n d = self.parameters.get('d', -1)\\n l = self.parameters.get('l', -1)\\n if type(l) not in [int, float]:\\n flag = False\\n warnings += \\\"Depth of well bottom must be a float value\\\\n\\\"\\n else:\\n if l < 0:\\n flag = False\\n warnings += \\\"Depth l must be higher than 0\\\\n\\\"\\n if type(d) not in [int, float]:\\n flag = False\\n warnings += \\\"Depth of well screen must be a float value\\\\n\\\"\\n else:\\n if d < 0 or d > l:\\n flag = False\\n warnings += \\\"Depth d must be in range 0 <= d <= l\\\\n\\\"\\n # Check piezometer depth\\n elif 'z' in self.parameters:\\n z = self.parameters.get('z', -1)\\n if type(z) not in [int, float]:\\n flag = False\\n warnings += \\\"Depth of piezometer must be a float value\\\\n\\\"\\n else:\\n if z < 0:\\n flag = False\\n warnings += \\\"Depth z must be higher than 0\\\\n\\\"\\n else:\\n flag = False\\n warnings += \\\"Well don't contain well depth attributes\\\\n\\\"\\n return(flag, warnings) # End Function\",\n \"def test_kw_args_with_defaults():\\n assert arguments.fun_opt_kw_params() == ('blue', 'red', 'yellow', 'orange')\",\n \"def _check_vals(self):\\n\\n try:\\n self.is_set = True\\n self.pack()\\n except Exception as err:\\n # Set default values again\\n raise ValueError(\\\"Invalid arguments. Could not packed since: {}\\\".format(err))\\n self.__init__()\",\n \"def test_default_parameters(self):\\n\\n assert self.test_shape.rotation_angle == 360\",\n \"def checkParameters(self):\\n self.DEBUG(\\\"EDPluginExecDatcmpv2_0.checkParameters\\\")\\n self.checkMandatoryParameters(self.getDataInput(), \\\"Data Input is None\\\")\\n self.checkMandatoryParameters(self.getDataInput().inputCurve, \\\"No input 1D curves file provided\\\")\",\n \"def _check_valid_basic(self, get_params):\\n try:\\n if get_params(self.variable):\\n return self.default\\n except: # noqa e722\\n pass\\n return not self.default\",\n \"def _check_params(self):\\n pass\",\n \"def test_build_defaults_failure(self, args):\\n sch = scheme.Scheme(*args)\\n with pytest.raises(errors.InvalidSchemeError):\\n sch.build_defaults()\",\n \"def assertCorrConfig() :\\n # eventually we will want a wait on C3Gmax8 or C3GMax24 astrobands \\n if ( subarrayOwnsCorrelator(subarrayNo,CORR_WIDEBAND) or subarrayOwnsCorrelator(subarrayNo,CORR_SPECTRAL) ) :\\n print \\\"This command is currently a no-op for non-C3G correlators\\\"\\n return\\n if ( subarrayOwnsNoCorrelator( subarrayNo ) ) :\\n print \\\"You need to add a C3G correlator to use this command!\\\"\\n return\\n s.assertCorrelatorConfiguration()\",\n \"def check_invalid_args_general(config):\\n # Not mathematically correct, but might be required if prior is not\\n # appropriate.\\n if hasattr(config, 'kl_scale') and config.kl_scale != 1.0:\\n warnings.warn('Prior matching term will be scaled by %f.'\\n % config.kl_scale)\\n\\n if hasattr(config, 'store_final_model') and \\\\\\n hasattr(config, 'train_from_scratch') and \\\\\\n config.store_final_model and config.train_from_scratch:\\n warnings.warn('Note, when training from scratch, the final model is ' +\\n 'only trained on the last task!')\",\n \"def checkParameters(self):\\n EDVerbose.DEBUG(\\\"EDPluginExecGnomv0_1.checkParameters\\\")\\n self.checkMandatoryParameters(self.dataInput, \\\"Data Input is None\\\")\\n self.checkMandatoryParameters(self.dataInput.experimentalDataQ, \\\"Scattering vector values are missing\\\")\\n self.checkMandatoryParameters(self.dataInput.experimentalDataValues, \\\"Experimental intensity values are missing\\\")\",\n \"def f_check_adr_parameters_correctness(dict):\\n\\n if int(dict[\\\"operation_mode_num\\\"]) not in (0, 1, 2, 3, 4, 5, 6):\\n print('\\\\n Error!!! Operation mode is wrong!\\\\n')\\n sys.exit(' Program stopped!')\\n\\n if int(dict[\\\"FFT_size_samples\\\"]) not in (2048, 4096, 8192, 16384, 32768):\\n print('\\\\n Error!!! FFT size is wrong!\\\\n')\\n sys.exit(' Program stopped!')\\n\\n if int(dict[\\\"spectra_averaging\\\"]) < 16 or int(dict[\\\"spectra_averaging\\\"]) > 32768:\\n print('\\\\n Error!!! Spectra averaging number is wrong!\\\\n')\\n sys.exit(' Program stopped!')\\n\\n if int(dict[\\\"start_line_freq\\\"]) not in (0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16): # 0 … (SFFT-1024)/1024\\n print('\\\\n Error!!! Start frequency line is wrong!\\\\n')\\n sys.exit(' Program stopped!')\\n\\n if int(dict[\\\"width_line_freq\\\"]) not in (0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16):\\n print('\\\\n Error!!! Frequency width line is wrong!\\\\n')\\n sys.exit(' Program stopped!')\\n\\n if int(dict[\\\"width_line_freq\\\"]) > ((int(dict[\\\"FFT_size_samples\\\"]) - int(dict[\\\"start_line_freq\\\"]) * 1024) / 1024): # 1 … (SFFT-SLINE*1024)/1024\\n print('\\\\n Error!!! Frequency width is bigger than FFT size allows!\\\\n')\\n sys.exit(' Program stopped!')\\n\\n if int(dict[\\\"clock_source\\\"]) not in (0, 1):\\n print('\\\\n Error!!! Clock source is wrong!\\\\n')\\n sys.exit(' Program stopped!')\\n\\n if int(dict[\\\"sum_diff_mode_num\\\"]) not in (0, 1):\\n print('\\\\n Error!!! Sum-diff mode is wrong!\\\\n')\\n sys.exit(' Program stopped!')\\n\\n if int(dict[\\\"data_file_size\\\"]) < -1 or int(dict[\\\"data_file_size\\\"]) > 4096:\\n print('\\\\n Error!!! File size value is wrong!\\\\n')\\n sys.exit(' Program stopped!')\\n\\n '''\\n if (int(dict[\\\"chan_diff_delay\\\"]) < 0 or int(parameters_dict[\\\"chan_diff_dalay\\\"]) > 1024):\\n print('\\\\n Error!!! Channel difference delay is wrong!\\\\n')\\n sys.exit(' Program stopped!')\\n '''\\n\\n # print('\\\\n ADR parameters from file are correct!\\\\n')\\n\\n return dict\",\n \"def checkNeededParams(self):\\n for clp,value in self.neededParamsNames.items():\\n if value[0] not in self.neededParams:\\n print >> sys.stderr, clp+\\\" is a mandatory parameter \\\"\\n self.printUsage()\\n sys.exit(1)\",\n \"def test_default_argument_null(self):\\n @converters.wrap\\n def inner_test(param: int = 14):\\n \\\"\\\"\\\"Make sure the default was used.\\\"\\\"\\\"\\n self.assertEqual(param, 14)\\n inner_test(param=None)\",\n \"def test__init__bound_and_default(self, extras, raises):\\n kwargs = dict(\\n kind=POSITIONAL_ONLY,\\n bound=True,\\n **extras,\\n )\\n\\n if not raises:\\n assert FParameter(**kwargs).bound\\n return\\n\\n with pytest.raises(TypeError) as excinfo:\\n FParameter(**kwargs)\\n assert excinfo.value.args[0] == \\\\\\n 'bound arguments must have a default value'\",\n \"def check_conv_config(self):\\n conv_config = self.conv_config\\n config = self.base_model.config\\n\\n new_params_1 = [k for k in conv_config.keys() if not k.endswith(\\\"_rate_multiplier\\\")]\\n new_params_2 = []\\n\\n for k, v in conv_config.items():\\n if isinstance(v, dict):\\n for p in v[\\\"params\\\"]:\\n if p not in new_params_2:\\n new_params_2.append(p)\\n\\n # order doesn't matter\\n assert set(new_params_1) == set(new_params_2), \\\"New parameters are not consistent, double check conv_config...\\\"\\n\\n # also check if new params are in config or not\\n missing_params = \\\"\\\"\\n for new_p in new_params_1:\\n if not config.get(new_p, False):\\n missing_params += f\\\"{new_p}, \\\"\\n\\n # remove the period if there are missing parameters..\\n if missing_params != \\\"\\\":\\n missing_params = missing_params[:-2]\\n\\n assert missing_params == \\\"\\\", f\\\"{missing_params} are missing in the config\\\"\",\n \"def check_required(self):\\n for argument in self.arguments:\\n if argument.required:\\n raise ArgumentRequiredError(argument, self.tagname)\\n else:\\n self.kwargs[argument.name] = argument.get_default()\",\n \"def check_common_defaults(cfg):\\n assert cfg.cluster.name.startswith('elasticblast') # Needed to run ElasticBLAST on NCBI AWS account see SYS-360205\\n if cfg.cloud_provider.cloud == CSP.GCP:\\n assert cfg.cluster.machine_type == constants.ELB_DFLT_GCP_MACHINE_TYPE\\n else:\\n assert cfg.cluster.machine_type == constants.ELB_DFLT_AWS_MACHINE_TYPE\\n\\n assert cfg.cluster.use_preemptible == constants.ELB_DFLT_USE_PREEMPTIBLE\\n assert cfg.blast.options == f'-outfmt {int(constants.ELB_DFLT_OUTFMT)}'\\n assert cfg.blast.db_source.name == cfg.cloud_provider.cloud.name\\n assert cfg.blast.db_mem_margin == constants.ELB_BLASTDB_MEMORY_MARGIN\",\n \"def validate_parameters(self):\\n\\n flag = True\\n warnings = \\\"\\\"\\n # Check radius\\n r = self.parameters.get('rw', 0)\\n if type(r) not in [int, float]:\\n flag = False\\n warnings += \\\"Well radius rw must be a float value\\\\n\\\"\\n else:\\n if r <= 0:\\n flag = False\\n warnings += \\\"Well radius rw must be higher than 0\\\\n\\\"\\n # Check if is full penetrating\\n op = self.parameters.get('full', False)\\n\\n if not op:\\n # Check observation well length\\n if 'd' in self.parameters and 'l' in self.parameters:\\n d = self.parameters.get('d', -1)\\n l = self.parameters.get('l', -1)\\n if type(l) not in [int, float]:\\n flag = False\\n warnings += \\\"Depth of well bottom must be a float value\\\\n\\\"\\n else:\\n if l < 0:\\n flag = False\\n warnings += \\\"Depth l must be higher than 0\\\\n\\\"\\n if type(d) not in [int, float]:\\n flag = False\\n warnings += \\\"Depth of well screen must be a float value\\\\n\\\"\\n else:\\n if d < 0 or d > l:\\n flag = False\\n warnings += \\\"Depth d must be in range 0 <= d <= l\\\\n\\\"\\n return(flag, warnings) # End Function\",\n \"def provides_defaults_for(self, rule):\\n return not self.is_build_only and \\\\\\n self.endpoint == rule.endpoint and self != rule and \\\\\\n self.arguments == rule.arguments\",\n \"def _check_params(self):\\n if self.k_initial <= 0 :\\n raise ValueError('Initial K should be 1 or more.')\",\n \"def check_params(self, name, fs_in, fs_out, highpass_cutoff, highpass_order,\\n lowpass_cutoff, lowpass_order, ref_channels, channels_to_ref,\\n channel_numbers, data_std, pre_context, post_context):\\n if not isinstance(name, str):\\n raise TypeError('name must be a string, not %s' % name)\\n if fs_in <= 0:\\n raise ValueError('fs_in should not be less than 0.')\\n if fs_out <= 0:\\n raise ValueError('fs_out should not be less than 0.')\\n if highpass_cutoff < 0:\\n raise ValueError('highpass_cutoff should not be less than 0.')\\n if highpass_order < 0:\\n raise ValueError('highpass_order should not be less than 0.')\\n if lowpass_cutoff < 0:\\n raise ValueError('lowpass_cutoff should not be less than 0.')\\n if lowpass_order < 0:\\n raise ValueError('lowpass_order should not be less than 0.')\\n if not isinstance(ref_channels, list) and ref_channels is not None:\\n raise ValueError('ref_channels must be a list.')\\n if not isinstance(channels_to_ref, list) and channels_to_ref is not None:\\n raise ValueError('channels_to_ref must be a list.')\\n if not isinstance(channel_numbers, (list, str)) \\\\\\n and channel_numbers is not None:\\n raise ValueError('c hannel_numbers must be a list.')\\n if data_std <= 0:\\n raise ValueError('data_std must be greater than 0.')\\n if pre_context < 0:\\n raise ValueError('pre_context should not be less than 0.')\\n if post_context < 0:\\n raise ValueError('post_context should not be less than 0.')\",\n \"def validate_arguments(self):\\n if not self.args[0].is_constant():\\n raise ValueError(\\\"The first argument to kron must be constant.\\\")\",\n \"def ensure_default_constraints(self):\\r\\n positive_strings = ['variance', 'lengthscale', 'precision', 'decay', 'kappa']\\r\\n # param_names = self._get_param_names()\\r\\n currently_constrained = self.all_constrained_indices()\\r\\n to_make_positive = []\\r\\n for s in positive_strings:\\r\\n for i in self.grep_param_names(\\\".*\\\" + s):\\r\\n if not (i in currently_constrained):\\r\\n to_make_positive.append(i)\\r\\n if len(to_make_positive):\\r\\n self.constrain_positive(np.asarray(to_make_positive))\",\n \"def checkDataParameters(self):\\n while True:\\n overideSamplesFlag = input(\\\"Default data parameters are:-\\\\n\\\\n Number of samples = %d\\\\n Number of replicates = %d\\\\n Number of QC replicates = %d\\\\n Number of solvent replicates = %d\\\\n File polarity mode = %s\\\\n Column type = %s\\\\n\\\\nChange these sample parameters (Y or N)? [N]: \\\" %\\n (self.numberOfSamples, self.numberOfTechReps, self.numberOfQCReps, self.numberOfSolventReps, self.filePolarityMode, self.columnType)) or 'N'\\n if overideSamplesFlag.upper() == 'N':\\n break\\n elif overideSamplesFlag.upper() == 'Y':\\n self.setNumSamples()\\n self.__setNumberOfTechReps__()\\n self.__setNumberOfQCReps__()\\n self.__setNumberOfSolventReps__()\\n self.__setFilePolarityMode__()\\n self.__setColumnType__()\\n break\\n else:\\n print(\\\"\\\\nY or N required!\\\")\",\n \"def test_reset_params(self):\\n\\t\\t\\n\\t\\tparams = DEFAULT_PARAMS.copy()\\n\\t\\tparams['fit']=PL\\n\\t\\tvalid = self.watcher.valid_params(params)\\n\\t\\tself.assertTrue(valid)\\n\\t\\tparams = self.watcher.normalize_params(params)\\n\\t\\tself.assertEqual(params['fit'], POWER_LAW)\\n\\t\\t\\n\\t\\tparams = DEFAULT_PARAMS.copy()\\n\\t\\tparams['fit']=TPL\\n\\t\\tvalid = self.watcher.valid_params(params)\\n\\t\\tself.assertFalse(valid)\\n\\t\\t\\n\\t\\tparams = DEFAULT_PARAMS.copy()\\n\\t\\tparams['fit']=TPL\\n\\t\\tparams[PL_PACKAGE]=POWERLAW_PACKAGE\\n\\t\\tparams[XMAX]=XMAX_FORCE\\n\\n\\t\\tvalid = self.watcher.valid_params(params)\\n\\t\\tself.assertTrue(valid)\\n\\t\\tparams = self.watcher.normalize_params(params)\\n\\t\\tself.assertEqual(params['fit'], TRUNCATED_POWER_LAW)\",\n \"def _verify_arguments(self, kwargs: dict[str, Any]):\\n geom_stat_args = kwargs.keys() | self._stat._kwargs.keys()\\n unknown = (\\n geom_stat_args\\n - self.aesthetics()\\n - self.DEFAULT_PARAMS.keys() # geom aesthetics\\n - self._stat.aesthetics() # geom parameters\\n - self._stat.DEFAULT_PARAMS.keys() # stat aesthetics\\n - { # stat parameters\\n \\\"data\\\",\\n \\\"mapping\\\",\\n \\\"show_legend\\\", # layer parameters\\n \\\"inherit_aes\\\",\\n \\\"raster\\\",\\n }\\n ) # layer parameters\\n if unknown:\\n msg = (\\n \\\"Parameters {}, are not understood by \\\"\\n \\\"either the geom, stat or layer.\\\"\\n )\\n raise PlotnineError(msg.format(unknown))\",\n \"def checkParameters(self):\\n self.DEBUG(\\\"EDPluginControlStitchImagev1_0.checkParameters\\\")\\n self.checkMandatoryParameters(self.getDataInput(), \\\"Data Input is None\\\")\\n self.checkMandatoryParameters(self.getDataInput().getInputImages(), \\\"No input Images\\\")\",\n \"def BOUNDED_default(self):\\n sstream = RosettaFunctionConstructs._ATOMPAIR\\n sstream += \\\"BOUNDED {lower_bound: >.3f} {upper_bound: >.3f} 1 0.5 #\\\"\\n return sstream\",\n \"def default_hparams():\\n return {\\n \\\"value\\\": 0.,\\n \\\"name\\\": \\\"constant_connector\\\"\\n }\",\n \"def optional_parameters(self):\\n return ['bunches', 'target_thickness']\",\n \"def changeRingSetting(self):\\n #Input code to accommodate function of Ring setting\",\n \"def _check_valid_config(self):\\n default_keys = self.default_config.keys()\\n current_keys = self.config.keys()\\n\\n if default_keys != current_keys:\\n msg = f\\\"Config must have the following keys : {list(default_keys)}\\\"\\n self.logger.critical(msg)\\n sys.exit(0)\",\n \"def check_params():\\n print INITIAL_SCHEDULE\\n print SCHEDULE_SA[:10]\\n print CONTROL_DECISIONS\\n\\n print \\\"T_SLOT= %f\\\" % T_SLOT\\n print \\\"R=%f\\\" % R\\n print \\\"A=%f\\\" % A\\n print \\\"A_IO=%f\\\" % A_IO\\n print \\\"Q_INT=%d\\\" % Q_INT\",\n \"def is_ring(self): # -> bool:\\n ...\",\n \"def test_validate_has_default(self, args, value):\\n sch = scheme.Scheme(*args)\\n sch.validate(value)\",\n \"def test_defaults(self):\\n varp = VarPositional()\\n fparam = self.assert_iterable_and_get_fparam(varp)\\n assert fparam.name == 'args'\\n assert fparam.type == empty\\n assert not fparam.converter\\n assert not fparam.validator\\n assert not fparam.metadata\",\n \"def __Opt_value_depends_on_another_correct(self):\\n strTestName = 'Test of value propagation onto optional parameters'\\n RxCSObject = _RxCSobject()\\n\\n RxCSObject.paramAddMan('parameter1', 'Reference parameter #1')\\n RxCSObject.paramAddMan('parameter2', 'Reference parameter #2')\\n\\n RxCSObject.paramAddOpt('optpar1', 'Optional parameter #1', default='$$parameter1')\\n RxCSObject.paramType('optpar1', int)\\n RxCSObject.paramHE('optpar1', 4)\\n RxCSObject.paramLE('optpar1', 4)\\n\\n RxCSObject.paramAddOpt('optpar2', 'Optional parameter #1', default='$$parameter2')\\n RxCSObject.paramType('optpar2', int)\\n RxCSObject.paramHE('optpar2', 1)\\n RxCSObject.paramLE('optpar2', 1)\\n \\n RxCSObject.parameter1 = 4\\n RxCSObject.parameter2 = 1\\n \\n self.__parametersCheck_error(RxCSObject, 'correct', strTestName)\",\n \"def test_default_argument(self):\\n @converters.wrap\\n def inner_test(param: int = 5):\\n \\\"\\\"\\\"Make sure the default was used.\\\"\\\"\\\"\\n self.assertEqual(param, 5)\\n inner_test()\",\n \"def _checkSettings(self):\\n geomsThatNeedMeshSize = (\\\"1D slab\\\", \\\"1D cylinder\\\")\\n if self.geometry in geomsThatNeedMeshSize:\\n if self.meshSubdivisionsPerCm is None:\\n raise ValueError(\\n \\\"{} geometry requires `mesh points per cm` to be defined in cross sections.\\\".format(\\n self.geometry\\n )\\n )\\n if self.criticalBuckling != False:\\n raise ValueError(\\n \\\"{} geometry cannot model critical buckling. Please disable\\\".format(\\n self.geometry\\n )\\n )\",\n \"def test_tooFewModeParameters(self):\\n self._sendModeChange(\\\"+o\\\")\\n self._checkModeChange([])\\n errors = self.flushLoggedErrors(irc.IRCBadModes)\\n self.assertEqual(len(errors), 1)\\n self.assertSubstring(\\\"Not enough parameters\\\", errors[0].getErrorMessage())\",\n \"def check_invalid_bbb_args(config):\\n if config.mnet_only and config.hyper_gauss_init:\\n warnings.warn('Option \\\"hyper_gauss_init\\\" has no effect if no ' +\\n 'hypernetwork is used.')\\n if config.keep_orig_init and not \\\\\\n (config.mnet_only or config.hyper_gauss_init):\\n warnings.warn('Option \\\"keep_orig_init\\\" has no effect if main ' +\\n 'network has no parameters or option ' +\\n '\\\"hyper_gauss_init\\\" is not activated.')\\n if not config.mnet_only and config.hyper_gauss_init and \\\\\\n config.normal_init:\\n warnings.warn('Option \\\"normal_init\\\" has no effect if ' +\\n '\\\"hyper_gauss_init\\\" is activated.')\\n if config.mnet_only and not config.keep_orig_init and \\\\\\n config.normal_init:\\n warnings.warn('Option \\\"normal_init\\\" has no effect for main net ' +\\n 'initialization if \\\"keep_orig_init\\\" is not ' +\\n 'activated.')\\n if config.local_reparam_trick:\\n if hasattr(config, 'dropout_rate') and config.dropout_rate != -1:\\n raise ValueError('Dropout not implemented for network with ' +\\n 'local reparametrization trick.')\\n if hasattr(config, 'specnorm') and config.specnorm:\\n raise ValueError('Spectral norm not implemented for network ' +\\n 'with local reparametrization trick.')\\n if hasattr(config, 'batchnorm') and config.batchnorm or \\\\\\n hasattr(config, 'no_batchnorm') and not config.no_batchnorm:\\n raise ValueError('Batchnorm not implemented for network ' +\\n 'with local reparametrization trick.')\\n if not config.local_reparam_trick and config.disable_lrt_test:\\n warnings.warn('Option \\\"disable_lrt_test\\\" has no effect if the local-'\\n 'reparametrization trick is not used.')\\n\\n if hasattr(config, 'mean_only') and config.mean_only:\\n if hasattr(config, 'kl_scale') and config.kl_scale != 0 or \\\\\\n hasattr(config, 'kl_schedule') and config.kl_schedule != 0:\\n raise ValueError('Prior-matching is not applicable for ' +\\n 'deterministic networks.')\\n if config.regularizer != 'mse':\\n raise ValueError('Only \\\"mse\\\" regularizer can be applied to ' +\\n 'deterministic networks.')\\n if config.local_reparam_trick:\\n raise ValueError('Local-reparametrization trick cannot be ' +\\n 'applied to non-Gaussian networks.')\\n if config.hyper_gauss_init:\\n raise ValueError('Gaussian-hypernet init cannot be applied to ' +\\n 'non-Gaussian networks.')\\n if hasattr(config, 'use_prev_post_as_prior') and \\\\\\n config.use_prev_post_as_prior:\\n raise ValueError('Option \\\"use_prev_post_as_prior\\\" cannot be ' +\\n 'enforced for deterministic networks.')\\n if config.train_sample_size > 1:\\n warnings.warn('A \\\"train_sample_size\\\" greater than 1 doesn\\\\'t ' +\\n 'make sense for a deterministic network.')\\n if config.val_sample_size > 1:\\n warnings.warn('A \\\"val_sample_size\\\" greater than 1 doesn\\\\'t ' +\\n 'make sense for a deterministic network.')\\n if config.disable_lrt_test:\\n warnings.warn('Option \\\"disable_lrt_test\\\" not applicable to ' +\\n 'deterministic networks.')\\n if config.use_logvar_enc:\\n warnings.warn('Option \\\"use_logvar_enc\\\" not applicable to ' +\\n 'deterministic networks.')\\n if config.regularizer != 'mse':\\n if hasattr(config, 'hnet_reg_batch_size') and \\\\\\n config.hnet_reg_batch_size != -1:\\n raise NotImplementedError('Mini-batching of regularizer other ' +\\n 'than the MSE reg is not implemented ' +\\n 'yet.')\\n\\n if config.radial_bnn:\\n if config.local_reparam_trick:\\n raise ValueError('Local-reparametrization trick is not compatible '+\\n 'with Radial BNNs since the weights posterior is '+\\n 'not Gaussian anymore.')\\n if config.regularizer != 'mse':\\n raise NotImplementedError('Only the MSE regularizer has been ' +\\n 'implemented for radial BNN ' +\\n 'distributions.')\\n if hasattr(config, 'use_prev_post_as_prior') and \\\\\\n config.use_prev_post_as_prior:\\n raise NotImplementedError('Option \\\"use_prev_post_as_prior\\\" not ' +\\n 'implemented for Radial BNN.')\",\n \"def _validate_parameter_combinations(self):\\n parameters = [\\\"type\\\", \\\"path\\\", \\\"mode\\\", \\\"default\\\", \\\"min\\\", \\\"max\\\"]\\n parameters = {key: getattr(self, key, None) for key in parameters}\\n type = parameters.pop(\\\"type\\\")\\n\\n # validate parameter combination\\n if type in self._TYPE_COMBINATION_MAPPING:\\n valid_parameters = self._TYPE_COMBINATION_MAPPING[type]\\n for key, value in parameters.items():\\n if key not in valid_parameters and value is not None:\\n msg = \\\"Invalid parameter for '{}' Input, parameter '{}' should be None but got '{}'\\\"\\n raise ValidationException(\\n message=msg.format(type, key, value),\\n no_personal_data_message=msg.format(\\\"[type]\\\", \\\"[parameter]\\\", \\\"[parameter_value]\\\"),\\n error_category=ErrorCategory.USER_ERROR,\\n target=ErrorTarget.PIPELINE,\\n )\",\n \"def _getIsValidParameters(self):\\n return True, ''\",\n \"def checkParameters(self):\\n self.DEBUG(\\\"EDPluginWaitMultiFile.checkParameters\\\")\\n self.checkMandatoryParameters(self.dataInput, \\\"Data Input is None\\\")\\n self.checkMandatoryParameters(self.dataInput.expectedFile, \\\"Data Input is None\\\")\\n self.checkMandatoryParameters(self.dataInput.expectedSize, \\\"Data Input is None\\\")\",\n \"def check_common_args(args, function_name,\\n valid_functions=['gaperture', 'gmap', 'gfind'],\\n allow_no_coords=False):\\n\\n try:\\n function_name = function_name.strip().lower()\\n except AttributeError:\\n raise gPhotonArgsError(\\\"Invalid function: {f}\\\".format(f=function_name))\\n\\n if not function_name in valid_functions:\\n raise gPhotonArgsError(\\\"Invalid function: {f}\\\".format(f=function_name))\\n\\n try:\\n args.band = args.band.strip()\\n except AttributeError:\\n raise SystemExit(\\\"Invalid band: {b}\\\".format(b=args.band))\\n\\n # This will ensure calpath has a trailing '/'.\\n if function_name in ['gaperture', 'gmap']:\\n args.calpath = os.path.join(args.calpath, '')\\n # [Future]: Consider fixing this statement. This is breaking nosetests,\\n # but it's not a bad idea...\\n # if not os.path.isdir(args.calpath):\\n # raise SystemExit(\\\"Calibration path not found: \\\" + args.calpath)\\n\\n if (not (args.ra and args.dec) and not args.skypos and\\n not allow_no_coords):\\n raise SystemExit(\\\"Must specify either both RA/DEC or SKYPOS.\\\")\\n elif (args.ra and args.dec) and args.skypos:\\n if not (args.ra == args.skypos[0] and args.dec == args.skypos[1]):\\n raise SystemExit(\\\"Must specify either RA/DEC or SKYPOS, not both.\\\")\\n elif (args.ra and args.dec) and not args.skypos:\\n args.skypos = [args.ra, args.dec]\\n elif not (args.ra and args.dec) and args.skypos:\\n args.ra, args.dec = args.skypos\\n\\n if args.suggest and function_name in ['gfind', 'gaperture']:\\n (args.ra, args.dec, args.radius, args.annulus1,\\n args.annulus2) = dbt.suggest_parameters(args.band, args.skypos,\\n verbose=0)\\n args.skypos = [args.ra, args.dec]\\n if args.verbose:\\n print(\\\"Recentering on [\\\"+str(args.ra)+\\\", \\\"+str(args.dec)+\\\"]\\\")\\n print(\\\"Setting radius to \\\"+str(args.radius))\\n print(\\\"Setting annulus to [\\\"+str(args.annulus1)+\\\", \\\"+\\n str(args.annulus2)+\\\"]\\\")\\n\\n if args.skypos:\\n if np.array(args.skypos).shape != (2,):\\n raise gPhotonArgsError(\\n \\\"Skypos (--skypos) must be a 2-element array.\\\")\\n args.ra, args.dec = args.skypos\\n\\n if args.ra and not 0. <= args.ra <= 360.:\\n raise SystemExit(\\n \\\"RA of {ra} does not satisfy 0 <= RA <= 360\\\".format(ra=args.ra))\\n\\n if args.dec and not -90 <= args.dec <= 90:\\n raise SystemExit(\\n \\\"Dec of {dec} does not satisfy -90 <= DEC <= 90\\\".format(\\n dec=args.dec))\\n\\n if args.detsize and args.detsize <= 0.:\\n raise SystemExit(\\\"Effective field diameter (--detsize) must be > 0\\\")\\n\\n if args.maxgap and args.maxgap <= 0.:\\n raise SystemExit(\\\"Maximum gap length (--maxgap) must be > 0 seconds.\\\")\\n if args.minexp and args.minexp <= 0.:\\n raise SystemExit(\\\"Minimum valid exposure depth (--minexp) must be > 0\\\"\\n \\\" seconds.\\\")\\n\\n if args.retries and args.retries <= 0.:\\n raise SystemExit(\\\"Number of retries (--retries) must be > 0.\\\")\\n\\n # tmin / tmax must be defined and reasonable\\n if not args.tmin or args.tmin <= 0.:\\n raise SystemExit(\\\"T0 (--t0) must be > 0.\\\")\\n if not args.tmax or args.tmax <= 0.:\\n raise SystemExit(\\\"T1 (--t1) must be > 0.\\\")\\n if args.tmin >= args.tmax:\\n raise SystemExit(\\\"Minimum time (--t0) must be < maximum time (--t1).\\\")\\n\\n if args.trange:\\n if np.array(args.trange).shape == (2, ):\\n args.trange = [args.trange]\\n if not (len(np.array(args.trange).shape) == 2 and\\n np.array(args.trange).shape[1] == 2):\\n raise SystemExit(\\\"trange (--trange) must be a pairwise list.\\\")\\n # Individually check the entries for sanity\\n for t in args.trange:\\n if t[0] <= 0 or t[1] <= 0:\\n raise SystemExit('Times must be positive: {t}'.format(t=t))\\n if t[1] <= t[0]:\\n raise SystemExit('Start time ({t0}) must preceed end time'\\n ' ({t1})'.format(t0=t[0], t1=t[1]))\\n elif not allow_no_coords and function_name in ['gmap', 'gaperture']:\\n args.trange = dbt.fGetTimeRanges(args.band, args.skypos,\\n trange=[args.tmin, args.tmax],\\n maxgap=args.maxgap, minexp=args.minexp,\\n detsize=args.detsize,\\n skyrange=args.skyrange)\\n else:\\n # If no coordinates specified then use a huge time range for now.\\n args.trange = [args.tmin, args.tmax]\\n\\n return args\",\n \"def test_no_default_value(self):\\n dim = Dimension(\\\"yolo\\\", \\\"uniform\\\", -3, 4)\\n assert dim.default_value is None\",\n \"def _handleRequestCableCheckParameters(self, data):\\r\\n print(\\\"\\\\\\\"Request Cable Check Parameters\\\\\\\" received\\\")\\r\\n message = self.whitebeet.v2gParseRequestCableCheckParameters(data)\\r\\n if 'dc' in message:\\r\\n print(\\\"SOC: {}%\\\".format(message['dc']['soc']))\\r\\n try:\\r\\n self.whitebeet.v2gSetDcCableCheckParameters(0, 1)\\r\\n except Warning as e:\\r\\n print(\\\"Warning: {}\\\".format(e))\\r\\n except ConnectionError as e:\\r\\n print(\\\"ConnectionError: {}\\\".format(e))\",\n \"def test_validate_default_kw_only_follows_non_default_kw_only(self):\\n fsig = FSignature(\\n [forge.kwarg('a', default=None), forge.kwarg('b')],\\n __validate_parameters__=False,\\n )\\n fsig.validate()\",\n \"def test_default_parse_args(self):\\n self.assertEqual(self.args.router, poll.DEFAULT_ROUTER)\\n self.assertEqual(self.args.port, poll.DEFAULT_PORT)\\n self.assertEqual(self.args.interval, poll.DEFAULT_INTERVAL)\\n self.assertEqual(self.args.community, poll.DEFAULT_COMMUNITY)\\n self.assertEqual(self.args.iterations, poll.DEFAULT_ITERATIONS)\",\n \"def test_config_option_required_default():\\n class Config(config.Config):\\n a = config.option(int, required=True, default=12, help=\\\"\\\")\\n\\n c = config.structure({}, Config)\\n assert c.a == 12\\n\\n c = config.structure({\\\"a\\\": 23}, Config)\\n assert c.a == 23\\n\\n with pytest.raises(config.ConfigError):\\n config.structure({\\\"a\\\": None}, Config)\",\n \"def test_set_outside_bounds_default_value(self):\\n with pytest.raises(ValueError):\\n Real(\\\"yolo\\\", \\\"uniform\\\", -3, 2, default_value=5)\",\n \"def test_defaults(self):\\n params = DefaultsInterface()\\n # make sure from_param_server can be called repeatedly\\n params.from_param_server()\\n\\n self.assertEqual(params.verbosity_param_w_default, 'info')\\n\\n self.assertEqual(params.int_param_w_default, 1)\\n self.assertAlmostEqual(params.double_param_w_default, 1.1)\\n self.assertEqual(params.str_param_w_default, \\\"Hello World\\\")\\n self.assertEqual(params.bool_param_w_default, True)\\n self.assertEqual(params.long_param_w_default_int, 1)\\n self.assertEqual(params.long_param_w_default_int_str, -1)\\n self.assertEqual(params.long_param_w_default_long_string, 9223372036854775807)\\n\\n self.assertEqual(params.vector_int_param_w_default, [1, 2, 3])\\n self.assertEqual(params.vector_double_param_w_default, [1.1, 1.2, 1.3])\\n self.assertEqual(params.vector_string_param_w_default, [\\\"Hello\\\", \\\"World\\\"])\\n\\n self.assertEqual(params.map_param_w_default, {\\\"Hello\\\": \\\"World\\\"})\\n self.assertEqual(params.enum_int_param_w_default, 1)\\n self.assertEqual(params.enum_str_param_w_default, \\\"One\\\")\",\n \"def _check_args(self):\\n if not isinstance(self.digits, str):\\n raise TypeError('digits must be of type string.')\\n if isinstance(self.n_points, float):\\n self.n_points = int(self.n_points)\\n if not isinstance(self.n_points, int):\\n raise TypeError('n_points must be of type integer.')\\n if self.n_points < 0:\\n raise ValueError('n_points must be positive.')\",\n \"def test_defaultValues(self):\\n argV = []\\n self.usage.parseOptions(argV)\\n self.failUnlessEqual(self.usage.opts['fooint'], 392)\\n self.assert_(isinstance(self.usage.opts['fooint'], int))\\n self.failUnlessEqual(self.usage.opts['foofloat'], 4.23)\\n self.assert_(isinstance(self.usage.opts['foofloat'], float))\\n self.failUnlessEqual(self.usage.opts['eggint'], None)\\n self.failUnlessEqual(self.usage.opts['eggfloat'], None)\",\n \"def test_glass_capacity__has_expected_default_value():\\n glass = moet.create_glass(\\\"A\\\")\\n assert glass.capacity == 250\",\n \"def test_default_arguments() -> None:\\n\\n @argcomb(a=\\\"b\\\")\\n def f(a: int = 1, b: int = 2) -> None:\\n ...\\n\\n # valid since ``a`` is the default value\\n f(a=1)\\n\\n with pytest.raises(InvalidArgumentCombination):\\n # invalid since ``b`` is the default value\\n f(a=2, b=2)\",\n \"def _check_param_grad_parity(\\n _baseline_model: nn.Module,\\n _test_model: nn.Module,\\n ):\\n self.assertEqual(len(list(_baseline_model.parameters())), 1)\\n self.assertEqual(len(list(_test_model.parameters())), 1)\\n for flat_param, orig_param in zip(\\n _baseline_model.parameters(), _test_model.parameters()\\n ):\\n # Baseline is permitted to have padding\\n self.assertGreaterEqual(flat_param.numel(), orig_param.numel())\\n unpadded_param_numel = orig_param.numel()\\n # For `NO_SHARD`, `use_orig_params=True` presents unflattened\\n # parameters, while `False` presents flattened ones\\n torch.testing.assert_close(\\n flat_param[:unpadded_param_numel], orig_param.flatten()\\n )\\n # Gradient numel is different if right after `no_sync()` since\\n # the gradient is unsharded, while the parameter is sharded\\n unpadded_grad_numel = orig_param.grad.numel()\\n # For `use_orig_params=False`, the unsharded gradient is\\n # flattened, while for `True`, it is unflattened\\n torch.testing.assert_close(\\n flat_param.grad[:unpadded_grad_numel].reshape(\\n orig_param.grad.shape\\n ),\\n orig_param.grad,\\n )\",\n \"def _check_input(self, **kwargs):\\n\\n combi_a = ['nxny', 'dxdy', 'ul_corner']\\n combi_b = ['nxny', 'dxdy', 'll_corner']\\n if all(kwargs[k] is not None for k in combi_a):\\n nx, ny = kwargs['nxny']\\n dx, dy = kwargs['dxdy']\\n x0, y0 = kwargs['ul_corner']\\n if (dx <= 0.) or (dy >= 0.):\\n raise ValueError('dxdy and input params not compatible')\\n origin = 'upper-left'\\n elif all(kwargs[k] is not None for k in combi_b):\\n nx, ny = kwargs['nxny']\\n dx, dy = kwargs['dxdy']\\n x0, y0 = kwargs['ll_corner']\\n if (dx <= 0.) or (dy <= 0.):\\n raise ValueError('dxdy and input params not compatible')\\n origin = 'lower-left'\\n else:\\n raise ValueError('Input params not compatible')\\n\\n self._nx = int(nx)\\n self._ny = int(ny)\\n if (self._nx <= 0) or (self._ny <= 0):\\n raise ValueError('nxny not valid')\\n self._dx = float(dx)\\n self._dy = float(dy)\\n self._x0 = float(x0)\\n self._y0 = float(y0)\\n self._origin = origin\\n\\n # Check for pixel ref\\n self._pixel_ref = kwargs['pixel_ref'].lower()\\n if self._pixel_ref not in ['corner', 'center']:\\n raise ValueError('pixel_ref not recognized')\",\n \"def check_default(self, sec, name, default):\\n if default is None:\\n raise\\n\\n # print debug message saying default value was used\\n if not default:\\n default_text = 'empty string'\\n else:\\n default_text = default\\n\\n msg = \\\"Setting [{}] {} to default value ({})\\\".format(sec,\\n name,\\n default_text)\\n if self.logger:\\n self.logger.debug(msg)\\n else:\\n print('DEBUG: {}'.format(msg))\\n\\n # set conf with default value so all defaults can be added to\\n # the final conf and warning only appears once per conf item\\n # using a default value\\n self.set(sec, name, default)\",\n \"def getParameters(self, greenRectangleStartPoint, clearanceRectangleStartPoint, greenTime, clearanceTime, \\n distance_Green, distance_Clearance, evTrajectoryTimePoint, evTrajectoryDistancePoint, \\n transitTrajectoryTimePoint, transitTrajectoryDistancePoint, truckTrajectoryTimePoint, \\n truckTrajectoryDistancePoint, carTrajectoryTimePoint, carTrajectoryDistancePoint, \\n connectedVehicleTrajectoryTimePoint, connectedVehicleTrajectoryDistancePoint, textString, xAxisRange):\\n self.greenRectangleStartPoint = greenRectangleStartPoint\\n self.clearanceRectangleStartPoint = clearanceRectangleStartPoint\\n self.greenTime = greenTime\\n self.clearanceTime = clearanceTime\\n self.distance_Green = distance_Green\\n self.distance_Clearance = distance_Clearance\\n self.evTrajectoryTimePoint, self.evTrajectoryDistancePoint = evTrajectoryTimePoint, evTrajectoryDistancePoint,\\n self.transitTrajectoryTimePoint, self.transitTrajectoryDistancePoint = transitTrajectoryTimePoint, transitTrajectoryDistancePoint\\n self.truckTrajectoryTimePoint, self.truckTrajectoryDistancePoint = truckTrajectoryTimePoint, truckTrajectoryDistancePoint\\n self.carTrajectoryTimePoint, self.carTrajectoryDistancePoint = carTrajectoryTimePoint, carTrajectoryDistancePoint\\n self.connectedVehicleTrajectoryTimePoint, self.connectedVehicleTrajectoryDistancePoint = connectedVehicleTrajectoryTimePoint, connectedVehicleTrajectoryDistancePoint\\n self.textString = textString\\n self.xAxisRange = xAxisRange\",\n \"def check_params(self):\\n raise NotImplementedError\",\n \"def getDefaultBrush(*args, **kwargs)->AnyStr:\\n pass\",\n \"def _validatePypetParameters(self, runParams):\\n\\n # fix rng seed, which is saved as a string if None\\n if \\\"seed\\\" in runParams:\\n if runParams[\\\"seed\\\"] == \\\"None\\\":\\n runParams[\\\"seed\\\"] = None\\n return runParams\",\n \"def check_params(self, X: TwoDimArray, y: OneDimArray = None) -> None:\\n\\n super().check_params(X)\",\n \"def check_params(self, X: TwoDimArray, y: OneDimArray = None) -> None:\\n\\n super().check_params(X)\",\n \"def check_params(self, X: TwoDimArray, y: OneDimArray = None) -> None:\\n\\n super().check_params(X)\",\n \"def check_params_set():\\n critical = {'machineinfo' : MACHINEID, \\n 'error_serverinfo' : ERROR_SERVER, \\n 'serverinfo' : SERVER}\\n for i, val in critical.iteritems():\\n if not val:\\n print \\\"ERROR: Set value for \\\\\\\"%s\\\\\\\" in baseconfig.cfg file first\\\\n\\\" % i\\n sys.exit(1)\",\n \"def bond_check(distance, minimum=0, maximum=1.5): # when variables are set equal to => default\\n if distance > minimum and distance < maximum:\\n return True\\n return False\",\n \"def test_blank(self):\\n self._calibration_test(\\\"blank\\\")\",\n \"def test_mismatchedParams(self):\\n self.assertRaises(irc.IRCBadModes, irc.parseModes, \\\"+k\\\", [], self.paramModes)\\n self.assertRaises(\\n irc.IRCBadModes,\\n irc.parseModes,\\n \\\"+kl\\\",\\n [\\\"foo\\\", \\\"10\\\", \\\"lulz_extra_param\\\"],\\n self.paramModes,\\n )\",\n \"def test_defaults(self):\\n vark = VarKeyword()\\n name, fparam = self.assert_mapping_and_get_fparam(vark)\\n assert name == 'kwargs'\\n assert fparam.type == empty\\n assert not fparam.converter\\n assert not fparam.validator\\n assert not fparam.metadata\",\n \"def apply_default_constraints(self):\\n try:\\n self.apply_secthresh(pipeline_weaksec(self.koi))\\n except NoWeakSecondaryError:\\n logging.warning('No secondary eclipse threshold set for {}'.format(self.koi))\\n self.set_maxrad(default_r_exclusion(self.koi))\",\n \"def test_no_default_value(self):\\n dim = Integer(\\\"yolo\\\", \\\"uniform\\\", -3, 4)\\n assert dim.default_value is None\",\n \"def test_nondefault_nonbonded_cutoff(self):\\n topology = Molecule.from_smiles(\\\"[#18]\\\").to_topology()\\n topology.box_vectors = [3, 3, 3] * unit.nanometer\\n\\n force_field = ForceField()\\n\\n vdw_handler = vdWHandler(version=0.4)\\n vdw_handler.cutoff = 7.89 * unit.angstrom\\n vdw_handler.scale14 = 1.0\\n\\n vdw_handler.add_parameter(\\n {\\n \\\"smirks\\\": \\\"[#18:1]\\\",\\n \\\"epsilon\\\": 1.0 * unit.kilojoules_per_mole,\\n \\\"sigma\\\": 1.0 * unit.angstrom,\\n }\\n )\\n force_field.register_parameter_handler(vdw_handler)\\n\\n electrostatics_handler = ElectrostaticsHandler(version=0.3)\\n electrostatics_handler.cutoff = 7.89 * unit.angstrom\\n electrostatics_handler.periodic_potential = \\\"PME\\\"\\n force_field.register_parameter_handler(electrostatics_handler)\\n\\n library_charges = LibraryChargeHandler(version=0.3)\\n library_charges.add_parameter(\\n {\\n \\\"smirks\\\": \\\"[#18:1]\\\",\\n \\\"charge1\\\": 0.0 * unit.elementary_charge,\\n }\\n )\\n force_field.register_parameter_handler(library_charges)\\n\\n system = force_field.create_openmm_system(topology)\\n\\n found_cutoff = (\\n system.getForce(0).getCutoffDistance().value_in_unit(openmm_unit.angstrom)\\n )\\n\\n assert abs(found_cutoff - 7.89) < 1e-6\",\n \"def __check_args_val(self):\\n if self.__num_prev_scans < 0:\\n error_msg = \\\"num_prev_scans must be greater than or equal to zero\\\"\\n raise ValueError(error_msg)\",\n \"def test_init_with_default_value(self):\\n with pytest.raises(NotImplementedError):\\n Dimension(\\\"yolo\\\", \\\"uniform\\\", -3, 4, default_value=4)\",\n \"def check_params(params):\\n\\n required = ['initlandmarks']\\n for r in required:\\n assert r in params.keys(), 'Params must include {}'.format(r)\",\n \"def is_default(dimension):\\n\\n print(f'{dimension}-dimensional space'.upper())\\n\\n while(True):\\n is_default = input('Default parameters? ')\\n try:\\n if is_default == 'y' or is_default == 'yes': \\n return True\\n elif is_default == 'n' or is_default == 'no':\\n return False\\n except Exception as e:\\n print('Exception: '.upper(), e)\\n traceback.print_tb(e.__traceback__)\",\n \"def test_missing_arg_repr():\\n argspec = inspect.getfullargspec(exceptional.wrap)\\n assert repr(argspec.kwonlydefaults[\\\"message\\\"]) == \\\"<MISSING>\\\"\",\n \"def validate_client_parameters(cmd, namespace):\\n n = namespace\\n\\n if not n.connection_string:\\n n.connection_string = get_config_value(cmd, 'communication', 'connection_string', None)\",\n \"def check_valid_keys(self, obj):\\n invalid_keys = [\\n x for x in obj if x not in self.defaults\\n ]\\n if invalid_keys:\\n raise ValueError(\\n \\\"No such model parameters: %s. Valid parameters are: %s\\\"\\n % (\\\" \\\".join(invalid_keys), \\\" \\\".join(self.defaults)))\",\n \"def getDefaultParams():\\n defpar = [\\n # coordinate system\\n ['crd_sys', \\\"'sph'\\\", 'Coordinate system'],\\n ['nx', '[60, 40, 30]', 'Number of grid points in the first dimension'],\\n ['xbound', '[0.1*au, 30.*au, 110.*au, 250.*au]', 'Number of radial grid points'],\\n ['ny', '[10,30, 30, 10]',\\n 'Number of grid points in the second dimension'],\\n ['ybound', '[0.1, pi/6., pi/2., 5.*pi/6., 3.04]',\\n 'Number of radial grid points'],\\n ['nz', '[361]', 'Number of grid points in the third dimension'],\\n ['zbound', '[0., 2.0*pi]', 'Number of radial grid points'],\\n # star related\\n ['tstar', '[3900.0]', 'Temperature of star'],\\n ['mstar', '[1.0*ms]', 'Mass of the star(s)'],\\n ['rstar', '[2.5*rs]', 'Radius of star'],\\n # gas density \\n ['Rin', '[0.1*au, 80*au]', 'inner bounding edge'],\\n ['Rin_w', '[0, 1*au]', 'gaussian taper before inner edge'], \\n ['Rout', '[30*au, 120*au]', 'outer bounding edge'],\\n ['Rout_w', '[1*au, 1*au]', 'gaussian taper after outer edge'], \\n ['sigp', '[-1.0, -1.5]', 'power-law surface density'],\\n ['sig0', '[1e2, 1e1]', 'surface density at Rin in g/cm^2'], \\n ['ring_r', '[50*au]', 'location of gaussian ring'], \\n ['ring_win', '[5*au]', 'width of gaussian ring in inner radius'],\\n ['ring_wout', '[5*au]', 'width of gaussian ring in outer radius'], \\n ['ring_a', '[1e2]', 'surface density at center of ring in g/cm^2]'], \\n ['cutgdens', '1e-30', 'cut for density'], \\n ['Rt', '100*au', 'radius for scale height'], \\n ['Ht', '10*au', 'scale height'], \\n ['qheight', '1.25', 'height power-law'], \\n # gas species\\n ['gasspec_mol_name', \\\"['12co']\\\", 'name of molecule'],\\n ['gasspec_mol_abun', '[5e-5]', 'mass abundance '],\\n ['gasspec_mol_dbase_type', \\\"['leiden']\\\", ''],\\n ['gasspec_mol_freezeout_dfact', '[1e-3]',\\n 'Factor by which the molecular abundance should be decreased in the freeze-out zone'],\\n ['mol_freeze_Ht', '[24*au]', 'Height at Rt, with index=qheight, for freeze out to happen'],\\n ['mol_freeze_del_hfrac', '0.2', 'Gaussian taper for freeze-out. del H = h * hfrac'],\\n ['mol_snowR', '[20*au]', 'Radius when freeze out begins to happen'],\\n # dust density\\n # flat power-law parts\\n ['dRin', '[0.1*au, 80*au]', 'inner bounding edge'],\\n ['dRin_w', '[0, 1*au]', 'gaussian taper before inner edge'], \\n ['dRout', '[30*au, 120*au]', 'outer bounding edge'],\\n ['dRout_w', '[1*au, 1*au]', 'gaussian taper after outer edge'], \\n ['dsigp', '[-1.0, -1.5]', 'power-law surface density'],\\n ['dsig0', '[1e2, 1e1]', 'surface density at Rin'],\\n # Lynden-Bell parts\\n ['dLB_Rin', '[0.1*au]', 'inner bounding radius'], \\n ['dLB_Rsig', '[30*au]', 'charcteristic radius'],\\n ['dLB_sigp', '[-1.0]', 'power-law exponent. Careful, the sign is different from the usual function by a negative sign for consistency with flat power-law'], \\n ['dLB_sig0', '[1e2]', 'surface density'], \\n # ring parts\\n ['dring_r', '[50*au]', 'location of gaussian ring'],\\n ['dring_win', '[5*au]', 'width of gaussian ring in inner radius'],\\n ['dring_wout', '[5*au]', 'width of gaussian ring in outer radius'], \\n ['dring_a', '[1e2]', 'surface density at center of ring in g/cm^2]'],\\n ['cutddens', '1e-30', 'cut for dust density'],\\n ['dRt', '[100*au]', 'radius for scale height for each grain size'], \\n ['dHt', '[10*au]', 'scale height for each grain size'], \\n ['dqheight', '[1.25]', 'scale height power-law for dust'], \\n # temperature\\n ['T0mid', '50', 'mid plane temperature at Rt'],\\n ['T0atm', '50', 'atmosphere temperature at Rt'],\\n ['zqratio', '3', 'factor of Ht of where temperature transition occurs'],\\n ['qmid', '-0.5', 'midplane temperature exponent'],\\n ['qatm', '-0.5', 'atmosphere temperature exponent'],\\n ['hdel', '2', 'temperature transition exponent '],\\n ['cuttemp', '10', 'temperature cut'], \\n # alignment\\n ['altype', \\\"'toroidal'\\\", 'alignment type']\\n ]\\n\\n return defpar\",\n \"def __optional_is_not_given(self):\\n\\n strTestName = 'Optional parameter is not given (incorrect)'\\n RxCSObject = _RxCSobject()\\n\\n RxCSObject.paramAddOpt('optional_parameter', 'Optional parameter')\\n\\n self.__parametersCheck_error(RxCSObject, 'correct', strTestName)\",\n \"def _init_checked(self):\\n assert all(\\n len(val) <= 2\\n or (\\n len(val) == 3\\n and all(\\n self.extra_parameters[parent_var] == self.fuse_parameter\\n for parent_var in val\\n )\\n )\\n for val in self.reversed_extra_parameters.values()\\n )\\n assert all(\\n (\\n any(\\n parent_var in self.left_sided_parameters\\n or parent_var in self.right_sided_parameters\\n for parent_var in parent_vars\\n )\\n and any(\\n parent_var in self.both_sided_parameters\\n for parent_var in parent_vars\\n )\\n )\\n or all(\\n self.extra_parameters[parent_var] == self.fuse_parameter\\n for parent_var in parent_vars\\n )\\n for parent_vars in self.reversed_extra_parameters.values()\\n if len(parent_vars) == 2\\n )\",\n \"def check_arg_compatibility(args: argparse.Namespace):\\n\\n # Require at least one stopping criteria\\n check_condition(any((args.max_samples,\\n args.max_updates,\\n args.max_seconds,\\n args.max_checkpoints,\\n args.max_num_epochs,\\n args.max_num_checkpoint_not_improved)),\\n 'Please specify at least one stopping criteria: --max-samples --max-updates --max-checkpoints '\\n '--max-num-epochs --max-num-checkpoint-not-improved')\\n\\n # Check and possibly adapt the parameters for source factors\\n n_source_factors = len(args.validation_source_factors)\\n if len(args.source_factors_combine) > 1:\\n check_condition(n_source_factors == len(args.source_factors_combine),\\n 'The number of combination strategies for source '\\n 'factors does not match the number of source factors.')\\n else:\\n # Length 1: expand the list to the appropriate length\\n args.source_factors_combine = args.source_factors_combine * n_source_factors\\n if len(args.source_factors_share_embedding) > 1:\\n check_condition(n_source_factors == len(args.source_factors_share_embedding),\\n 'The number of vocabulary sharing flags for source '\\n 'factors does not match the number of source factors.')\\n else:\\n # Length 1: expand the list to the appropriate length\\n args.source_factors_share_embedding = args.source_factors_share_embedding * n_source_factors\\n\\n # Check and possibly adapt the parameters for target factors\\n n_target_factors = len(args.validation_target_factors)\\n if len(args.target_factors_combine) > 1:\\n check_condition(n_target_factors == len(args.target_factors_combine),\\n 'The number of combination strategies for target '\\n 'factors does not match the number of target factors.')\\n else:\\n # Length 1: expand the list to the appropriate length\\n args.target_factors_combine = args.target_factors_combine * n_target_factors\\n if len(args.target_factors_share_embedding) > 1:\\n check_condition(n_target_factors == len(args.target_factors_share_embedding),\\n 'The number of vocabulary sharing flags for target '\\n 'factors does not match the number of target factors.')\\n else:\\n # Length 1: expand the list to the appropriate length\\n args.target_factors_share_embedding = args.target_factors_share_embedding * n_target_factors\",\n \"def test_config_option_required_no_default():\\n class Config(config.Config):\\n a = config.option(int, required=True, help=\\\"\\\")\\n\\n with pytest.raises(config.ConfigError):\\n config.structure({}, Config)\\n\\n with pytest.raises(config.ConfigError):\\n config.structure({\\\"a\\\": None}, Config)\\n\\n c = config.structure({\\\"a\\\": 12}, Config)\\n assert c.a == 12\",\n \"def updateParameters(self):\\n\\n if self.params[1].value:\\n if arcpy.Exists(self.params[1].value):\\n try:\\n min_value = arcpy.GetRasterProperties_management(self.params[1].value, \\\"MINIMUM\\\")[0]\\n\\n if str(self.params[8].value) != str(self.params[1].value):\\n self.params[7].value = True\\n self.params[8].value = str(self.params[1].value)\\n else:\\n self.params[7].value = False\\n\\n if str(min_value) == \\\"0\\\":\\n if self.params[7].value == True:\\n self.params[2].value = True\\n self.params[3].enabled = True\\n self.params[7].value = False\\n else:\\n self.params[2].value = False\\n self.params[3].enabled = False\\n\\n except arcpy.ExecuteError:\\n pass\\n\\n if self.params[2].value == True:\\n self.params[3].enabled = True\\n else:\\n self.params[3].enabled = False\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.57292235","0.5649407","0.5493077","0.54790646","0.5410326","0.54050815","0.539264","0.53915656","0.5389374","0.53777575","0.53308314","0.5328452","0.52771133","0.5256819","0.5243553","0.52401507","0.5219868","0.5205472","0.5191979","0.5157206","0.5150775","0.5142031","0.5122428","0.51155806","0.51153743","0.5106601","0.50937843","0.5071658","0.50541955","0.5031099","0.50270516","0.50193727","0.50027615","0.49982345","0.49870414","0.49774718","0.49754518","0.4965185","0.49505603","0.49380457","0.4922247","0.49185675","0.49148628","0.4899217","0.48847106","0.48770157","0.4873674","0.48686484","0.48651716","0.48632613","0.48606342","0.48498318","0.48480135","0.48349708","0.48341823","0.48312348","0.4831001","0.482618","0.48219973","0.48171017","0.48102918","0.48040098","0.48018512","0.48017666","0.48012406","0.47983322","0.47972515","0.4796116","0.4794698","0.4792781","0.47926706","0.47732306","0.47700727","0.4764726","0.4756439","0.47494152","0.4745018","0.4745018","0.4745018","0.4732777","0.47301435","0.47300825","0.47228512","0.47208825","0.47037193","0.47033855","0.46986023","0.46928918","0.46893755","0.46838656","0.46836555","0.4677695","0.46762833","0.4670965","0.4666347","0.46588647","0.4658635","0.4657854","0.4657763","0.46570498"],"string":"[\n \"0.57292235\",\n \"0.5649407\",\n \"0.5493077\",\n \"0.54790646\",\n \"0.5410326\",\n \"0.54050815\",\n \"0.539264\",\n \"0.53915656\",\n \"0.5389374\",\n \"0.53777575\",\n \"0.53308314\",\n \"0.5328452\",\n \"0.52771133\",\n \"0.5256819\",\n \"0.5243553\",\n \"0.52401507\",\n \"0.5219868\",\n \"0.5205472\",\n \"0.5191979\",\n \"0.5157206\",\n \"0.5150775\",\n \"0.5142031\",\n \"0.5122428\",\n \"0.51155806\",\n \"0.51153743\",\n \"0.5106601\",\n \"0.50937843\",\n \"0.5071658\",\n \"0.50541955\",\n \"0.5031099\",\n \"0.50270516\",\n \"0.50193727\",\n \"0.50027615\",\n \"0.49982345\",\n \"0.49870414\",\n \"0.49774718\",\n \"0.49754518\",\n \"0.4965185\",\n \"0.49505603\",\n \"0.49380457\",\n \"0.4922247\",\n \"0.49185675\",\n \"0.49148628\",\n \"0.4899217\",\n \"0.48847106\",\n \"0.48770157\",\n \"0.4873674\",\n \"0.48686484\",\n \"0.48651716\",\n \"0.48632613\",\n \"0.48606342\",\n \"0.48498318\",\n \"0.48480135\",\n \"0.48349708\",\n \"0.48341823\",\n \"0.48312348\",\n \"0.4831001\",\n \"0.482618\",\n \"0.48219973\",\n \"0.48171017\",\n \"0.48102918\",\n \"0.48040098\",\n \"0.48018512\",\n \"0.48017666\",\n \"0.48012406\",\n \"0.47983322\",\n \"0.47972515\",\n \"0.4796116\",\n \"0.4794698\",\n \"0.4792781\",\n \"0.47926706\",\n \"0.47732306\",\n \"0.47700727\",\n \"0.4764726\",\n \"0.4756439\",\n \"0.47494152\",\n \"0.4745018\",\n \"0.4745018\",\n \"0.4745018\",\n \"0.4732777\",\n \"0.47301435\",\n \"0.47300825\",\n \"0.47228512\",\n \"0.47208825\",\n \"0.47037193\",\n \"0.47033855\",\n \"0.46986023\",\n \"0.46928918\",\n \"0.46893755\",\n \"0.46838656\",\n \"0.46836555\",\n \"0.4677695\",\n \"0.46762833\",\n \"0.4670965\",\n \"0.4666347\",\n \"0.46588647\",\n \"0.4658635\",\n \"0.4657854\",\n \"0.4657763\",\n \"0.46570498\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.5559056"},"document_rank":{"kind":"string","value":"2"}}},{"rowIdx":89884,"cells":{"query":{"kind":"string","value":"Creates a coolant channel ring using the CoolantChannelRingStraight parameteric shape and checks that a cadquery solid is created."},"document":{"kind":"string","value":"def test_creation(self):\n\n assert self.test_shape.solid is not None\n assert self.test_shape.volume() > 1000"},"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 add_cable_ring(self, env, info={}, cable_idx=0):\n def rad_to_deg(rad):\n return (rad * 180.0) / np.pi\n\n def get_discretized_rotations(num_rotations):\n # counter-clockwise\n theta = i * (2 * np.pi) / num_rotations\n return (theta, rad_to_deg(theta))\n\n # Bead properties.\n num_parts = self.num_parts\n radius = self.radius\n color = self.colors[cable_idx] + [1]\n\n # The `ring_radius` (not the bead radius!) has to be tuned somewhat.\n # Try to make sure the beads don't have notable gaps between them.\n ring_radius = info['ring_radius']\n beads = []\n bead_positions_l = []\n\n # Add beaded cable. Here, `position` is the circle center.\n position = np.float32(info['center_position'])\n part_shape = p.createCollisionShape(p.GEOM_BOX, halfExtents=[radius]*3)\n part_visual = p.createVisualShape(p.GEOM_SPHERE, radius=radius*1.5)\n\n # Iterate through parts and create constraints as needed.\n for i in range(num_parts):\n angle_rad, _ = get_discretized_rotations(num_parts)\n px = ring_radius * np.cos(angle_rad)\n py = ring_radius * np.sin(angle_rad)\n #print(f'pos: {px:0.2f}, {py:0.2f}, angle: {angle_rad:0.2f}, {angle_deg:0.1f}')\n bead_position = np.float32([position[0] + px, position[1] + py, 0.01])\n part_id = p.createMultiBody(0.1, part_shape, part_visual,\n basePosition=bead_position)\n p.changeVisualShape(part_id, -1, rgbaColor=color)\n\n if i > 0:\n parent_frame = bead_position - bead_positions_l[-1]\n constraint_id = p.createConstraint(\n parentBodyUniqueId=beads[-1],\n parentLinkIndex=-1,\n childBodyUniqueId=part_id,\n childLinkIndex=-1,\n jointType=p.JOINT_POINT2POINT,\n jointAxis=(0, 0, 0),\n parentFramePosition=parent_frame,\n childFramePosition=(0, 0, 0))\n p.changeConstraint(constraint_id, maxForce=100)\n\n # Make a constraint with i=0. Careful with `parent_frame`!\n if i == num_parts - 1:\n parent_frame = bead_positions_l[0] - bead_position\n constraint_id = p.createConstraint(\n parentBodyUniqueId=part_id,\n parentLinkIndex=-1,\n childBodyUniqueId=beads[0],\n childLinkIndex=-1,\n jointType=p.JOINT_POINT2POINT,\n jointAxis=(0, 0, 0),\n parentFramePosition=parent_frame,\n childFramePosition=(0, 0, 0))\n p.changeConstraint(constraint_id, maxForce=100)\n\n # Track beads.\n beads.append(part_id)\n bead_positions_l.append(bead_position)\n\n # The usual for tracking IDs. Four things to add.\n self.cable_bead_IDs.append(part_id)\n self._IDs[part_id] = f'cable_part_{str(part_id).zfill(2)}'\n env.objects.append(part_id)\n self.object_points[part_id] = np.float32((0, 0, 0)).reshape(3, 1)\n\n if 'cable-ring' in self._name:\n # For targets, we can assume the starting position gives us\n # that. Later, apply a random force on the ring to perturb it.\n true_position = (bead_position[0], bead_position[1], 0)\n self.goal['places'][part_id] = (true_position, (0, 0, 0, 1.))\n symmetry = 0\n self.goal['steps'][0][part_id] = (symmetry, [part_id])\n\n # Make the true positions visible if desired.\n if info['targets_visible']:\n sq_pose = ((true_position[0], true_position[1], 0.002), (0,0,0,1))\n sq_template = 'assets/square/square-template-allsides-green.urdf'\n replace = {'DIM': (0.003,), 'HALF': (0.003 / 2,)}\n urdf = self.fill_template(sq_template, replace)\n env.add_object(urdf, sq_pose, fixed=True)\n os.remove(urdf)\n else:\n print(f'Warning, env {self._name} will not have goals.')","def make_circle_fill():\n num_points = 40\n batch = pyglet.graphics.Batch()\n rad = math.pi * 2 / num_points # getting 360 / n in radians\n index = list(itertools.chain.from_iterable( (0, x-1, x) for x in range(2, num_points+1) ))\n index += [0, 1, num_points] # end of fan\n vertices = [0, 0] # adding center of fan\n for i in range(1, num_points + 1):\n angle = rad * i\n vertices += [math.cos(angle), math.sin(angle)]\n vertices += [1, 0] # adding end of fan\n circle = pyglet.graphics.vertex_list_indexed(num_points+2, index, ('v2f', vertices))\n return circle","def build_glyCB(self, gCBd: Dihedron): # -> None:\n ...","def add_cable(self, env, size_range, info={}, cable_idx=0,\n direction='z', max_force=100):\n num_parts = self.num_parts\n radius = self.radius\n length = self.length\n color = self.colors[cable_idx] + [1]\n color_end = U.COLORS['yellow'] + [1]\n\n # Add beaded cable.\n distance = length / num_parts\n position, _ = self.random_pose(env, size_range)\n position = np.float32(position)\n part_shape = p.createCollisionShape(p.GEOM_BOX, halfExtents=[radius]*3)\n part_visual = p.createVisualShape(p.GEOM_SPHERE, radius=radius*1.5)\n\n # Iterate through parts and create constraints as needed.\n for i in range(num_parts):\n if direction == 'x':\n position[0] += distance\n parent_frame = (distance, 0, 0)\n elif direction == 'y':\n position[1] += distance\n parent_frame = (0, distance, 0)\n else:\n position[2] += distance\n parent_frame = (0, 0, distance)\n\n part_id = p.createMultiBody(0.1, part_shape, part_visual,\n basePosition=position)\n if i > 0:\n constraint_id = p.createConstraint(\n parentBodyUniqueId=env.objects[-1],\n parentLinkIndex=-1,\n childBodyUniqueId=part_id,\n childLinkIndex=-1,\n jointType=p.JOINT_POINT2POINT,\n jointAxis=(0, 0, 0),\n parentFramePosition=parent_frame,\n childFramePosition=(0, 0, 0))\n p.changeConstraint(constraint_id, maxForce=max_force)\n\n if (i > 0) and (i < num_parts - 1):\n p.changeVisualShape(part_id, -1, rgbaColor=color)\n elif i == num_parts - 1:\n p.changeVisualShape(part_id, -1, rgbaColor=color_end)\n\n # The usual for tracking IDs. Four things to add.\n self.cable_bead_IDs.append(part_id)\n self._IDs[part_id] = f'cable_part_{str(part_id).zfill(2)}'\n env.objects.append(part_id)\n self.object_points[part_id] = np.float32((0, 0, 0)).reshape(3, 1)\n\n # Get target placing positions for each cable bead, if applicable.\n if self._name == 'cable-shape' or self._name == 'cable-shape-notarget' or \\\n self._name == 'cable-line-notarget':\n # ----------------------------------------------------------- #\n # Here, zone_pose = square_pose, unlike Ravens cable, where the\n # zone_pose is shifted so that its center matches the straight\n # line segment center. For `true_position`, we use `zone_pose`\n # but apply the correct offset to deal with the sides. Note\n # that `length` is the size of a fully smoothed cable, BUT we\n # made a rectangle with each side <= length.\n # ----------------------------------------------------------- #\n lx = info['lengthx']\n ly = info['lengthy']\n r = radius\n\n if info['nb_sides'] == 1:\n # Here it's just a straight line on the 'lx' side.\n x_coord = lx / 2 - (distance * i)\n y_coord = 0\n true_position = (x_coord - r, y_coord, 0)\n\n elif info['nb_sides'] == 2:\n # Start from lx side, go 'left' to the pivot point, then on\n # the ly side, go 'upwards' but offset by `i`. For radius\n # offset, I just got this by tuning. XD\n if i < info['cutoff']:\n x_coord = lx / 2 - (distance * i)\n y_coord = -ly / 2\n true_position = (x_coord - r, y_coord, 0)\n else:\n x_coord = -lx / 2\n y_coord = -ly / 2 + (distance * (i - info['cutoff']))\n true_position = (x_coord, y_coord + r, 0)\n\n elif info['nb_sides'] == 3:\n # Start from positive lx, positive ly, go down to first\n # pivot. Then go left to the second pivot, then up again.\n # For v1, division by two is because we assume BOTH of the\n # 'ly edges' were divided by two.\n v1 = (self.num_parts - info['cutoff']) / 2\n v2 = self.num_parts - v1\n if i < v1:\n x_coord = lx / 2\n y_coord = ly / 2 - (distance * i)\n true_position = (x_coord, y_coord - r, 0)\n elif i < v2:\n x_coord = lx / 2 - (distance * (i - v1))\n y_coord = -ly / 2\n true_position = (x_coord - r, y_coord, 0)\n else:\n x_coord = -lx / 2\n y_coord = -ly / 2 + (distance * (i - v2))\n true_position = (x_coord, y_coord + r, 0)\n\n elif info['nb_sides'] == 4:\n # I think this is similar to the 2-side case: we start in\n # the same direction and go counter-clockwise.\n v1 = info['cutoff'] / 2\n v2 = num_parts / 2\n v3 = (num_parts + info['cutoff']) / 2\n if i < v1:\n x_coord = lx / 2 - (distance * i)\n y_coord = -ly / 2\n true_position = (x_coord, y_coord, 0)\n elif i < v2:\n x_coord = -lx / 2\n y_coord = -ly / 2 + (distance * (i - v1))\n true_position = (x_coord, y_coord, 0)\n elif i < v3:\n x_coord = -lx / 2 + (distance * (i - v2))\n y_coord = ly / 2\n true_position = (x_coord, y_coord, 0)\n else:\n x_coord = lx / 2\n y_coord = ly / 2 - (distance * (i - v3))\n true_position = (x_coord, y_coord, 0)\n\n # Map true_position onto the workspace from zone_pose.\n true_position = self.apply(self.zone_pose, true_position)\n\n # See `cable.py`: just get the places and steps set.\n self.goal['places'][part_id] = (true_position, (0, 0, 0, 1.))\n symmetry = 0\n self.goal['steps'][0][part_id] = (symmetry, [part_id])\n\n # Debugging target zones.\n if self.target_debug_markers:\n sq_pose = ((true_position[0], true_position[1], 0.002), (0,0,0,1))\n sq_template = 'assets/square/square-template-allsides-blue.urdf'\n replace = {'DIM': (0.003,), 'HALF': (0.003 / 2,)}\n urdf = self.fill_template(sq_template, replace)\n env.add_object(urdf, sq_pose, fixed=True)\n os.remove(urdf)\n else:\n print(f'Warning, env {self._name} will not have goals.')","def bolthole(location, diameter, clamp_length, nuthole_size, nuthole_depth):\n bolthole = (\n cq.Workplane()\n .bolt(\n bolt_size = diameter,\n head_size = 2 * diameter,\n head_length = 2 * diameter,\n head_shape = \"cylindrical\", \n head_angle = 90,\n clamp_length = clamp_length,\n nut_size = nuthole_size,\n nut_length = nuthole_depth\n )\n .val()\n .located(location * cq.Location(cq.Vector(0, 0, - clamp_length / 2)))\n )\n # show_object(bolthole) # Debug helper.\n return bolthole","def C(width = 1, size = (10, 20), layer = 0):\n D = Device(name = 'C')\n w = width/2\n s1, s2 = size\n points = [(-w, -w), (s1, -w), (s1, w), (w, w), (w, s2-w),\n (s1, s2-w), (s1, s2+w), (-w, s2+w), (-w, -w)]\n D.add_polygon(points, layer = layer)\n D.add_port(name = 1, midpoint = (s1, s2), width = width, orientation = 0)\n D.add_port(name = 2, midpoint = (s1, 0), width = width, orientation = 0)\n return D","def __bcc_left_diagonals(self) -> cq.cq.Workplane:\n # In a cuboid ABCDA1B1C1D1 this is the angle C1AD\n #angle_C1AD = 90 - degrees(acos(2**-.5))\n angle_C1AD = 90 - degrees(acos(0.5))\n angle_CAD = 90 - degrees(acos(sqrt(2/3)))\n pseudo_unit_cell_size = sqrt(2/3)*self.unit_cell_size\n corner_points = np.array(\n [(0, 0),\n (self.bcc_unit_cell_size, 0),\n (self.bcc_unit_cell_size, self.unit_cell_size),\n (0, self.unit_cell_size)]\n )\n result = (\n cq.Workplane(\"XY\")\n .pushPoints(corner_points)\n .eachpointAdaptive(\n create_bcc_diagonal_strut,\n callback_extra_args = [\n {\"unit_cell_size\": pseudo_unit_cell_size,\n \"radius\": self.strut_radius,\n \"angle_x\": - angle_CAD,\n \"angle_y\": angle_C1AD},\n {\"unit_cell_size\": 0.5 * pseudo_unit_cell_size,\n \"radius\": self.strut_radius,\n \"angle_x\": - angle_CAD,\n \"angle_y\": - angle_C1AD},\n {\"unit_cell_size\": 0.5 * pseudo_unit_cell_size,\n \"radius\": self.strut_radius,\n \"angle_x\": angle_CAD,\n \"angle_y\": - angle_C1AD},\n {\"unit_cell_size\": pseudo_unit_cell_size,\n \"radius\": self.strut_radius,\n \"angle_x\": angle_CAD,\n \"angle_y\": angle_C1AD}\n ],\n useLocalCoords = True\n )\n )\n return result","def HollowCylinder(self,center=(0,0,0),inner_radius=1.0,outer_radius=2.,\n element_type='hex',isotropic=True,nrad=5,ncirc=10, nlong=20,length=10):\n\n if element_type != \"hex\":\n raise NotImplementedError('Generating {} mesh of cylinder is not supported yet'.format(element_type))\n\n if not isinstance(center,tuple):\n raise ValueError(\"The center for the base of the cylinder should be given in a tuple with three elements (x,y,z)\")\n\n self.__reset__()\n\n nlong = int(nlong)\n if nlong==0:\n nlong = 1\n\n mesh = Mesh()\n mesh.HollowCircle(center=(center[0],center[1]), inner_radius=inner_radius,\n outer_radius=outer_radius, element_type=\"quad\",\n isotropic=isotropic, nrad=nrad, ncirc=ncirc)\n\n self.Extrude(base_mesh=mesh, length=length, nlong=nlong)\n self.points += center[2]","def createCone( basePoint=(0,-1,0), tipPoint=(0,1,0), radius = 1.0, colour=(0.6,0.6,0.6), samples = 20 ):\r\n \r\n basePoint = PyUtils.toPoint3d(basePoint)\r\n tipPoint = PyUtils.toPoint3d(tipPoint)\r\n baseToTipVector = Vector3d(basePoint,tipPoint)\r\n if baseToTipVector.isZeroVector() :\r\n raise ValueError( 'Invalid points for cylinder: base and tip are equal!' )\r\n baseToTipUnitVector = baseToTipVector.unit()\r\n xUnitVector = baseToTipUnitVector.crossProductWith( Vector3d(0,0,1) )\r\n if xUnitVector.length() < 0.5 :\r\n xUnitVector = baseToTipUnitVector.crossProductWith( Vector3d(0,-1,0) )\r\n xUnitVector.toUnit()\r\n yUnitVector = baseToTipUnitVector.crossProductWith( Vector3d(-1,0,0) )\r\n if yUnitVector.length() < 0.5 :\r\n yUnitVector = baseToTipUnitVector.crossProductWith( Vector3d(0,1,0) )\r\n yUnitVector.toUnit()\r\n\r\n vertices = []\r\n for i in range(samples):\r\n theta = i * 2 * math.pi / float(samples)\r\n vertices.append( basePoint + xUnitVector * math.cos(theta) * radius + yUnitVector * math.sin(theta) * radius )\r\n for i in range(samples):\r\n theta = i * 2 * math.pi / float(samples)\r\n vertices.append( basePoint + xUnitVector * math.cos(theta) * radius + yUnitVector * math.sin(theta) * radius )\r\n vertices.append( tipPoint )\r\n \r\n faces = [ range(0,samples) ]\r\n for i in range(0,samples) :\r\n base = samples\r\n size = samples\r\n faces.append( (base+i, base+(i+1)%size, 2*samples ) )\r\n \r\n return create( vertices, faces, colour )","def __bcc_diagonals(self) -> cq.cq.Workplane:\n # In a cuboid ABCDA1B1C1D1 this is the angle C1AD\n #angle_C1AD = 90 - degrees(acos(2**-.5))\n angle_C1AD = 90 - degrees(acos(0.5))\n angle_CAD = 90 - degrees(acos(sqrt(2/3)))\n pseudo_unit_cell_size = sqrt(2/3)*self.unit_cell_size\n corner_points = np.array(\n [(0, 0),\n (self.bcc_unit_cell_size, 0),\n (self.bcc_unit_cell_size, self.unit_cell_size),\n (0, self.unit_cell_size)]\n )\n result = (\n cq.Workplane(\"XY\")\n .pushPoints(corner_points)\n .eachpointAdaptive(\n create_bcc_diagonal_strut,\n callback_extra_args = [\n {\"unit_cell_size\": pseudo_unit_cell_size,\n \"radius\": self.strut_radius,\n \"angle_x\": - angle_CAD,\n \"angle_y\": angle_C1AD},\n {\"unit_cell_size\": pseudo_unit_cell_size,\n \"radius\": self.strut_radius,\n \"angle_x\": - angle_CAD,\n \"angle_y\": - angle_C1AD},\n {\"unit_cell_size\": pseudo_unit_cell_size,\n \"radius\": self.strut_radius,\n \"angle_x\": angle_CAD,\n \"angle_y\": - angle_C1AD},\n {\"unit_cell_size\": pseudo_unit_cell_size,\n \"radius\": self.strut_radius,\n \"angle_x\": angle_CAD,\n \"angle_y\": angle_C1AD}\n ],\n useLocalCoords = True\n )\n )\n return result","def grating_coupler_circular(\n taper_angle: float = 30.0,\n taper_length: float = 10.0,\n length: float = 30.0,\n period: float = 1.0,\n fill_factor: float = 0.7,\n n_periods: int = 30,\n bias_gap: float = 0,\n port: Coordinate = (0.0, 0.0),\n layer_slab: Optional[LayerSpec] = None,\n layer_cladding: LayerSpec = \"WGCLAD\",\n gaps: Optional[Floats] = None,\n widths: Optional[Floats] = None,\n direction: str = \"EAST\",\n polarization: str = \"te\",\n wavelength: float = 1.55,\n fiber_marker_width: float = 11.0,\n fiber_marker_layer: Optional[LayerSpec] = \"TE\",\n cladding_offset: float = 2.0,\n cross_section: CrossSectionSpec = \"strip\",\n **kwargs,\n) -> Component:\n x = gf.get_cross_section(cross_section, **kwargs)\n layer = x.layer\n wg_width = x.width\n\n widths = widths or n_periods * [period * fill_factor]\n gaps = gaps or n_periods * [period * (1 - fill_factor)]\n\n gaps = np.array(gaps) + bias_gap\n widths = np.array(widths) - bias_gap\n teeth_list = list(zip(gaps, widths))\n\n layer = gf.get_layer(layer)\n layer_slab = gf.get_layer(layer_slab)\n layer_cladding = gf.get_layer(layer_cladding)\n\n c = pc.GratingCoupler(\n gf.call_if_func(\n strip,\n cladding_offset=cladding_offset,\n wg_width=wg_width,\n layer=layer,\n layer_cladding=layer_cladding,\n ),\n theta=np.deg2rad(taper_angle),\n length=length,\n taper_length=taper_length,\n period=period,\n dutycycle=fill_factor,\n ridge=bool(layer_slab),\n ridge_layers=layer_slab,\n teeth_list=teeth_list,\n port=port,\n direction=direction,\n )\n\n c = gf.read.from_picwriter(c)\n c.info[\"polarization\"] = polarization\n c.info[\"wavelength\"] = wavelength\n c.ports[\"o1\"].cross_section = x\n\n fiber_xoffset = np.round(c.center[0] + taper_length / 2, 3)\n\n if fiber_marker_layer:\n circle = gf.components.circle(\n radius=fiber_marker_width / 2, layer=fiber_marker_layer\n )\n circle_ref = c.add_ref(circle)\n circle_ref.movex(fiber_xoffset)\n\n c.add_port(\n name=f\"vertical_{polarization.lower()}\",\n center=[fiber_xoffset, 0],\n width=fiber_marker_width,\n orientation=0,\n layer=fiber_marker_layer,\n )\n if x.add_bbox:\n c = x.add_bbox(c)\n if x.add_pins:\n c = x.add_pins(c)\n return c","def Cool_per_Grain(grain_size, grain_type, ZZ, fdist, ntot, xe, temp):\n import numpy as np\n import math\n import compute_charge_dist as fz\n \n tau = grain_size * fz.AAtocm * fz.kb * temp / fz.echarge**2\n \n # Loop over species!\n Cool_spec = 0\n for partner in [\"electron\", \"hydrogen\", \"carbon\"]:\n \n Cool_Zall = 0\n # Loop over charge\n for zi in range(len(ZZ)):\n \n if partner == \"electron\":\n nu = -1*ZZ[zi]\n stick_coef = fz.get_stickCoef(ZZ[zi], grain_size, grain_type)\n charge_frac = xe\n mass = fz.me\n \n elif partner == \"hydrogen\":\n nu = ZZ[zi]\n stick_coef = 1.0\n charge_frac = xe\n mass = fz.mH\n \n elif partner == \"carbon\":\n nu = ZZ[zi]\n stick_coef = 1.0\n # Maximum fraction of ionized Carbon is 1e-4*ntot.\n charge_frac = min(1.0e-4, xe)\n mass = fz.mC\n \n Cooltilde = 1.0\n \n if nu < 0:\n Cooltilde = fz.Jtilde_neg(tau, nu)\n elif nu == 0:\n Cooltilde = fz.Jtilde_0(tau, nu)\n else:\n Cooltilde = fz.Jtilde_pos(tau, nu)\n \n #print(zi)\n Cool_Zhere = fdist[zi]*Cooltilde*fz.kb*temp\n Cool_Zall += Cool_Zhere\n \n #print(\"Collisional Partner = \", partner)\n Cool_spec += ntot*charge_frac*stick_coef*np.sqrt(8.0*fz.kb*temp/(np.pi*mass))*Cool_Zall\n \n Cool_tot = math.pi * (grain_size*AAtocm)**2 * Cool_spec\n \n return Cool_tot","def _createCadence(self, harmonicRhythm):\n random = RandomManager.getActive()\n\n # choose cadence to apply\n cadences = self.chordProfile.getCadences()\n\n #TODO: Choose cadence in more intelligent way\n cadence = random.choice(cadences)\n\n scale = self.chordProfile.getScale().getName()\n cadenceChordProgression = []\n\n reversedHarmonicRhythm = reversed(harmonicRhythm[:])\n # create as many cadence\n for count, durationObj in enumerate(reversedHarmonicRhythm):\n duration = durationObj.getDuration()\n code = cadence[-count+1]\n chord = Chord(code, duration=duration, scale=scale, octave=4)\n\n if count >= len(cadence):\n return cadenceChordProgression\n\n # prepend chord\n cadenceChordProgression.insert(0, chord)\n return cadenceChordProgression","def createCylinder( basePoint=(0,-1,0), tipPoint=(0,1,0), radius = 1.0, colour=(0.6,0.6,0.6), samples = 20 ):\r\n \r\n basePoint = PyUtils.toPoint3d(basePoint)\r\n tipPoint = PyUtils.toPoint3d(tipPoint)\r\n baseToTipVector = Vector3d(basePoint,tipPoint)\r\n if baseToTipVector.isZeroVector() :\r\n raise ValueError( 'Invalid points for cylinder: base and tip are equal!' )\r\n baseToTipUnitVector = baseToTipVector.unit()\r\n xUnitVector = baseToTipUnitVector.crossProductWith( Vector3d(0,0,1) )\r\n if xUnitVector.length() < 0.5 :\r\n xUnitVector = baseToTipUnitVector.crossProductWith( Vector3d(0,-1,0) )\r\n xUnitVector.toUnit()\r\n yUnitVector = baseToTipUnitVector.crossProductWith( Vector3d(-1,0,0) )\r\n if yUnitVector.length() < 0.5 :\r\n yUnitVector = baseToTipUnitVector.crossProductWith( Vector3d(0,1,0) )\r\n yUnitVector.toUnit()\r\n\r\n vertices = []\r\n for i in range(samples):\r\n theta = i * 2 * math.pi / float(samples)\r\n vertices.append( basePoint + xUnitVector * math.cos(theta) * radius + yUnitVector * math.sin(theta) * radius )\r\n for i in range(samples):\r\n theta = i * 2 * math.pi / float(samples)\r\n vertices.append( tipPoint + xUnitVector * math.cos(theta) * radius + yUnitVector * math.sin(theta) * radius )\r\n for i in range(samples):\r\n theta = i * 2 * math.pi / float(samples)\r\n vertices.append( basePoint + xUnitVector * math.cos(theta) * radius + yUnitVector * math.sin(theta) * radius )\r\n vertices.append( tipPoint + xUnitVector * math.cos(theta) * radius + yUnitVector * math.sin(theta) * radius )\r\n \r\n faces = [ range(0,samples), range(samples,2*samples) ]\r\n for i in range(0,2*samples,2) :\r\n base = 2*samples\r\n size = 2*samples\r\n faces.append( (base+i, base+i+1, base+(i+3)%size, base+(i+2)%size ) )\r\n \r\n return create( vertices, faces, colour )","def __bcc_top_diagonals(self) -> cq.cq.Workplane:\n # In a cuboid ABCDA1B1C1D1 this is the angle C1AD\n #angle_C1AD = 90 - degrees(acos(2**-.5))\n angle_C1AD = 90 - degrees(acos(0.5))\n angle_CAD = 90 - degrees(acos(sqrt(2/3)))\n pseudo_unit_cell_size = sqrt(2/3)*self.unit_cell_size\n corner_points = np.array(\n [(0, 0),\n (self.bcc_unit_cell_size, 0),\n (self.bcc_unit_cell_size, self.unit_cell_size),\n (0, self.unit_cell_size)]\n )\n result = (\n cq.Workplane(\"XY\")\n .pushPoints(corner_points)\n .eachpointAdaptive(\n create_bcc_diagonal_strut,\n callback_extra_args = [\n {\"unit_cell_size\": 0.5 * pseudo_unit_cell_size,\n \"radius\": self.strut_radius,\n \"angle_x\": - angle_CAD,\n \"angle_y\": angle_C1AD},\n {\"unit_cell_size\": pseudo_unit_cell_size,\n \"radius\": self.strut_radius,\n \"angle_x\": - angle_CAD,\n \"angle_y\": - angle_C1AD},\n {\"unit_cell_size\": pseudo_unit_cell_size,\n \"radius\": self.strut_radius,\n \"angle_x\": angle_CAD,\n \"angle_y\": - angle_C1AD},\n {\"unit_cell_size\": 0.5 * pseudo_unit_cell_size,\n \"radius\": self.strut_radius,\n \"angle_x\": angle_CAD,\n \"angle_y\": angle_C1AD}\n ],\n useLocalCoords = True\n )\n )\n return result","def test_drawSolid(self):\n\n image_name = filename(sys._getframe().f_code.co_name)\n result_file, reference_file = get_path(image_name)\n\n ''' This function is to create an empty image with a specific dimension\n with white background, and black/white colored '''\n\n image, canvas = get_image('RGB', (640, 480), 'white')\n\n '''\n for different representations of colors see\n \"https://pillow.readthedocs.io/en/3.0.x/reference/ImageColor.html#color-names\"\n '''\n drawSolid(canvas, regularPolygon(3, np.array([160, 120]), 50), 'red')\n drawSolid(canvas, regularPolygon(4, np.array([480, 120]), 90), 'blue')\n drawSolid(canvas, regularPolygon(5, np.array([420, 360]), 60), 'green')\n drawSolid(canvas, regularPolygon(6, np.array([160, 360]), 80), 'black')\n drawSolid(canvas, regularPolygon(7, np.array([320, 160]), 70), 'brown')\n\n \"\"\" saving the file and closing it \"\"\"\n image.save(result_file)\n image.close()\n\n \"\"\" validate the resultant file against the reference images\"\"\"\n\n validate(reference_file, result_file)","def ring(radius = 10, width = 0.5, angle_resolution = 2.5, layer = 0):\n D = Device(name = 'ring')\n inner_radius = radius - width/2\n outer_radius = radius + width/2\n n = int(np.round(360/angle_resolution))\n t = np.linspace(0, 360, n+1) * pi/180\n inner_points_x = (inner_radius*cos(t)).tolist()\n inner_points_y = (inner_radius*sin(t)).tolist()\n outer_points_x = (outer_radius*cos(t)).tolist()\n outer_points_y = (outer_radius*sin(t)).tolist()\n xpts = inner_points_x + outer_points_x[::-1]\n ypts = inner_points_y + outer_points_y[::-1]\n D.add_polygon(points = (xpts, ypts), layer = layer)\n return D","def generate_solid(self):\n ext = os.path.splitext(self.filename)[1][1:]\n if ext == 'stl':\n shaft_compound = read_stl_file(self.filename)\n elif ext == 'iges':\n iges_reader = IGESControl_Reader()\n iges_reader.ReadFile(self.filename)\n iges_reader.TransferRoots()\n shaft_compound = iges_reader.Shape()\n else:\n raise Exception('The shaft file is not in iges/stl formats')\n sewer = BRepBuilderAPI_Sewing(1e-2)\n sewer.Add(shaft_compound)\n sewer.Perform()\n result_sewed_shaft = sewer.SewedShape()\n shaft_solid_maker = BRepBuilderAPI_MakeSolid()\n shaft_solid_maker.Add(OCC.Core.TopoDS.topods_Shell(result_sewed_shaft))\n if not shaft_solid_maker.IsDone():\n raise RuntimeError('Unsuccessful assembling of solid shaft')\n shaft_solid = shaft_solid_maker.Solid()\n return shaft_solid","def roof_cc(lenght, width, overhang=1, wall_height=3, roof_height=4):\n a = min(0.1 * lenght, 0.1 * width, 0.4 * (wall_height + 0.5 * roof_height))\n\n area = (lenght + overhang)*(width + overhang)\n area_3 = 8*a**2\n area_1 = (lenght - 2)*(width - 4*a)\n area_2 = area - area_3 - area_1\n return area, area_1, area_2, area_3","def test_create_circuit_noname(self):\n q_program = QuantumProgram()\n qr = q_program.create_quantum_register(size=3)\n cr = q_program.create_classical_register(size=3)\n qc = q_program.create_circuit(qregisters=[qr], cregisters=[cr])\n self.assertIsInstance(qc, QuantumCircuit)","def smear_coolant_wirewrap(info):\n height = info[0]\n fuel_radius = info[1] / 2\n wirewrap_radius = info[2] / 2\n wire_wrap_axial_pitch = info[3]\n fuel_pitch = info[4]\n coolant_material = info[5]\n clad_material = info[6]\n fuel_volume = utilities.get_cylinder_volume(fuel_radius, height)\n wire_wrap_volume = utilities.get_toroidal_volume(fuel_radius, wirewrap_radius, wire_wrap_axial_pitch, height)\n pin_hexagonal_universe_volume = utilities.get_hexagonal_prism_volume(fuel_pitch, height)\n coolant_volume = pin_hexagonal_universe_volume - fuel_volume - wire_wrap_volume\n total_coolant_wire_wrap_volume = coolant_volume + wire_wrap_volume\n wire_wrap_volume_percent = wire_wrap_volume / total_coolant_wire_wrap_volume\n coolant_volume_percent = coolant_volume / total_coolant_wire_wrap_volume\n smeared_material_dict = {clad_material: wire_wrap_volume_percent, coolant_material: coolant_volume_percent}\n return smeared_material_dict","def test_cyclohexane(self):\n self._test_shape(\n image_size=(1000, 1000),\n expected_corners=np.array([\n [[400, 400]],\n [[487, 350]],\n [[574, 400]],\n [[574, 500]],\n [[487, 550]],\n [[400, 500]]\n ]),\n drawer=lambda image: image.add_regular_hexagon(\n 100, start_coord=(400, 400)\n )\n )","def circuitSat(C):","def to_circuit(self):\n from qiskit.synthesis.cnotdihedral import synth_cnotdihedral_full\n\n return synth_cnotdihedral_full(self)","def add_connector(self):\n \n no = len(self.connectors)\n state = {}\n state[\"s_pin\"] = no\n state[\"p_pin\"] = no\n state[\"s_label\"] = \"C%d\" % no\n \n if len(self.connectors)>0:\n state = self.connectors[-1].get_state()\n state[\"s_pin\"] = no\n state[\"p_pin\"] = no\n state[\"s_label\"] = \"C%d\" % (no)\n else:\n if self.mount == self.MOUNT_THT:\n state[\"p_shape\"] = Con.SHAPE_HOLE\n elif self.mount == self.MOUNT_SMD:\n state[\"p_shape\"] = Con.SHAPE_PAD\n \n c = Con(no)\n c.set_state(state) \n \n self.sch_layers[\"pins\"].add(c.s_svg)\n self.pcb_layers[\"copper1\"].add(c.p_svg)\n self.connectors.append(c)","async def create_channel(self):\n self._logger.info(\"Deploying chaincode...\")\n network_file_path = os.path.join(os.getcwd(), \"network.json\")\n channel_config_path = os.path.join(self.config_path, \"channel-artifacts\", \"channel.tx\")\n\n self.fabric_client = Client(net_profile=network_file_path)\n\n org1_admin = self.fabric_client.get_user(org_name='org1.example.com', name='Admin')\n\n # Create a New Channel, the response should be true if succeed\n response = await self.fabric_client.channel_create(\n orderer='orderer1.example.com',\n channel_name='mychannel',\n requestor=org1_admin,\n config_tx=channel_config_path\n )\n self._logger.info(\"Result of channel creation: %s\", response)","def bell():\n qr = QuantumRegister(2, name='qr')\n cr = ClassicalRegister(2, name='qc')\n qc = QuantumCircuit(qr, cr, name='bell')\n qc.h(qr[0])\n qc.cx(qr[0], qr[1])\n qc.measure(qr, cr)\n\n return qc","def corrRing(self, angle):\n c =\"/cli:python /app:matrix /cmd:setcorring\" + str(float(angle))\n self.sendCMDstring(c)","def walls_cc(lenght, width, wall_height=3, roof_height=4):\n a = min(0.1*lenght, 0.1*width, 0.4*(wall_height+0.5*roof_height))\n trian = 0.5*width*roof_height\n trian_5 = 0.5*a*a*(wall_height/roof_height)\n # trian_4 = trian - 2*trian_5\n\n area = (lenght + width)*2*wall_height + 2*trian\n area_5 = 8*a*wall_height + 4*trian_5\n area_4 = area - area_5\n\n return area, area_4, area_5","async def _create_cycle(self, ctx: Context, number: int = None):\n\n guild: discord.Guild = ctx.guild\n\n if not number:\n number = (\n await self.config.guild(guild).get_raw(\"cycle\", \"number\") + 1\n )\n\n msg = await ctx.send(\n _(\n \"Are you sure you want to create cycle `{}` channels? Make\"\n \" sure you have the day text ready. Users will be able to talk\"\n \" in the day and vote channels as soon as they are created.\"\n ).format(number)\n )\n start_adding_reactions(msg, ReactionPredicate.YES_OR_NO_EMOJIS)\n\n pred = ReactionPredicate.yes_or_no(msg, ctx.author)\n await ctx.bot.wait_for(\"reaction_add\", check=pred)\n\n if not pred.result:\n return await ctx.send(_(\"Process aborted.\"))\n\n player_id = await self.config.guild(guild).player_id()\n player_role = discord.utils.get(guild.roles, id=player_id)\n\n overwrites = {\n guild.default_role: discord.PermissionOverwrite(\n read_messages=True,\n send_messages=False\n ),\n player_role: discord.PermissionOverwrite(\n send_messages=True,\n attach_files=False\n ),\n guild.me: discord.PermissionOverwrite(\n send_messages=True,\n embed_links=True\n )\n }\n\n cycle_category = await guild.create_category_channel(\n f\"Cycle {number}\", overwrites=overwrites\n )\n\n day = await cycle_category.create_text_channel(f\"day-{number}\")\n vote = await cycle_category.create_text_channel(f\"day-{number}-votes\")\n\n night_overwrites = {\n guild.default_role: discord.PermissionOverwrite(\n read_messages=False\n ),\n guild.me: discord.PermissionOverwrite(\n read_messages=True\n )\n }\n\n night = await cycle_category.create_text_channel(\n f\"night-{number}\", overwrites=night_overwrites\n )\n\n await self.config.guild(guild).na_submitted.clear()\n\n async with self.config.guild(guild).cycle() as cycle:\n cycle[\"number\"] = number\n cycle[\"day\"] = day.id\n cycle[\"vote\"] = vote.id\n cycle[\"night\"] = night.id\n\n await ctx.send(_(\"Created cycle {} channels!\").format(number))","def short_circ():\n \n set_mode(mode_cv)\n time.sleep(.250)\n set_CV_volts(0.1)\n time.sleep(.250)\n \n sc_vals = get_input_values()\n sc_data_point = data_point(sc_vals)\n jsc = sc_data_point[4]\n print('Short circuit current: ', jsc)\n write_data_tofile(sc_data_point)\n\n return jsc","def construct_qcbm(circuit, n_qubits, depth):\n\n for d in range(depth):\n for i in range(n_qubits):\n circuit.append_gate(Gate('X', target = i, angle = np.random.random()*np.pi*2))\n circuit.append_gate(Gate('Z', target = i, angle = np.random.random()*np.pi*2))\n if n_qubits != 1:\n for i in range(n_qubits):\n circuit.append_gate(Gate('CNOT', control = i, target = (i+1)%n_qubits))\n return circuit","def test_rocket():\n ring = [(0,0), (10, 0), (15,5), (10,9), (1,7), (6,4), (0,0)]\n conv = ToPointsAndSegments()\n conv.add_polygon([ring])\n skel = calc_skel(conv, output=True, pause=True)\n print \"DONE\"","def circle(t, r):\n circumference = math.pi * 2 * r\n n = 60\n length = circumference / n\n polygon(t, length, n)","def request_circuit_build(self, deferred, path=None):\n if path is None:\n\n pick = self.relays['all'].pop\n n = self.state.entry_guards.values()\n choose = random.choice\n\n first, middle, last = (None for i in range(3))\n\n if self.relays['remaining']() >= 3:\n first, middle, last = (pick() for i in range(3))\n elif self.relays['remaining']() < 3:\n first = choose(n)\n middle = pick()\n if self.relays['remaining'] == 2:\n middle, last = (pick() for i in range(2))\n elif self.relay['remaining'] == 1:\n middle = pick()\n last = choose(n)\n else:\n log.msg(\"Qu'est-que fuque?\")\n else:\n middle, last = (random.choice(self.state.routers.values())\n for i in range(2))\n\n path = [first, middle, last]\n\n else:\n assert isinstance(path, list), \\\n \"Circuit path must be a list of relays!\"\n assert len(path) >= 3, \\\n \"Circuit path must be at least three hops!\"\n\n log.msg(\"Requesting a circuit: %s\"\n % '->'.join(map(lambda node: node, path)))\n\n class AppendWaiting:\n def __init__(self, attacher, deferred):\n self.attacher = attacher\n self.d = deferred\n def __call__(self, circ):\n \"\"\"\n Return from build_circuit is a Circuit, however,\n we want to wait until it is built before we can\n issue an attach on it and callback to the Deferred\n we issue here.\n \"\"\"\n log.msg(\"Circuit %s is in progress ...\" % circ.id)\n self.attacher.waiting_circuits.append((circ.id, self.d))\n\n return self.state.build_circuit(path).addCallback(\n AppendWaiting(self, deferred)).addErrback(\n log.err)","def solid(t, coord, ii, n_pixels, random_values):\n\n\n return (100,100,100)","def cliques_on_ring(cliques,labels,G, cut=0):\n print(\"cliques_on_ring CUT:\", cut)\n #if partitions\n if cut > 1:\n partitions = get_partitions(cliques,cut)\n for partition in partitions:\n if len(partition) > 1:\n n1 = random.choice(partition[0])\n for idx,clique in enumerate(partition):\n if idx > 0:# and idx not in cuts:\n candidates = [n for n in clique if labels[n.id] != labels[n1.id]]\n candidates = candidates if len(candidates) > 0 else clique\n n2 = random.choice(candidates)\n G.add_edge(n1,n2)\n n1 = random.choice(clique)\n\n else:\n n1 = random.choice(cliques[0]) \n for idx,clique in enumerate(cliques):\n if idx > 0:# and idx not in cuts:\n candidates = [n for n in clique if labels[n.id] != labels[n1.id]]\n candidates = candidates if len(candidates) > 0 else clique\n n2 = random.choice(candidates)\n G.add_edge(n1,n2)\n n1 = random.choice(clique)\n \n #Attach head and tail cliques\n candidates = [n for n in cliques[0] if labels[n.id] != labels[n1.id]]\n candidates = candidates if len(candidates) > 0 else cliques[0]\n n2 = random.choice(candidates)\n G.add_edge(n1,n2)","def make_path(self, loop):\n path=Path(closed=True)\n for c in range(0,len(loop)):\n connection=loop[c]\n nextConnection = loop[(c+1)%len(loop)]\n lastConnection = loop[(c-1)%len(loop)]\n if self.dontFill(connection, nextConnection, lastConnection):\n return False\n cp = self.corner_pos(connection, nextConnection, lastConnection)\n corner_offset = cp[0]\n corner_dir = cp[1]\n # catch case when it is the end of a single rod\n if type(corner_offset) is list:\n endpoints = corner_offset\n corner_offset = endpoints[0]\n else:\n endpoints = False\n if connection.other.radius is not None and ( corner_offset.length() < connection.other.radius or corner_dir >0):\n # catch case when it is the end of a single rod\n if endpoints:\n para=(connection.this.pos-connection.other.pos).normalize()\n d = math.sqrt(connection.other.radius**2 - corner_offset.length()**2)\n path.add_point(PSharp(connection.other.pos + corner_offset + d*para))\n path.add_point(PArc(connection.other.pos, radius=connection.other.radius, direction='cw'))\n path.add_point(PSharp(connection.other.pos - corner_offset+d*para))\n else:\n path.add_point(PAroundcurve(connection.other.pos + corner_offset, centre=connection.other.pos, radius=connection.other.radius, direction='cw'))\n\n elif self.get_intRadius(connection, connection.other) is not None:\n # path.add_point(PIncurve(connection.other.pos + corner_offset, radius=self.get_intRadius(connection, connection.other)))\n # path.add_point(PIncurve(connection.other.pos - corner_offset, radius=self.get_intRadius(connection, connection.other)))\n # path.add_point(PIncurve(connection.other.pos - corner_offset, radius=self.get_intRadius(connection, connection.other)))\n path.add_point(PIncurve(connection.other.pos + corner_offset, radius=self.get_intRadius(connection, connection.other)))\n else:\n cornerpos = self.corner_pos(connection, nextConnection, lastConnection)\n if type(cornerpos) is list:\n path.add_point(PSharp(connection.other.pos + cornerpos[0]))\n path.add_point(PSharp(connection.other.pos + cornerpos[1]))\n else:\n path.add_point(PSharp(connection.other.pos + cornerpos))#self.corner_pos(connection, nextConnection, lastConnection)))\n # path.add_point(PSharp(connection.other.pos - cornerpos))#self.corner_pos(connection, nextConnection, lastConnection)))\n if connection.other.holeRad is not None:\n if type(connection.other.holeRad) is int or type(connection.other.holeRad) is float:\n self.otherpaths.append(Circle(connection.other.pos, rad=connection.other.holeRad, side='in'))\n else:\n t=copy.deepcopy(connection.other.holeRad)\n t.translate(connection.other.pos)\n self.otherpaths.append(t)\n return path","def draw_C(self, frame):\n c = self.get_real_leg()\n cv2.circle(\n frame,\n (\n Utils.ConvertX(c.x),\n Utils.ConvertY(c.y)\n ),\n 8,\n color=Utils.blue,\n thickness=-1\n )","def ring(self):\n pass","def CreateFiller(filler_def):\n filler_def = filler_def if isinstance(filler_def, str) \\\n else filler_def.SerializeToString()\n CreateFillerCC(filler_def)","def create_brake_command(apply_brake, pcm_override, pcm_cancel_cmd, chime, idx):\n pump_on = apply_brake > 0\n brakelights = apply_brake > 0\n brake_rq = apply_brake > 0\n\n pcm_fault_cmd = False\n amount = struct.pack(\"!H\", (apply_brake << 6) + pump_on)\n msg = amount + struct.pack(\"BBB\", (pcm_override << 4) |\n (pcm_fault_cmd << 2) |\n (pcm_cancel_cmd << 1) | brake_rq, 0x80,\n brakelights << 7) + chr(chime) + \"\\x00\"\n return make_can_msg(0x1fa, msg, idx, 0)","def _create_main_shape(self):\n\n a, b = gc( self.size/2,\n self._ZERO_DEGREES - self.angle,\n self._180_DEGREES + self.angle)\n self.wafer_points = zip(a,b)\n self.wafer_polygon = gdspy.Polygon(self.wafer_points, self.WAFER_LAYER)\n self.cell.add(self.wafer_polygon)","def test_component_coolant_connection_list(self):\n with PhysicsEngineHarness('tests/engineering-test.json') as physics_engine:\n engineering = physics_engine.get_state().engineering\n\n connected_loops = engineering.components.CoolantConnectionMatrix()\n self.assertEqual(connected_loops.shape, (3, N_COMPONENTS))","def drawBrick(res_num1, atom1, res_num2, atom2, **kwargs):\n\n chain1 = str(kwargs.pop(\"chain1\", \"A\")).strip()\n chain2 = str(kwargs.pop(\"chain2\", \"A\")).strip()\n res_num1 = int(res_num1)\n res_num2 = int(res_num2)\n offset1 = str2array(kwargs.pop(\"offset1\", \"(0,0,0)\"))\n offset2 = str2array(kwargs.pop(\"offset2\", \"(0,0,0)\"))\n\n boxname = kwargs.pop(\"boxname\", \"brick\")\n selname = kwargs.pop(\"name\", \"(sel)\")\n p1 = get_selection_first_coord(\"///%(chain1)s/`%(res_num1)d/%(atom1)s\" % vars(), selname)\n p2 = get_selection_first_coord(\"///%(chain2)s/`%(res_num2)d/%(atom2)s\" % vars(), selname)\n\n #print \"lower_left: %r\" % lower_left\n #print \"offset1: %r\" % offset1\n\n p1 += offset1\n p2 += offset2\n\n lower_left = numpy.where(p1 < p2, p1, p2)\n upper_right = numpy.where(p1 < p2, p2, p1)\n\n print \"--> lower left front corner: %(lower_left)r\" % vars()\n print \"--> upper right back corner: %(upper_right)r\" % vars()\n\n boxCGO = box(lower_left, upper_right, **kwargs)\n cmd.load_cgo(boxCGO, boxname)\n return boxname","def circlePrimitive(self):\n\n def drawWireframe(self):\n\n # Draw line\n glFT.glBegin(OpenMayaRender.MGL_LINE_STRIP)\n\n # Get Color\n # self.getColor(\"edge\")\n\n def_circle = 100\n for idx in range(def_circle + 1):\n\n theta = 2 * 3.141592 * idx / def_circle\n x = self.shape_size * math.cos(theta)\n z = self.shape_size * math.sin(theta)\n\n point = OpenMaya.MVector(x, 0.0, z)\n point = self.setUpAxis(point)\n point = self.addOffsetRotation(point)\n point = self.addOffsetPosition(point)\n self.getBoundingBoxSize(point)\n\n glFT.glVertex3f(point.x, point.y, point.z)\n\n glFT.glEnd()\n \n def drawShaded(self):\n\n # Draw quad\n glFT.glBegin(OpenMayaRender.MGL_POLYGON)\n\n # Get Color\n # self.getColor(\"polygon\")\n\n def_circle = 100\n for idx in range(def_circle + 1):\n\n theta = 2 * 3.141592 * idx / def_circle\n x = self.shape_size * math.cos(theta)\n z = self.shape_size * math.sin(theta)\n\n point = OpenMaya.MVector(x, 0.0, z)\n point = self.setUpAxis(point)\n point = self.addOffsetRotation(point)\n point = self.addOffsetPosition(point)\n self.getBoundingBoxSize(point)\n\n glFT.glVertex3f(point.x, point.y, point.z)\n\n glFT.glEnd()\n\n glFT.glNewList(self.vList_id, OpenMayaRender.MGL_COMPILE)\n\n # Draw lines\n if self.draw_type == 0 or self.draw_type == 2:\n drawWireframe(self)\n \n # Draww Polygons\n if self.draw_type == 1 or self.draw_type == 2:\n drawShaded(self)\n\n glFT.glEndList()","def creates_valid_building(self, cell):\n def wont_cut_off_other_commercial_buildings(pos):\n \"\"\"Helper function that ensures other commercial buildings won't be cutoff if a commercial building is\n placed at pos\"\"\"\n for adj_cell in self.environment.grid.get_neighborhood(pos, moore=False, include_center=False):\n # Check if the adj_cell is already touching at most 3 commercial buildings - can't cut anybody off\n if self.num_adj_commercial_buildings(adj_cell) == 3:\n return False\n\n return True\n\n return \\\n self.environment.grid.is_cell_empty(cell) and \\\n self.num_adj_commercial_buildings(cell) != 4 and \\\n wont_cut_off_other_commercial_buildings(cell)","def calc_chromatic_coupling(self):\n raise NotImplementedError('Chromatic Coupling is not Implemented yet.')","def test_component_coolant_connection_list(self):\n with PhysicsEngineHarness('tests/engineering-test.json') as physics_engine:\n engineering = physics_engine.get_state().engineering\n\n connected_loops = engineering.components.CoolantConnectionMatrix()\n\n self.assertEqual(connected_loops.shape, (3, N_COMPONENTS))","def glycosylate(self):\n chid = self.chain.get()\n sequon = self.sequon.get()\n self.sequon_colors[sequon] = [.7, .1, 0]\n key = self.sequon.get()\n residue = self.myGlycosylator.get_residue(key)\n #Build new glycan\n if self.selected_glycan:\n self.myGlycosylator.connect_topology['SELECTED'] = self.selected_glycan[1]\n #build from current glycan\n if key in self.original_glycans:\n original_glycan = self.original_glycanMolecules[key].atom_group\n r,t = self.original_glycans[key]\n connect_tree = self.myGlycosylator.build_connectivity_tree(r, t)\n else:\n original_glycan = None\n connect_tree = None \n #Use current glycan\n else:\n original_glycan = self.original_glycanMolecules[key]\n r,t = self.original_glycans[key]\n connect_tree = self.myGlycosylator.build_connectivity_tree(r, t)\n self.myGlycosylator.connect_topology['SELECTED'] = self.myGlycosylator.build_connect_topology(original_glycan) \n original_glycan = original_glycan.atom_group\n \n segname = 'G'+key.split(',')[2]\n glycan,bonds = self.myGlycosylator.glycosylate('SELECTED', \n template_glycan_tree = connect_tree, \n template_glycan = original_glycan,\n link_residue=residue, link_patch = 'NGLB', chain = 'G', segname=segname)\n new_glycan = glc.Molecule(key)\n new_glycan.set_AtomGroup(glycan, bonds = bonds)\n self.myGlycosylator.assign_patches(new_glycan)\n self.linked_glycanMolecules[key] = new_glycan\n self.linked_glycans[key] = [new_glycan.rootRes, new_glycan.interresidue_connectivity]\n self.names.update(new_glycan.get_names())\n # Update glycoprotein and sequon panels\n self.draw_glycoprotein(chid)\n self.draw_glycan(sequon)","def cmd_cb():\n cmds = []\n #cmds.append(\"r_m[0.0,-1,1]\")\n cmds.append(\"r_m[0.0]\")\n cmds.append('r_a[1.7,0,10]')\n cmds.append('r_n[1.5,0,10]')\n cmds.append(\"r_s[2.5,0,10]\")\n cmds.append('RooCBShape::res(x,r_m,r_s,r_a,r_n)')\n return cmds","def corridor(x,z, emap, width=10, length=10, height=10, details=None, walls=\"ns\", name=\"wall\", mergeshape=None):\r\n global wallnum\r\n n = z + width / 2\r\n s = z - width / 2\r\n e = x + length / 2\r\n w = x - length / 2\r\n\r\n solid_objects = []\r\n\r\n if \"n\" in walls:\r\n # TODO: abstract out the mostly-duplicate code in these cases...\r\n nwall = SolidObject(name+str(wallnum),\r\n Size(length, height, 1),\r\n Position(x, emap.calcHeight(x, z) + height / 2, n-0.5), 0)\r\n solid_objects.append(nwall)\r\n nwallmodel = createMyCuboid(nwall.w() * 2, nwall.h() * 2, nwall.d() * 2,\r\n name=name+str(wallnum),\r\n x=nwall.x(),y=nwall.y(),z=nwall.z(),\r\n rx=0.0, ry=0.0, rz=0.0, cx=0.0, cy=0.0, cz=0.0)\r\n if mergeshape:\r\n mergeshape.add(nwallmodel)\r\n else:\r\n nwall.setmodel(nwallmodel, details)\r\n\r\n\r\n wallnum += 1\r\n\r\n if \"s\" in walls:\r\n swall = SolidObject(name+str(wallnum), Size(length, height, 1), Position(x, emap.calcHeight(x, z)+height / 2, s+0.5), 0)\r\n solid_objects.append(swall)\r\n swallmodel = createMyCuboid(swall.w()*2, swall.h()*2, swall.d()*2,\r\n name=name+str(wallnum),\r\n x=swall.x(), y=swall.y(), z=swall.z(),\r\n rx=0.0, ry=0.0, rz=0.0, cx=0.0,cy=0.0, cz=0.0)\r\n if mergeshape:\r\n mergeshape.add(swallmodel)\r\n else:\r\n swall.setmodel(swallmodel, details)\r\n\r\n wallnum += 1\r\n\r\n if \"e\" in walls:\r\n ewall = SolidObject(name+str(wallnum), Size(1, height, width), Position(e-0.5, emap.calcHeight(x, z)+height / 2, z), 0)\r\n solid_objects.append(ewall)\r\n ewallmodel = createMyCuboid(ewall.w()*2, ewall.h()*2, ewall.d()*2,\r\n name=name+str(wallnum),\r\n x=ewall.x(), y=ewall.y(), z=ewall.z(),\r\n rx=0.0, ry=0.0, rz=0.0, cx=0.0, cy=0.0, cz=0.0)\r\n if mergeshape:\r\n mergeshape.add(ewallmodel)\r\n else:\r\n ewall.setmodel(ewallmodel, details)\r\n\r\n wallnum += 1\r\n\r\n if \"w\" in walls:\r\n wwall = SolidObject(name+str(wallnum), Size(1, height, width), Position(w+0.5, emap.calcHeight(x, z)+height / 2, z), 0)\r\n solid_objects.append(wwall)\r\n wwallmodel = createMyCuboid(wwall.w()*2, wwall.h()*2, wwall.d()*2,\r\n name=name+str(wallnum),\r\n x=wwall.x(), y=wwall.y(), z=wwall.z(),\r\n rx=0.0, ry=0.0, rz=0.0, cx=0.0, cy=0.0, cz=0.0)\r\n if mergeshape:\r\n mergeshape.add(wwallmodel)\r\n else:\r\n wwall.setmodel(wwallmodel, details)\r\n wallnum += 1\r\n\r\n if \"o\" not in walls:\r\n ceiling = SolidObject(name+str(wallnum), Size(length, 1, width), Position(x, emap.calcHeight(x, z)+height+0.5, z), 0)\r\n solid_objects.append(ceiling)\r\n ceilingmodel = createMyCuboid(ceiling.w()*2, ceiling.h()*2, ceiling.d()*2,\r\n name=name+str(wallnum),\r\n x=ceiling.x(), y=ceiling.y(), z=ceiling.z(),\r\n rx=0.0, ry=0.0, rz=0.0, cx=0.0, cy=0.0, cz=0.0)\r\n if mergeshape:\r\n mergeshape.add(ceilingmodel)\r\n else:\r\n ceiling.setmodel(ceilingmodel, details)\r\n\r\n wallnum += 1\r\n\r\n return solid_objects","def bc_is_solid(bc):\n solid = BCProp(int(bc_solid[bc.xlb]),\n int(bc_solid[bc.xrb]),\n int(bc_solid[bc.ylb]),\n int(bc_solid[bc.yrb]))\n return solid","def bamboo(screen, color, x, y, size):\n rect(screen, color, (x, y + size * 6, size, size * 14 / 3))\n rect(screen, color, (x, y, size, size * 16 / 3))\n polygon(screen, color, [(x + size * 2 / 3, y - size * 2 / 3), (x, y - size),\n (x + size / 3, y - size * 13 / 3), (x + size, y - size * 14 / 3)])\n polygon(screen, color, [(x + size, y - size * 14 / 3), (x + size * 2 / 3, y - size * 73 / 15),\n (x + size * 17 / 15, y - size * 29 / 3), (x + size * 22 / 15, y - size * 142 / 15)])\n stick(screen, color, [x - size * 13 / 3, y - size * 5 / 3], [x - size * 1 / 3, y + size / 3], 3, 1, -30)\n stick(screen, color, [x + size * 24 / 3, y - size * 25 / 3], [x + size * 4 / 3, y - size * 3], 5, 1, 30)\n stick(screen, color, [x - size * 13 / 3, y - size * 25 / 3], [x - size * 1 / 3, y - size * 5], 5, 1, -30)\n stick(screen, color, [x + size * 14 / 3, y - size * 5 / 3], [x + size * 4 / 3, y + size / 3], 3, 1, 30)","def createCirclePolygon(h, k, r, dx):\n D = 10.0\n theta = 2 * np.arccos((r-(dx/D))/r)\n npoints = int(360.0/theta)\n x, y = getPointsInCircum(r, n=npoints, h=h, k=k)\n p = Polygon(list(zip(x, y)))\n return p","def convert_to_circuit(x):\n y = np.arcsin(x)\n z = np.arccos(x**2)\n qubits = cirq.GridQubit.rect(5, 1)\n circuit = cirq.Circuit()\n for i in range(5):\n circuit.append(cirq.ry(y).on(qubits[i]))\n circuit.append(cirq.rz(z).on(qubits[i]))\n return circuit","def conj(q_1: Q, conj_type: int = 0) -> Q:\n\n end_q_type = f\"{q_1.q_type}*\"\n c_t, c_x, c_y, c_z = q_1.t, q_1.x, q_1.y, q_1.z\n cq = Q()\n\n if conj_type % 4 == 0:\n cq.t = c_t\n if c_x != 0:\n cq.x = -1 * c_x\n if c_y != 0:\n cq.y = -1 * c_y\n if c_z != 0:\n cq.z = -1 * c_z\n\n elif conj_type % 4 == 1:\n if c_t != 0:\n cq.t = -1 * c_t\n cq.x = c_x\n if c_y != 0:\n cq.y = -1 * c_y\n if c_z != 0:\n cq.z = -1 * c_z\n end_q_type += \"1\"\n\n elif conj_type % 4 == 2:\n if c_t != 0:\n cq.t = -1 * c_t\n if c_x != 0:\n cq.x = -1 * c_x\n cq.y = c_y\n if c_z != 0:\n cq.z = -1 * c_z\n end_q_type += \"2\"\n\n elif conj_type % 4 == 3:\n if c_t != 0:\n cq.t = -1 * c_t\n if c_x != 0:\n cq.x = -1 * c_x\n if c_y != 0:\n cq.y = -1 * c_y\n cq.z = c_z\n end_q_type += \"3\"\n\n cq.q_type = end_q_type\n cq.representation = q_1.representation\n\n return cq","def concent_graph(self):\n r_big = self['M_RSMALL']\n r_small = self['M_RBIG']\n C = self['M_C']\n \n xcenter = self['X_IMAGE'] ; ycenter = self['Y_IMAGE']\n xcenter = xcenter - self['MXMIN_IMAGE']\n ycenter = ycenter - self['MYMIN_IMAGE']\n center = (xcenter,ycenter)\n \n ellip = self['ELLIPTICITY'] \n q = 1. - ellip\n pa = self['THETA_IMAGE'] # Astronomical position angle.\n\n stamp = self['STAMP'].copy()\n mask = self['MASKOTHER'].copy()\n sky = self['BACKGROUND']\n Img = stamp - sky\n Img[num.where(mask != 0)] = 0.\n \n id = self._getGraphId()\n root = 'C_%s' % (id,)\n pngname = root + '.png' ; epsname = root + '.eps'\n jpgname = root + '.jpg'\n doStamp(Img,pngname,format='PNG')\n Convert(pngname,jpgname)\n \n Painted = Paint(jpgname)\n Painted.load()\n Painted.DrawEllipse(center,r_big,q,pa,color='red',linewidth=2)\n Painted.DrawEllipse(center,r_small,q,pa,color='green',linewidth=2)\n \n text = 'C=%5.2f' % (self['M_C'])\n # Painted.Graffiti(text,commtextpos)\n Painted.save(jpgname) \n Painted.release()\n \n Convert(jpgname,epsname)\n os.system('rm %s %s' % (pngname,jpgname))\n \n self['figures']['C'] = epsname\n self['figcomms']['C'] = text","def cones_and_cylinders(\n network,\n pore_diameter=\"pore.diameter\",\n throat_diameter=\"throat.diameter\",\n):\n D1, Dt, D2 = network.get_conduit_data(pore_diameter.split('.', 1)[-1]).T\n L1, Lt, L2 = _conduit_lengths.cones_and_cylinders(\n network=network,\n pore_diameter=pore_diameter,\n throat_diameter=throat_diameter\n ).T\n\n # Fi is the integral of (1/A^2) dx, x = [0, Li]\n F1 = 16 / 3 * (L1 * (D1**2 + D1 * Dt + Dt**2) / (D1**3 * Dt**3 * _np.pi**2))\n F2 = 16 / 3 * (L2 * (D2**2 + D2 * Dt + Dt**2) / (D2**3 * Dt**3 * _np.pi**2))\n Ft = Lt / (_np.pi * Dt**2 / 4) ** 2\n\n # I is the integral of (y^2 + z^2) dA, divided by A^2\n I1 = I2 = It = 1 / (2 * _np.pi)\n\n # S is 1 / (16 * pi^2 * I * F)\n S1 = 1 / (16 * _np.pi**2 * I1 * F1)\n St = 1 / (16 * _np.pi**2 * It * Ft)\n S2 = 1 / (16 * _np.pi**2 * I2 * F2)\n\n return _np.vstack([S1, St, S2]).T","def draw_housing():\r\n green.pensize(3)\r\n green.color(\"black\", \"darkgrey\")\r\n green.begin_fill()\r\n green.forward(80)\r\n green.left(90)\r\n green.forward(200)\r\n green.circle(40, 180)\r\n green.forward(200)\r\n green.left(90)\r\n green.end_fill()","def generate_random_DC_crack_coupled_tensor():\n # 1. Generate random DC MT and crack MT:\n # generate DC MT:\n DC_MT_to_rot = np.vstack(([0.,0.,1.],[0.,0.,0.], [1.,0.,0.])) # DC moment tensor\n # generate crack MT (from Tape 2013, eq. 41 and Fig. 6):\n # To randomly generate lune_perim_angle (from Tape 2013 eq. 41 and Fig. 6):\n # --- To randomly generate lune_perim_angle (from Tape 2013 eq. 41 and Fig. 6) ---:\n # Get between small range:\n theta_lune_sphere = np.random.uniform(-1.,1.)*np.pi/2.\n random_num = random.random()\n if random_num <= 0.5:\n phi_lune_sphere = 0. #np.pi/6. #0. #np.pi/6.\n elif random_num > 0.5:\n phi_lune_sphere = np.pi/3 #-1.*np.pi/6. #np.pi/3 #-1.*np.pi/6.\n # calculate lune_perim_angle, allowing for outside tan(-pi/2->pi/2):\n lune_perim_angle = np.arctan(np.sin(phi_lune_sphere)/np.sin(theta_lune_sphere)) # Generates uniform distribution of lune crack angle in Lune plot space #random.random()*2.*np.pi # Random number in uniform distribution betwen 0 and 2 pi\n # And redistribute evenly everywhere on boundary:\n random_num = random.random()\n if random_num>0.25 and random_num<=0.5:\n lune_perim_angle = lune_perim_angle+np.pi # Allow to use full 2 pi space\n if random_num>0.5 and random_num<=0.75:\n lune_perim_angle = lune_perim_angle+np.pi/2 # Allow to use full 2 pi space\n if random_num>0.75 and random_num<=1.0:\n lune_perim_angle = lune_perim_angle+3*np.pi/2 # Allow to use full 2 pi space\n # --- ---\n # random_num = random.random()\n # if random_num <= 0.5:\n # theta_lune_sphere = random.random()*np.pi/2.\n # elif random_num > 0.5:\n # theta_lune_sphere = -1.*random.random()*np.pi/2.\n # random_num = random.random()\n # if random_num <= 0.5:\n # phi_lune_sphere = np.pi/6.\n # elif random_num > 0.5:\n # phi_lune_sphere = -1.*np.pi/6.\n # lune_perim_angle = np.arctan(np.sin(phi_lune_sphere)/np.sin(theta_lune_sphere)) # Generates uniform distribution of lune crack angle in Lune plot space #random.random()*2.*np.pi # Random number in uniform distribution betwen 0 and 2 pi\n crack_MT_to_rot = ((((4*(np.sin(lune_perim_angle)**2)) + (np.cos(lune_perim_angle)**2))**-0.5)/np.sqrt(3.)) * np.vstack(([np.cos(lune_perim_angle)-(np.sqrt(2)*np.sin(lune_perim_angle)),0.,0.],[0.,np.cos(lune_perim_angle)-(np.sqrt(2)*np.sin(lune_perim_angle)),0.], [0.,0.,np.cos(lune_perim_angle)+(2.*np.sqrt(2)*np.sin(lune_perim_angle))])) # crack moment tensor\n # 2. Combine DC and crack tensors:\n random_amp_frac = random.random() # random number between 0. and 1., for relative amplitude of DC and crack fractions.\n DC_crack_MT_to_rot =random_amp_frac*DC_MT_to_rot + (1.-random_amp_frac)*crack_MT_to_rot\n # 3. Randomly rotate DC-crack MT to random orientation:\n # Get a random sample 3-vector on a 3-unit sphere to use to calculate random theta and phi rotation angles:\n a_unnormalised = np.array([np.random.normal(loc=0.0, scale=1.0), np.random.normal(loc=0.0, scale=1.0), np.random.normal(loc=0.0, scale=1.0)], dtype=float) # Generate 3 indepdendent normal deviates\n a_normalised = a_unnormalised/(np.sum(a_unnormalised**2)**-0.5) # Normallise sample onto unit 3-sphere - As in Muller (1959)\n # And normallise so that vector magnitude = 1:\n a_normalised = a_normalised/((np.sum(a_normalised**2))**0.5)\n x = a_normalised[0]\n y = a_normalised[1]\n z = a_normalised[2]\n theta = np.arctan2(np.sqrt((x**2)+(y**2)),z) #np.arccos(z)\n phi = np.arctan2(y,x) #np.arccos(x/np.sin(theta))\n DC_crack_MT_rotated = rot_mt_by_theta_phi(DC_crack_MT_to_rot, theta, phi)\n # 4. Normalise and get 6 MT:\n # Get 6 MT:\n DC_crack_six_MT_rotated = get_six_MT_from_full_MT_array(DC_crack_MT_rotated)\n # And normallise so that moment tensor magnitude = 1:\n DC_crack_six_MT_rotated_normalised = DC_crack_six_MT_rotated/((np.sum(DC_crack_six_MT_rotated**2))**0.5)\n # And set to correct dimensions (so matrix multiplication in forward model works correctly):\n DC_crack_six_MT_rotated_normalised = np.reshape(DC_crack_six_MT_rotated_normalised, (6, 1))\n return DC_crack_six_MT_rotated_normalised, random_amp_frac","def build_fully_biconnected_test_graph():\n graph = build_biconnected_test_graph()\n\n # Connect the first and third components to create a ring, converting everything into a single biconnected component\n graph.new_edge(1, 12)\n\n return graph","def test_pl_to_braket_circuit():\n dev = _aws_device(wires=2, foo=\"bar\")\n\n with QuantumTape() as tape:\n qml.RX(0.2, wires=0)\n qml.RX(0.3, wires=1)\n qml.CNOT(wires=[0, 1])\n qml.expval(qml.PauliZ(0))\n\n braket_circuit_true = (\n Circuit()\n .rx(0, 0.2)\n .rx(1, 0.3)\n .cnot(0, 1)\n .add_result_type(result_types.Expectation(observable=Observable.Z(), target=0))\n )\n\n braket_circuit = dev._pl_to_braket_circuit(tape)\n\n assert braket_circuit_true == braket_circuit","def setup_ringbuffer_datastream(context):\n\tchan = context.create_channel(\"ring\", 5000000, 50,\n\t\t\t0, ringbuffer=True)\n\tenabled = {\n\t\t\"SCHED\" : True,\n\t\t\"SIGNAL_FAM\" : True,\n\t\t\"SYSCALL\" : True,\n\t\t\"TASKALIAS\": True,\n\t\t\"DSKITRACE\": True\n\t}\n\tring_ds = context.create_datastream(\"ds_ring\", \"ring\")\n\tds.process_enabled_dict(enabled)\n\treturn chan","def test_cliches_write_good_basic(self):\n assert chk.check_cliches_write_good(\"\"\"No cliches here.\"\"\") == []\n # use one of the example cliches to verify basic functionality\n assert chk.check_cliches_write_good(self.l_write_good) != []\n assert \"cliches.write_good\" in chk.check_cliches_write_good(\n self.l_write_good)[0]","def create_cone(base=1.0, height=1.0, lat=20, lng=20, color=COLOR_WHITE):\n if lat >= 3 and lng >= 10:\n circlebase = create_circle(base - 0.05, 0.1, [0.0, 0.0, -1.0], color)\n obj = glGenLists(1)\n glNewList(obj, GL_COMPILE)\n glPushMatrix()\n glColor4fv(color)\n try:\n glutSolidCone(base, height, lat, lng)\n except:\n if not _ERRS[3]:\n printGLError(\n \"la version actual de OpenGL no posee la funcion glutSolidCone\")\n _ERRS[3] = True\n glCallList(circlebase)\n glPopMatrix()\n glEndList()\n return obj\n else:\n raise Exception(\n \"La latitud y longitud de la figura deben ser mayores a 3\")","def ring_forming_scission(rct_zmas, prd_zmas):\n ret = None\n rct_zmas, rct_gras = shifted_standard_zmas_graphs(\n rct_zmas, remove_stereo=True)\n prd_zmas, prd_gras = shifted_standard_zmas_graphs(\n prd_zmas, remove_stereo=True)\n tras, _, _ = automol.graph.reac.ring_forming_scission(rct_gras, prd_gras)\n if tras:\n tra = tras[0]\n brk_bnd_key, = automol.graph.trans.broken_bond_keys(tra)\n frm_bnd_key, = automol.graph.trans.formed_bond_keys(tra)\n ts_zma = rct_zmas[0]\n\n # set up radical atom, leaving atom, newly formed radical atom\n # also set up chain between radical atom and newly formed radical atom\n ts_gra = automol.zmatrix.graph(ts_zma)\n rad_atm = list(automol.graph.sing_res_dom_radical_atom_keys(ts_gra))[0]\n for atm in brk_bnd_key:\n if atm not in frm_bnd_key:\n leave_atm = atm\n else:\n new_rad_atm = atm\n\n chain_between = automol.zmatrix.chain_between(ts_zma, new_rad_atm, rad_atm)\n\n tors_names = automol.zmatrix.torsion_coordinate_names(ts_zma)\n coo_dct = automol.zmatrix.coordinates(ts_zma)\n ang_90 = numpy.pi/2.\n ts_tors_names = []\n const_tors_names = []\n # (i) set torsion from rad atom towards chain to 90\n for tors_name in tors_names:\n axis = coo_dct[tors_name][0][1:3]\n # (ii) remove torsions in chain_between from final torsion sampling list\n if ((axis[0] not in chain_between) or (axis[1] not in chain_between)):\n ts_tors_names.append(tors_name)\n if ((rad_atm == axis[0] and axis[1] in chain_between) or\n (rad_atm == axis[1] and axis[0] in chain_between)):\n ts_zma_p = automol.zmatrix.set_values(ts_zma, {tors_name: ang_90})\n # const_tors_names.append(tors_name)\n\n # (iii) vary torsions in chain_between to minimize distance from rad_atm to new_rad_atm\n preopt_tors_names = []\n for tors_name in tors_names:\n axis = coo_dct[tors_name][0][1:3]\n if ((axis[0] in chain_between) and (axis[1] in chain_between) and\n (rad_atm not in axis) and (new_rad_atm not in axis)):\n preopt_tors_names.append(tors_name)\n # add any ring forming torsions to constraints to ensure 0 dihedrals for the ring\n const_tors_names.append(tors_name)\n\n angles = [0., 2.*numpy.pi/3, 4.*numpy.pi/3]\n # angles = [0., numpy.pi/3., 2.*numpy.pi/3, 3.*numpy.pi/3., 4.*numpy.pi/3, 5*numpy.pi/3.]\n trial_zmas = [ts_zma_p]\n for preopt_tors_name in preopt_tors_names:\n new_trial_zmas = []\n for zma_i in trial_zmas:\n for ang in angles:\n new_trial_zmas.append(\n automol.zmatrix.set_values(\n zma_i, {preopt_tors_name: ang}))\n trial_zmas = new_trial_zmas\n\n dist_min = 1.0e30\n for trial_zma in trial_zmas:\n geo_i = automol.zmatrix.geometry(trial_zma)\n dist = automol.geom.distance(geo_i, rad_atm, new_rad_atm)\n if dist < dist_min:\n dist_min = dist\n ts_zma = trial_zma\n\n ang_stp = 2.*numpy.pi/6.\n # (iv) vary torsion from new_rad_atm to leaving atom so that leave_atm is far from rad_atm\n for tors_name in tors_names:\n ang = -ang_stp\n axis = coo_dct[tors_name][0][1:3]\n if ((new_rad_atm == axis[0] and axis[1] in chain_between) or\n (new_rad_atm == axis[1] and axis[0] in chain_between)):\n dist_max = 0.0\n for _ in range(6):\n ang += ang_stp\n ts_zma_i = automol.zmatrix.set_values(ts_zma, {tors_name: ang})\n geo_i = automol.zmatrix.geometry(ts_zma_i)\n dist = automol.geom.distance(geo_i, rad_atm, leave_atm)\n if dist > dist_max:\n dist_max = dist\n ts_zma_max = ts_zma_i\n const_tors_names.append(tors_name)\n # set up ts torsions - remove ones with axis in the chain between new and old rad atoms\n if ((axis[0] not in chain_between) or (axis[1] not in chain_between)):\n ts_tors_names.append(tors_name)\n # elif (axis[0] in chain_between) and (axis[1] in chain_between):\n # if tors_name not in const_tors_names:\n # const_tors_names.append(tors_name)\n\n ts_zma = ts_zma_max\n\n # (v) vary angles to decrease rad_atm to new_rad_atm to < 2.25 Ang\n dist_thresh = 4.25\n # dist_thresh = 4.\n ang_names = automol.zmatrix.central_angle_names(ts_zma)\n ring_angs = []\n const_angs_names = []\n for ang_name in ang_names:\n ang_atms = coo_dct[ang_name][0]\n if ((ang_atms[0] in chain_between) and (ang_atms[1] in chain_between) and\n (ang_atms[2] in chain_between)):\n ring_angs.append(ang_name)\n const_angs_names.append(ang_name)\n dist = 1.e30\n ang_stp = numpy.pi/360.\n # ang_stp = 0.5 degrees\n counter = 0\n while ((dist > dist_thresh) and (counter < 30)):\n counter += 1\n values = automol.zmatrix.values(ts_zma)\n for ang_name in ring_angs:\n ang = values[ang_name] - ang_stp\n ts_zma = automol.zmatrix.set_values(ts_zma, {ang_name: ang})\n geo_i = automol.zmatrix.geometry(ts_zma)\n dist = automol.geom.distance(geo_i, rad_atm, new_rad_atm)\n\n brk_dist_name = automol.zmatrix.bond_key_from_idxs(ts_zma, brk_bnd_key)\n\n # Build the reactants graph\n rcts_gra = automol.graph.union_from_sequence(rct_gras)\n\n # Set the indices for the const coords\n\n ret = (ts_zma, brk_dist_name, brk_bnd_key,\n tuple(const_tors_names), tuple(ts_tors_names),\n tuple(const_angs_names), rcts_gra)\n\n return ret","def prepare_circ_burn(mission):\n vessel = mission.conn.space_center.active_vessel\n apo_time = vessel.orbit.time_to_apoapsis\n ap = vessel.auto_pilot\n\n if mission.current_step[\"first_call\"]:\n circ_burn = compute_circ_burn(vessel)\n circ_burn[\"burn_start_time\"] = mission.ut() + apo_time - (circ_burn[\"burn_time\"] / 2.)\n circ_burn[\"node\"] = vessel.control.add_node(mission.ut() + apo_time,\n prograde=circ_burn[\"delta_v\"])\n\n mission.parameters[\"circ_burn\"] = circ_burn\n vessel.control.rcs = True\n ap.engage()\n ap.reference_frame = circ_burn[\"node\"].reference_frame\n ap.target_direction = (0, 1, 0)\n\n else:\n circ_burn = mission.parameters[\"circ_burn\"]\n burn_ut = circ_burn[\"burn_start_time\"]\n\n if burn_ut < mission.ut():\n # burn right now!\n mission.next('execute_circ_burn')\n\n elif ap.error < 1 and mission.ut() - mission.current_step[\"start_ut\"] > 1:\n lead_time = 15\n if burn_ut > mission.ut() + lead_time * 2:\n mission.conn.space_center.warp_to(burn_ut - lead_time)\n mission.next()","async def handleChannelCreate(self, channel: discord.abc.GuildChannel):\n self.logger.info(\n \"Channel creation has been detected. Name: %s, ID: %s\", channel.name, channel.id\n )\n\n if not isinstance(channel, discord.TextChannel):\n return\n\n if channel.name == AH_CHANNEL:\n self.logger.info(\"%s detected, applying exceptions\", AH_CHANNEL)\n ctx = await self.getContext(channel)\n if not ctx:\n return\n await self.notifyChannel(ctx)\n await self.makeHighlightChanges(ctx, channel)\n await self.makeStarboardChanges(ctx, channel)\n await self.makeWordFilterChanges(ctx, channel)\n async with self.config.guild(channel.guild).get_attr(KEY_CHANNEL_IDS)() as channelIds:\n channelIds[channel.id] = {\"time\": datetime.now().timestamp()}","def concur_wait(self, node):\n global BARRIER_CTR\n\n # This method will be destructive, unless we make a new\n # copy of the AST tree first\n #\n node = deepcopy(node)\n\n seen_channels = set()\n\n # Channels in this with_concur\n concur_channels = find_all_channels(node)\n\n # For creating the Barriers, we want QGL1 scoped variables that will be real channel instances.\n # We basically have that already.\n real_chans = set()\n for chan in concur_channels:\n real_chans.add(chan)\n\n start_barrier = BARRIER_CTR\n end_barrier = start_barrier + 1\n BARRIER_CTR += 2\n\n for stmnt in node.body:\n if not is_seq(stmnt):\n NodeError.error_msg(stmnt,\n 'non-seq block inside concur block?')\n return node\n\n seq_channels = find_all_channels(stmnt)\n\n if seq_channels.intersection(seen_channels):\n NodeError.error_msg(stmnt,\n 'seq blocks have overlapping channels')\n return node\n\n seen_channels = seen_channels.union(seq_channels)\n\n chan_name = ','.join(seq_channels)\n\n # mark stmnt with chan_name or seq_channels in another way\n if hasattr(stmnt, 'qgl_chan_list'):\n oldChanSet = set(stmnt.qgl_chan_list)\n newChanSet = seq_channels\n oldMissing = newChanSet - oldChanSet\n oldExtra = oldChanSet - newChanSet\n if len(oldMissing) > 0:\n NodeError.diag_msg(stmnt, 'marked chan list %s was missing %s' % (str(oldChanSet), str(oldMissing)))\n if len(oldExtra) > 0:\n NodeError.diag_msg(stmnt, 'marked chan list %s had extra %s' % (str(oldChanSet), str(oldExtra)))\n NodeError.diag_msg(stmnt, 'Marking chan list %s' % (str(seq_channels)))\n stmnt.qgl_chan_list = list(seq_channels)\n\n new_seq_body = list()\n\n # Helper to ensure the string we feed to AST doesn't put quotes around\n # our Qubit variable names\n def appendChans(bString, chans):\n bString += '['\n first = True\n for chan in chans:\n if first:\n bString += str(chan)\n first = False\n else:\n bString += \",\" + str(chan)\n bString += ']'\n return bString\n\n # Add global ctr, chanlist=concur_channels\n # FIXME: Hold concur_channels as a string? List?\n bstring = 'Barrier(\"%s\", ' % str(start_barrier)\n bstring = appendChans(bstring, list(real_chans))\n bstring += ')\\n'\n barrier_ast = expr2ast(bstring)\n # barrier_ast = expr2ast('Barrier(%s, %s)\\n' % (str(start_barrier), list(real_chans)))\n copy_all_loc(barrier_ast, node)\n barrier_ast.channels = concur_channels\n # print(\"*****Start barrier: %s\" % pyqgl2.ast_util.ast2str(barrier_ast))\n\n new_seq_body.append(barrier_ast)\n\n new_seq_body += stmnt.body\n\n bstring = 'Barrier(\"%s\", ' % str(end_barrier)\n bstring = appendChans(bstring, list(real_chans))\n bstring += ')\\n'\n end_barrier_ast = expr2ast(bstring)\n #end_barrier_ast = expr2ast('Barrier(%s, %s)\\n' % (str(end_barrier), list(real_chans)))\n copy_all_loc(end_barrier_ast, node)\n # Add global ctr, chanlist=concur_channels\n end_barrier_ast.channels = concur_channels\n\n # print('End AST: %s' % ast2str(end_barrier_ast))\n\n new_seq_body.append(end_barrier_ast)\n\n stmnt.body = new_seq_body\n\n # FIXME: In new thinking, is the proper unseen set the global one,\n # Or only those local to this with concur. I think only local\n for unseen_chan in concur_channels - seen_channels:\n #print('DIAG %s' % ast2str(stmnt))\n NodeError.diag_msg(stmnt,\n 'channels unreferenced in concur: %s' % str(unseen_chan))\n\n bstring = 'with seq:\\n Barrier(\"%s\", ' % str(start_barrier)\n bstring = appendChans(bstring, list(real_chans))\n bstring += ')\\n Barrier(\"%s\",' % str(end_barrier)\n bstring = appendChans(bstring, list(real_chans))\n bstring += ')\\n'\n empty_seq_ast = expr2ast(bstring)\n # print('Empty AST: %s' % ast2str(empty_seq_ast))\n # empty_seq_ast = expr2ast(\n # 'with seq:\\n Barrier(%s, %s)\\n Barrier(%s, %s)' % (str(start_barrier), list(real_chans), str(end_barrier), list(real_chans)))\n\n # Mark empty_seq_ast with unseen_chan\n empty_seq_ast.qgl_chan_list = [unseen_chan]\n copy_all_loc(empty_seq_ast, node)\n node.body.append(empty_seq_ast)\n\n return node","def draw_housing():\n tess.pensize(3)\n tess.color(\"black\", \"darkgrey\")\n tess.begin_fill()\n tess.forward(80)\n tess.left(90)\n tess.forward(200)\n tess.circle(40, 180)\n tess.forward(200)\n tess.left(90)\n tess.end_fill()\n tess.hideturtle()","def test_state_channel_identifier_invalid(\n token_network: Contract, get_accounts: Callable, create_channel: Callable\n) -> None:\n (A, B, C) = get_accounts(3)\n channel_id = 0\n\n pairs = permutations([A, B, C], 2)\n for pair in pairs:\n state = token_network.functions.getChannelState(channel_id, *pair).call()\n settle_block_number = token_network.functions.settleable_after(channel_id).call()\n assert settle_block_number == 0\n assert state == ChannelState.NONEXISTENT\n\n for pair in pairs:\n create_channel(*pair)\n state = token_network.functions.getChannelState(0, *pair).call()\n settle_block_number = token_network.functions.settleable_after(0)\n assert settle_block_number == 0 # initialized on channel close\n assert state == ChannelState.OPENED\n\n current_counter = token_network.functions.channel_counter().call()\n\n for pair in pairs:\n state = token_network.functions.getChannelState(current_counter + 1, *pair).call()\n settle_block_number = token_network.functions.settleable_after(current_counter + 1).call()\n assert settle_block_number == 0\n assert state == ChannelState.NONEXISTENT","def build_cochlear_model(tensor_waveform,\n signal_rate=20000,\n filter_type='half-cosine',\n filter_spacing='erb',\n HIGH_LIM=8000,\n LOW_LIM=20,\n N=40,\n SAMPLE_FACTOR=1,\n bandwidth_scale_factor=1.0,\n compression='stable_point3',\n include_highpass=False,\n include_lowpass=False,\n linear_max=1.0,\n rFFT=True,\n rectify_and_lowpass_subbands=True,\n return_subbands_only=True,\n **kwargs):\n signal_length = tensor_waveform.get_shape().as_list()[-1]\n \n if filter_type == 'half-cosine':\n assert HIGH_LIM <= signal_rate/2, \"cochlear filterbank high_lim is above Nyquist frequency\"\n filts, center_freqs, freqs = make_cos_filters_nx(\n signal_length,\n signal_rate,\n N,\n LOW_LIM,\n HIGH_LIM,\n SAMPLE_FACTOR,\n padding_size=None,\n full_filter=True,\n strict=True,\n bandwidth_scale_factor=bandwidth_scale_factor,\n include_lowpass=include_lowpass,\n include_highpass=include_highpass,\n filter_spacing=filter_spacing)\n assert filts.shape[1] == signal_length, \"filter array shape must match signal length\"\n else:\n raise ValueError('Specified filter_type {} is not supported'.format(filter_type))\n \n coch_container = {'input_signal': tensor_waveform}\n coch_container = cochleagram_graph(\n coch_container,\n signal_length,\n signal_rate,\n LOW_LIM=LOW_LIM,\n HIGH_LIM=HIGH_LIM,\n N=N,\n SAMPLE_FACTOR=SAMPLE_FACTOR,\n custom_filts=filts,\n linear_max=linear_max,\n rFFT=rFFT,\n rectify_and_lowpass_subbands=rectify_and_lowpass_subbands,\n return_subbands_only=return_subbands_only,\n **kwargs)\n \n tensor_cochlear_representation = coch_container['output_tfcoch_graph']\n return tensor_cochlear_representation, coch_container","def checkRing(self, verbose = 0):\n angleSum = self.tfs.ANGLE.sum()\n if self.verbose: print (\"check\")\n print (\"---------------------------------- \\n Checking, if ring is closed: \\n\", \"angleSum = \", angleSum)\n twoPi = 2*pi\n \n if angleSum != twoPi:\n fudge = 2*pi - angleSum\n print (\" ** Ring not closed - offset of: \", fudge)","def open_circ():\n\n set_mode(mode_cc) # set operation mode to CC\n time.sleep(.250)\n set_CC_current(cc_current=0) # set CC mode current to 0 amps\n time.sleep(.1)\n \n oc_vals = get_input_values() # read open circuits levels\n oc_data_point = data_point(oc_vals) # create data point for open circuit measurement\n voc = oc_data_point[3] # open circuit voltage measurement\n print('Open circuit voltage: ', voc)\n write_data_tofile(oc_data_point) # write data to file\n \n return voc","def CascadeLlhVertexFit(tray, name, CascadeLlh, Pulses='TWNFEMergedPulses', If=lambda frame: True):\r\n\ticetray.load('clast', False)\r\n\ticetray.load('cscd-llh', False)\r\n\t\r\n\t# Settings from std-processing/releases/11-02-00/scripts/IC79/level2_DoCascadeReco.py\r\n\tCscdLlhVertexFitter = icetray.module_altconfig('I3CscdLlhModule',\r\n\tInputType='RecoPulse', MinHits=5,\r\n\tMinimizer='Powell', PDF='UPandel',\r\n\tParamT='1.0, 0.0, 0.0, false',\r\n\tParamX='1.0, 0.0, 0.0, false',\r\n\tParamY='1.0, 0.0, 0.0, false',\r\n\tParamZ='1.0, 0.0, 0.0, false',\r\n\t)\r\n\r\n\tseed = name + '_CLastSeed'\r\n\ttray.AddModule('I3CLastModule', name+'Clast',\r\n\t Name=seed, InputReadout=Pulses, If=If, MinHits=5)\r\n\tif CascadeLlh:\r\n\t\ttray.AddSegment(CscdLlhVertexFitter, name+'CscdLlh',\r\n\t\t\tRecoSeries=Pulses, SeedKey=seed,\r\n\t\t\tResultName=name+\"_CscdLlh\", If=If\r\n\t)\r\n\t\r\n\treturn [seed, seed+'Params', name, name+'Params']","def is_ring(self): # -> bool:\n ...","def make_shape_ccw(self):\n\n if not(self.closed):\n return\n\n # Optimization for closed shapes\n # Start value for the first sum\n\n if self.isDirectionOfGeosCCW(self.geos):\n self.reverse()\n logger.debug(self.tr(\"Had to reverse the shape to be CW\"))\n self.cw = True","def add_rand_circ() -> int:\n r = randint(10, 100)\n x = randint(r, WIDTH - r)\n y = randint(r, HEIGHT - r)\n vx = randint(-10, 10)\n vy = randint(-10, 10)\n color = COLORS[randint(0, len(COLORS) - 1)]\n add_circ(x, y, r, vx, vy, color, int(100 / r))\n return 0","def gen_chip(cfpath, gfpath, bbox, theta, new_size, filter_list=[]):\n chipBGR = ctool.compute_chip(gfpath, bbox, theta, new_size, filter_list)\n return chipBGR, cfpath","def bend_s(\n size: Float2 = (10.0, 2.0),\n nb_points: int = 99,\n with_cladding_box: bool = True,\n cross_section: CrossSectionFactory = strip,\n **kwargs\n) -> Component:\n dx, dy = size\n x = cross_section(**kwargs)\n width = x.info[\"width\"]\n layer = x.info[\"layer\"]\n\n c = Component()\n\n bend = bezier(\n width=width,\n control_points=[(0, 0), (dx / 2, 0), (dx / 2, dy), (dx, dy)],\n npoints=nb_points,\n layer=layer,\n )\n\n bend_ref = c << bend\n c.add_ports(bend_ref.ports)\n c.copy_child_info(bend)\n c.info[\"start_angle\"] = bend.info[\"start_angle\"]\n c.info[\"end_angle\"] = bend.info[\"end_angle\"]\n c.info[\"length\"] = bend.info[\"length\"]\n c.info[\"min_bend_radius\"] = bend.info[\"min_bend_radius\"]\n\n if with_cladding_box and x.info[\"layers_cladding\"]:\n layers_cladding = x.info[\"layers_cladding\"]\n cladding_offset = x.info[\"cladding_offset\"]\n points = get_padding_points(\n component=c,\n default=0,\n bottom=cladding_offset,\n top=cladding_offset,\n )\n for layer in layers_cladding or []:\n c.add_polygon(points, layer=layer)\n\n auto_rename_ports(c)\n return c","def polyPlatonicSolid(*args, axis: Union[List[float, float, float], bool]=None, caching:\n bool=True, constructionHistory: bool=True, createUVs: int=4, name:\n AnyStr=\"\", nodeState: Union[int, bool]=0, object: bool=True, radius:\n Union[float, bool]=1.0, sideLength: Union[float, bool]=1.0, solidType:\n int=0, texture: int=0, q=True, query=True, e=True, edit=True,\n **kwargs)->Union[List[AnyStr], Any]:\n pass","def __make_carriage(self):\n # Create base rectangle\n length = self.parameters['carriage_length']\n width = self.parameters['carriage_width']\n height = self.parameters['carriage_height']\n carriage = fso.Box(x=length, y=width, z=height)\n\n # Subtract slide from carraige\n slide_width = self.parameters['slide_width'] + 2*self.parameters['slide_tolerance']\n slide_height = self.parameters['slide_height'] + 2*self.parameters['slide_tolerance']\n slide_negative = fso.Box(x=2*length, y=slide_width, z=slide_height)\n carriage = carriage - slide_negative\n\n # Create mounting holes\n radius = 0.5*self.parameters['carriage_screw_size']\n base_hole = fso.Cylinder(r=radius,l=2*height)\n hole_list = []\n for i in (-1,1):\n for j in (-1,1):\n xpos = i*0.5*self.parameters['carriage_screw_dL']\n ypos = j*0.5*self.parameters['carriage_screw_dW']\n hole = base_hole.copy()\n hole.translate([xpos,ypos,0])\n hole_list.append(hole)\n # Remove hole material\n # print hole_list\n carriage -= hole_list\n carriage.set_color(self.carriage_color,recursive=True)\n self.carriage = carriage","def ring_is_clockwise(ring):\n total = 0\n for (pt1, pt2) in pairwise(ring):\n total += (pt2[0] - pt1[0]) * (pt2[1] + pt1[1])\n return total >= 0","def run(self, verbose=False, build_graph=False):\n from sage.combinat.crystals.letters import CrystalOfLetters\n letters = CrystalOfLetters(self.rigged_con.parent()._cartan_type.classical())\n\n # This is technically bad, but because the first thing we do is append\n # an empty list to ret_crystal_path, we correct this. We do it this\n # way so that we do not have to remove an empty list after the\n # bijection has been performed.\n ret_crystal_path = []\n\n for dim in self.rigged_con.parent().dims:\n ret_crystal_path.append([])\n\n # Check to see if we are a spinor\n if dim[0] == self.n:\n # Perform the spinor bijection by converting to type A_{2n-1}^{(2)}\n # doing the bijection there and pulling back\n\n from sage.combinat.rigged_configurations.bij_type_A2_odd import RCToKRTBijectionTypeA2Odd\n from sage.combinat.rigged_configurations.rigged_configurations import RiggedConfigurations\n from sage.combinat.rigged_configurations.rigged_partition import RiggedPartition, RiggedPartitionTypeB\n \n # Convert to a type A_{2n-1}^{(2)} RC\n RC = RiggedConfigurations(['A', 2*self.n-1, 2], self.cur_dims)\n if verbose:\n print(\"====================\")\n print(repr(RC(*self.cur_partitions, use_vacancy_numbers=True)))\n print(\"--------------------\")\n print(ret_crystal_path)\n print(\"--------------------\\n\")\n print(\"Applying doubling map\\n\")\n # Convert the n-th partition into a regular rigged partition\n self.cur_partitions[-1] = RiggedPartition(self.cur_partitions[-1]._list,\n self.cur_partitions[-1].rigging,\n self.cur_partitions[-1].vacancy_numbers)\n\n bij = RCToKRTBijectionTypeA2Odd(RC(*self.cur_partitions, use_vacancy_numbers=True))\n for i in range(len(self.cur_dims)):\n if bij.cur_dims[i][0] != self.n:\n bij.cur_dims[i][1] *= 2\n for i in range(self.n-1):\n for j in range(len(bij.cur_partitions[i])):\n bij.cur_partitions[i]._list[j] *= 2\n bij.cur_partitions[i].rigging[j] *= 2\n bij.cur_partitions[i].vacancy_numbers[j] *= 2\n\n if build_graph:\n y = self.rigged_con.parent()(*[x._clone() for x in self.cur_partitions], use_vacancy_numbers=True)\n self._graph.append([self._graph[-1][1], (y, len(self._graph)), '2x'])\n \n # Perform the type A_{2n-1}^{(2)} bijection\n \n # Iterate over each column\n for dummy_var in range(dim[1]):\n # Split off a new column if necessary\n if bij.cur_dims[0][1] > 1:\n bij.cur_dims[0][1] -= 1\n bij.cur_dims.insert(0, [dim[0], 1])\n \n # Perform the corresponding splitting map on rigged configurations\n # All it does is update the vacancy numbers on the RC side\n for a in range(self.n):\n bij._update_vacancy_numbers(a)\n\n if build_graph:\n y = self.rigged_con.parent()(*[x._clone() for x in self.cur_partitions], use_vacancy_numbers=True)\n self._graph.append([self._graph[-1][1], (y, len(self._graph)), 'ls'])\n \n while bij.cur_dims[0][0] > 0:\n if verbose:\n print(\"====================\")\n print(repr(RC(*bij.cur_partitions, use_vacancy_numbers=True)))\n print(\"--------------------\")\n print(ret_crystal_path)\n print(\"--------------------\\n\")\n\n bij.cur_dims[0][0] -= 1 # This takes care of the indexing\n b = bij.next_state(bij.cur_dims[0][0])\n # Make sure we have a crystal letter\n ret_crystal_path[-1].append(letters(b)) # Append the rank\n\n if build_graph:\n y = self.rigged_con.parent()(*[x._clone() for x in self.cur_partitions], use_vacancy_numbers=True)\n self._graph.append([self._graph[-1][1], (y, len(self._graph)), letters(b)])\n\n bij.cur_dims.pop(0) # Pop off the leading column\n\n self.cur_dims.pop(0) # Pop off the spin rectangle\n\n self.cur_partitions = bij.cur_partitions\n # Convert the n-th partition back into the special type B one\n self.cur_partitions[-1] = RiggedPartitionTypeB(self.cur_partitions[-1])\n\n # Convert back to a type B_n^{(1)}\n if verbose:\n print(\"====================\")\n print(repr(self.rigged_con.parent()(*bij.cur_partitions, use_vacancy_numbers=True)))\n print(\"--------------------\")\n print(ret_crystal_path)\n print(\"--------------------\\n\")\n print(\"Applying halving map\\n\")\n\n for i in range(self.n-1):\n for j in range(len(self.cur_partitions[i])):\n self.cur_partitions[i]._list[j] //= 2\n self.cur_partitions[i].rigging[j] //= 2\n self.cur_partitions[i].vacancy_numbers[j] //= 2\n\n if build_graph:\n y = self.rigged_con.parent()(*[x._clone() for x in self.cur_partitions], use_vacancy_numbers=True)\n self._graph.append([self._graph[-1][1], (y, len(self._graph)), '1/2x'])\n else:\n # Perform the regular type B_n^{(1)} bijection\n\n # Iterate over each column\n for dummy_var in range(dim[1]):\n # Split off a new column if necessary\n if self.cur_dims[0][1] > 1:\n if verbose:\n print(\"====================\")\n print(repr(self.rigged_con.parent()(*self.cur_partitions, use_vacancy_numbers=True)))\n print(\"--------------------\")\n print(ret_crystal_path)\n print(\"--------------------\\n\")\n print(\"Applying column split\")\n\n self.cur_dims[0][1] -= 1\n self.cur_dims.insert(0, [dim[0], 1])\n\n # Perform the corresponding splitting map on rigged configurations\n # All it does is update the vacancy numbers on the RC side\n for a in range(self.n):\n self._update_vacancy_numbers(a)\n\n if build_graph:\n y = self.rigged_con.parent()(*[x._clone() for x in self.cur_partitions], use_vacancy_numbers=True)\n self._graph.append([self._graph[-1][1], (y, len(self._graph)), '2x'])\n\n while self.cur_dims[0][0] > 0:\n if verbose:\n print(\"====================\")\n print(repr(self.rigged_con.parent()(*self.cur_partitions, use_vacancy_numbers=True)))\n print(\"--------------------\")\n print(ret_crystal_path)\n print(\"--------------------\\n\")\n\n self.cur_dims[0][0] -= 1 # This takes care of the indexing\n b = self.next_state(self.cur_dims[0][0])\n\n # Make sure we have a crystal letter\n ret_crystal_path[-1].append(letters(b)) # Append the rank\n\n if build_graph:\n y = self.rigged_con.parent()(*[x._clone() for x in self.cur_partitions], use_vacancy_numbers=True)\n self._graph.append([self._graph[-1][1], (y, len(self._graph)), letters(b)])\n\n self.cur_dims.pop(0) # Pop off the leading column\n\n if build_graph:\n self._graph.pop(0) # Remove the dummy at the start\n from sage.graphs.digraph import DiGraph\n from sage.graphs.dot2tex_utils import have_dot2tex\n self._graph = DiGraph(self._graph)\n if have_dot2tex():\n self._graph.set_latex_options(format=\"dot2tex\", edge_labels=True)\n\n return self.KRT(pathlist=ret_crystal_path)","def _constructArc(self, a, b, c):\n arc = pcbnew.PCB_SHAPE()\n arc.SetShape(STROKE_T.S_ARC)\n arc.SetLayer(Layer.Edge_Cuts)\n arc.SetArcGeometry(toKiCADPoint(a), toKiCADPoint(b), toKiCADPoint(c))\n return arc","def _small_circuit():\n qr = QuantumRegister(1, name='qr')\n cr = ClassicalRegister(1, name='cr')\n circuit = QuantumCircuit(qr, cr)\n\n circuit.x(qr[0])\n circuit.barrier(qr[0])\n circuit.measure(qr, cr)\n\n return circuit","def CheckClearance(self, via, area, clearance):\r\n p1 = via.GetPosition()\r\n corners = area.GetNumCorners()\r\n # Calculate minimum distance from corners\r\n # TODO: remove?\r\n for i in range(corners):\r\n corner = area.GetCornerPosition(i)\r\n p2 = corner.getWxPoint()\r\n the_distance = norm(p2 - p1) # sqrt((p2.x - p1.x) ** 2 + (p2.y - p1.y) ** 2)\r\n\r\n if the_distance < clearance:\r\n return False\r\n\r\n for i in range(corners):\r\n corner1 = area.GetCornerPosition(i)\r\n corner2 = area.GetCornerPosition((i + 1) % corners)\r\n pc1 = corner1.getWxPoint()\r\n pc2 = corner2.getWxPoint()\r\n the_distance, _ = pnt2line(p1, pc1, pc2)\r\n\r\n if the_distance <= clearance:\r\n return False\r\n\r\n for edge in self.board_edges:\r\n if edge.ShowShape() == 'Line':\r\n the_distance, _ = pnt2line(p1, edge.GetStart(), edge.GetEnd())\r\n if the_distance <= clearance + via.GetWidth() / 2:\r\n return False\r\n if edge.ShowShape() == 'Arc':\r\n # distance from center of Arc and with angle within Arc angle should be outside Arc radius +- clearance + via Width/2\r\n center = edge.GetPosition()\r\n start = edge.GetStart()\r\n end = edge.GetEnd()\r\n radius = norm(center - end)\r\n dist = norm(p1 - center)\r\n if radius - (self.clearance + via.GetWidth() / 2) < dist < radius + (\r\n self.clearance + via.GetWidth() / 2):\r\n # via is in range need to check the angle\r\n start_angle = math.atan2((start - center).y, (start - center).x)\r\n end_angle = math.atan2((end - center).y, (end - center).x)\r\n if end_angle < start_angle:\r\n end_angle += 2 * math.pi\r\n point_angle = math.atan2((p1 - center).y, (p1 - center).x)\r\n if start_angle <= point_angle <= end_angle:\r\n return False\r\n\r\n return True","def add_carboxyl(atom, atom_list, added_functional_groups, ct):\n \n global anywhere_map\n global edge_map\n current_size = len(atom_list)\n placed = 0\n alpha = random.randint(0,359)\n x = atom.x\n y = atom.y\n z = atom.z\n while (placed <= 359):\n alpha += 1\n carbon_atom = Atom(current_size + 1, 'C4', 'C1A', str(added_functional_groups + 1), float(\"{0:.3f}\".format(x)), float(\"{0:.3f}\".format(y)), float(\"{0:.3f}\".format(ct * 1.52 + z)))\n atom_list.append(carbon_atom)\n if ((len(identify_bonds(carbon_atom, atom_list)) == 1) and (identify_bonds(carbon_atom, atom_list)[0][0].atom_number == atom.atom_number)):\n h = math.sin(math.radians(60)) * 1.20\n oxygen_atom_1 = Atom(current_size + 2, 'OJ', 'C1A', str(added_functional_groups + 1), float(\"{0:.3f}\".format(carbon_atom.x - math.cos(math.radians(alpha)) * h)), float(\"{0:.3f}\".format(carbon_atom.y - math.sin(math.radians(alpha)) * h)), float(\"{0:.3f}\".format(carbon_atom.z + ct * math.cos(math.radians(60)) * 1.20)))\n atom_list.append(oxygen_atom_1)\n if ((len(identify_bonds(oxygen_atom_1, atom_list)) == 1) and (identify_bonds(oxygen_atom_1, atom_list)[0][0].atom_number == carbon_atom.atom_number)):\n h = math.sin(math.radians(60)) * 1.34\n oxygen_atom_2 = Atom(current_size + 3, 'OK', 'C1A', str(added_functional_groups + 1), float(\"{0:.3f}\".format(carbon_atom.x - math.cos(math.radians(alpha + 180)) * h)), float(\"{0:.3f}\".format(carbon_atom.y - math.sin(math.radians(alpha+180)) * h)), float(\"{0:.3f}\".format(carbon_atom.z + ct * math.cos(math.radians(60)) * 1.34)) )\n atom_list.append(oxygen_atom_2)\n if ((len(identify_bonds(oxygen_atom_2, atom_list)) == 1) and (identify_bonds(oxygen_atom_2, atom_list)[0][0].atom_number == carbon_atom.atom_number)):\n hydrogen_atom = Atom(current_size + 4, 'HK', 'C1A', str(added_functional_groups + 1), float(\"{0:.3f}\".format(oxygen_atom_2.x)), float(\"{0:.3f}\".format(oxygen_atom_2.y)), float(\"{0:.3f}\".format(oxygen_atom_2.z+ct*0.98)))\n atom_list.append(hydrogen_atom)\n if ((len(identify_bonds(hydrogen_atom, atom_list)) == 1) and (identify_bonds(hydrogen_atom, atom_list)[0][0].atom_number == oxygen_atom_2.atom_number)):\n placed = 888\n if atom in edge_map: edge_map.remove(atom)\n if atom in anywhere_map: anywhere_map.remove(atom)\n CY = Atom(atom.atom_number, 'CY', 'C1A', carbon_atom.residue_number, atom.x, atom.y, atom.z)\n atom_list.append(CY)\n atom_list.remove(atom)\n del atom\n else:\n placed += 5\n del hydrogen_atom\n del atom_list[current_size + 3]\n del oxygen_atom_2\n del atom_list[current_size + 2]\n del oxygen_atom_1\n del atom_list[current_size + 1]\n del carbon_atom\n del atom_list[current_size + 0]\n else:\n placed += 5\n del oxygen_atom_2\n del atom_list[current_size + 2]\n del oxygen_atom_1\n del atom_list[current_size + 1]\n del carbon_atom\n del atom_list[current_size + 0]\n else:\n placed += 5\n del oxygen_atom_1\n del atom_list[current_size + 1]\n del carbon_atom\n del atom_list[current_size + 0]\n else:\n placed += 5\n del carbon_atom \n del atom_list[current_size + 0]\n return atom_list","def create_rink():\n\n # RINK\n coords = OFFSET, OFFSET, OFFSET+22*SCALE, OFFSET+22*SCALE\n canvas.create_arc(coords, start=90, extent=90, fill=WHITE, outline=\"\")\n coords = OFFSET, HEIGHT-OFFSET-22*SCALE, OFFSET+22*SCALE, HEIGHT-OFFSET\n canvas.create_arc(coords, start=180, extent=90, fill=WHITE, outline=WHITE)\n coords = WIDTH-OFFSET-22*SCALE, HEIGHT-OFFSET-22*SCALE, WIDTH-OFFSET, HEIGHT-OFFSET\n canvas.create_arc(coords, start=270, extent=90, fill=WHITE, outline=WHITE)\n coords = WIDTH-OFFSET-22*SCALE, OFFSET, WIDTH-OFFSET, OFFSET+22*SCALE\n canvas.create_arc(coords, start=0, extent=90, fill=WHITE, outline=WHITE)\n coords = OFFSET+11*SCALE, OFFSET, WIDTH-OFFSET-11*SCALE, OFFSET, WIDTH-OFFSET-11*SCALE, HEIGHT-OFFSET, OFFSET+11*SCALE, HEIGHT-OFFSET\n canvas.create_polygon(coords, fill=WHITE, outline=WHITE)\n coords = OFFSET, OFFSET+11*SCALE, WIDTH-OFFSET, OFFSET+11*SCALE, WIDTH-OFFSET, HEIGHT-OFFSET-11*SCALE, OFFSET, HEIGHT-OFFSET-11*SCALE\n canvas.create_polygon(coords, fill=WHITE, outline=WHITE)\n\n # CENTER CIRCLE\n coords = WIDTH/2-15*SCALE, HEIGHT/2-15*SCALE, WIDTH/2+15*SCALE, HEIGHT/2+15*SCALE\n canvas.create_oval(coords, outline=BLUE, width=2, fill=WHITE)\n\n # HALF CENTER CIRCLE\n coords = WIDTH/2-10*SCALE, HEIGHT-OFFSET-10*SCALE, WIDTH/2+10*SCALE, HEIGHT-OFFSET+10*SCALE\n canvas.create_arc(coords, outline=RED, width=2, start=0, extent=180)\n\n # GOAL AREA\n # - Left\n # - - Crease\n coords = OFFSET+5*SCALE, HEIGHT/2-6*SCALE, OFFSET+17*SCALE, HEIGHT/2+6*SCALE\n canvas.create_arc(coords, fill=LIGHT_BLUE, start=318, extent=84, outline=\"\")\n canvas.create_arc(coords, outline=RED, start=318, extent=84, style=ARC)\n coords = OFFSET+11*SCALE, HEIGHT/2-4*SCALE, OFFSET+15.5*SCALE, HEIGHT/2-4*SCALE, OFFSET+15.5*SCALE, HEIGHT/2+4*SCALE, OFFSET+11*SCALE, HEIGHT/2+4*SCALE\n canvas.create_polygon(coords, fill=LIGHT_BLUE, outline=\"\")\n coords = OFFSET+11*SCALE, HEIGHT/2-4*SCALE, OFFSET+15.2*SCALE+1, HEIGHT/2-4*SCALE\n canvas.create_line(coords, fill=RED)\n coords = OFFSET+15.2*SCALE+1, HEIGHT/2+4*SCALE, OFFSET+11*SCALE, HEIGHT/2+4*SCALE\n canvas.create_line(coords, fill=RED)\n # - - Restricted Area\n coords = OFFSET, HEIGHT/2-14*SCALE, OFFSET+11*SCALE, HEIGHT/2-9*SCALE\n canvas.create_line(coords, fill=RED)\n coords = OFFSET, HEIGHT/2+14*SCALE, OFFSET+11*SCALE, HEIGHT/2+9*SCALE\n canvas.create_line(coords, fill=RED)\n # - - Goal\n coords = OFFSET+8*SCALE, HEIGHT/2-3*SCALE, OFFSET+11*SCALE, HEIGHT/2-3*SCALE, OFFSET+11*SCALE, HEIGHT/2+3*SCALE, OFFSET+8*SCALE, HEIGHT/2+3*SCALE\n canvas.create_polygon(coords, fill=GRAY, outline=RED)\n # - Right\n # - - Crease\n coords = WIDTH-(OFFSET+5*SCALE), HEIGHT/2-6*SCALE, WIDTH-(OFFSET+17*SCALE), HEIGHT/2+6*SCALE\n canvas.create_arc(coords, fill=LIGHT_BLUE, start=138, extent=84, outline=\"\")\n canvas.create_arc(coords, outline=RED, start=138, extent=84, style=ARC)\n coords = WIDTH-(OFFSET+11*SCALE), HEIGHT/2-4*SCALE, WIDTH-(OFFSET+15.5*SCALE), HEIGHT/2-4*SCALE, WIDTH-(OFFSET+15.5*SCALE), HEIGHT/2+4*SCALE, WIDTH-(OFFSET+11*SCALE), HEIGHT/2+4*SCALE\n canvas.create_polygon(coords, fill=LIGHT_BLUE, outline=\"\")\n coords = WIDTH-(OFFSET+11*SCALE), HEIGHT/2-4*SCALE, WIDTH-(OFFSET+15.2*SCALE+1), HEIGHT/2-4*SCALE\n canvas.create_line(coords, fill=RED)\n coords = WIDTH-(OFFSET+15.2*SCALE+1), HEIGHT/2+4*SCALE, WIDTH-(OFFSET+11*SCALE), HEIGHT/2+4*SCALE\n canvas.create_line(coords, fill=RED)\n # - - Restricted Area\n coords = WIDTH-OFFSET, HEIGHT/2-14*SCALE, WIDTH-OFFSET-11*SCALE, HEIGHT/2-9*SCALE\n canvas.create_line(coords, fill=RED)\n coords = WIDTH-OFFSET, HEIGHT/2+14*SCALE, WIDTH-OFFSET-11*SCALE, HEIGHT/2+9*SCALE\n canvas.create_line(coords, fill=RED)\n # - - Goal\n coords = WIDTH-(OFFSET+8*SCALE), HEIGHT/2-3*SCALE, WIDTH-(OFFSET+11*SCALE), HEIGHT/2-3*SCALE, WIDTH-(OFFSET+11*SCALE), HEIGHT/2+3*SCALE, WIDTH-(OFFSET+8*SCALE), HEIGHT/2+3*SCALE\n canvas.create_polygon(coords, fill=GRAY, outline=RED)\n\n # LINES\n # - Left Baseline\n coords = OFFSET+11*SCALE, OFFSET, OFFSET+11*SCALE, HEIGHT-OFFSET\n canvas.create_line(coords, fill=RED, width=1.5)\n # - Right Baseline\n coords = WIDTH-OFFSET-11*SCALE, OFFSET, WIDTH-OFFSET-11*SCALE, HEIGHT-OFFSET\n canvas.create_line(coords, fill=RED, width=1.5)\n # - Left Blueline\n coords = OFFSET+70*SCALE, OFFSET, OFFSET+70*SCALE, HEIGHT-OFFSET\n canvas.create_line(coords, fill=BLUE, width=7)\n # - Right Blueline\n coords = WIDTH-(OFFSET+70*SCALE), OFFSET, WIDTH-(OFFSET+70*SCALE), HEIGHT-OFFSET\n canvas.create_line(coords, fill=BLUE, width=7)\n # - Redline\n coords = WIDTH/2, OFFSET, WIDTH/2, HEIGHT-OFFSET\n canvas.create_line(coords, fill=RED, width=7)\n coords = WIDTH/2, OFFSET, WIDTH/2, HEIGHT-OFFSET\n canvas.create_line(coords, fill=WHITE, width=5, dash=(9,9))\n\n # RINK OUTLINE\n coords = OFFSET, OFFSET, OFFSET+22*SCALE, OFFSET+22*SCALE\n canvas.create_arc(coords, start=90, extent=90, outline=BLACK, style=ARC, width=2)\n coords = OFFSET, HEIGHT-OFFSET-22*SCALE, OFFSET+22*SCALE, HEIGHT-OFFSET\n canvas.create_arc(coords, start=180, extent=90, outline=BLACK, style=ARC, width=2)\n coords = WIDTH-OFFSET-22*SCALE, HEIGHT-OFFSET-22*SCALE, WIDTH-OFFSET, HEIGHT-OFFSET\n canvas.create_arc(coords, start=270, extent=90, outline=BLACK, style=ARC, width=2)\n coords = WIDTH-OFFSET-22*SCALE, OFFSET, WIDTH-OFFSET, OFFSET+22*SCALE\n canvas.create_arc(coords, start=0, extent=90, outline=BLACK, style=ARC, width=2)\n coords = OFFSET+11*SCALE, OFFSET, WIDTH-OFFSET-11*SCALE, OFFSET\n canvas.create_line(coords, fill=BLACK, width=2)\n coords = WIDTH-OFFSET, OFFSET+11*SCALE, WIDTH-OFFSET, HEIGHT-OFFSET-11*SCALE\n canvas.create_line(coords, fill=BLACK, width=2)\n coords = WIDTH-OFFSET-11*SCALE, HEIGHT-OFFSET, OFFSET+11*SCALE, HEIGHT-OFFSET\n canvas.create_line(coords, fill=BLACK, width=2)\n coords = OFFSET, OFFSET+11*SCALE, OFFSET, HEIGHT-OFFSET-11*SCALE\n canvas.create_line(coords, fill=BLACK, width=2)\n\n\n # CENTER DOT\n coords = WIDTH/2-1*SCALE-1, HEIGHT/2-1*SCALE-1, WIDTH/2+1*SCALE+1, HEIGHT/2+1*SCALE+1\n canvas.create_oval(coords, outline=WHITE, fill=BLUE)\n\n # FACEOFF\n # - Top Left\n # - - Ticks\n coords = OFFSET+29.5*SCALE, HEIGHT/2-39*SCALE, OFFSET+29.5*SCALE, HEIGHT/2-5*SCALE\n canvas.create_line(coords, fill=RED, width=2)\n coords = OFFSET+32.5*SCALE, HEIGHT/2-39*SCALE, OFFSET+32.5*SCALE, HEIGHT/2-5*SCALE\n canvas.create_line(coords, fill=RED, width=2)\n # - - Circles\n coords = OFFSET+16*SCALE, HEIGHT/2-37*SCALE, OFFSET+46*SCALE, HEIGHT/2-7*SCALE\n canvas.create_oval(coords, outline=RED, width=2, fill=WHITE)\n coords = OFFSET+30*SCALE, HEIGHT/2-23*SCALE, OFFSET+32*SCALE, HEIGHT/2-21*SCALE\n canvas.create_oval(coords, fill=RED, outline=\"\")\n # - - Cross\n coords = OFFSET+25*SCALE, HEIGHT/2-22.8*SCALE, OFFSET+29*SCALE, HEIGHT/2-22.8*SCALE, OFFSET+29*SCALE, HEIGHT/2-25.8*SCALE\n canvas.create_line(coords, fill=RED, width=2)\n coords = OFFSET+25*SCALE, HEIGHT/2-21.2*SCALE, OFFSET+29*SCALE, HEIGHT/2-21.2*SCALE, OFFSET+29*SCALE, HEIGHT/2-18.2*SCALE\n canvas.create_line(coords, fill=RED, width=2)\n coords = OFFSET+37*SCALE, HEIGHT/2-22.8*SCALE, OFFSET+33*SCALE, HEIGHT/2-22.8*SCALE, OFFSET+33*SCALE, HEIGHT/2-25.8*SCALE\n canvas.create_line(coords, fill=RED, width=2)\n coords = OFFSET+37*SCALE, HEIGHT/2-21.2*SCALE, OFFSET+33*SCALE, HEIGHT/2-21.2*SCALE, OFFSET+33*SCALE, HEIGHT/2-18.2*SCALE\n canvas.create_line(coords, fill=RED, width=2)\n # - Bottom Left\n # - - Ticks\n coords = OFFSET+29.5*SCALE, HEIGHT/2+39*SCALE, OFFSET+29.5*SCALE, HEIGHT/2+5*SCALE\n canvas.create_line(coords, fill=RED, width=2)\n coords = OFFSET+32.5*SCALE, HEIGHT/2+39*SCALE, OFFSET+32.5*SCALE, HEIGHT/2+5*SCALE\n canvas.create_line(coords, fill=RED, width=2)\n # - - Circles\n coords = OFFSET+16*SCALE, HEIGHT/2+37*SCALE, OFFSET+46*SCALE, HEIGHT/2+7*SCALE\n canvas.create_oval(coords, outline=RED, width=2, fill=WHITE)\n coords = OFFSET+30*SCALE, HEIGHT/2+23*SCALE, OFFSET+32*SCALE, HEIGHT/2+21*SCALE\n canvas.create_oval(coords, fill=RED, outline=\"\")\n # - - Cross\n coords = OFFSET+25*SCALE, HEIGHT/2+22.8*SCALE, OFFSET+29*SCALE, HEIGHT/2+22.8*SCALE, OFFSET+29*SCALE, HEIGHT/2+25.8*SCALE\n canvas.create_line(coords, fill=RED, width=2)\n coords = OFFSET+25*SCALE, HEIGHT/2+21.2*SCALE, OFFSET+29*SCALE, HEIGHT/2+21.2*SCALE, OFFSET+29*SCALE, HEIGHT/2+18.2*SCALE\n canvas.create_line(coords, fill=RED, width=2)\n coords = OFFSET+37*SCALE, HEIGHT/2+22.8*SCALE, OFFSET+33*SCALE, HEIGHT/2+22.8*SCALE, OFFSET+33*SCALE, HEIGHT/2+25.8*SCALE\n canvas.create_line(coords, fill=RED, width=2)\n coords = OFFSET+37*SCALE, HEIGHT/2+21.2*SCALE, OFFSET+33*SCALE, HEIGHT/2+21.2*SCALE, OFFSET+33*SCALE, HEIGHT/2+18.2*SCALE\n canvas.create_line(coords, fill=RED, width=2)\n # - Top Right\n # - - Ticks\n coords = WIDTH-(OFFSET+29.5*SCALE), HEIGHT/2-39*SCALE, WIDTH-(OFFSET+29.5*SCALE), HEIGHT/2-5*SCALE\n canvas.create_line(coords, fill=RED, width=2)\n coords = WIDTH-(OFFSET+32.5*SCALE), HEIGHT/2-39*SCALE, WIDTH-(OFFSET+32.5*SCALE), HEIGHT/2-5*SCALE\n canvas.create_line(coords, fill=RED, width=2)\n # - - Circles\n coords = WIDTH-(OFFSET+16*SCALE), HEIGHT/2-37*SCALE, WIDTH-(OFFSET+46*SCALE), HEIGHT/2-7*SCALE\n canvas.create_oval(coords, outline=RED, width=2, fill=WHITE)\n coords = WIDTH-(OFFSET+30*SCALE), HEIGHT/2-23*SCALE, WIDTH-(OFFSET+32*SCALE), HEIGHT/2-21*SCALE\n canvas.create_oval(coords, fill=RED, outline=\"\")\n # - - Cross\n coords = WIDTH-(OFFSET+25*SCALE), HEIGHT/2-22.8*SCALE, WIDTH-(OFFSET+29*SCALE), HEIGHT/2-22.8*SCALE, WIDTH-(OFFSET+29*SCALE), HEIGHT/2-25.8*SCALE\n canvas.create_line(coords, fill=RED, width=2)\n coords = WIDTH-(OFFSET+25*SCALE), HEIGHT/2-21.2*SCALE, WIDTH-(OFFSET+29*SCALE), HEIGHT/2-21.2*SCALE, WIDTH-(OFFSET+29*SCALE), HEIGHT/2-18.2*SCALE\n canvas.create_line(coords, fill=RED, width=2)\n coords = WIDTH-(OFFSET+37*SCALE), HEIGHT/2-22.8*SCALE, WIDTH-(OFFSET+33*SCALE), HEIGHT/2-22.8*SCALE, WIDTH-(OFFSET+33*SCALE), HEIGHT/2-25.8*SCALE\n canvas.create_line(coords, fill=RED, width=2)\n coords = WIDTH-(OFFSET+37*SCALE), HEIGHT/2-21.2*SCALE, WIDTH-(OFFSET+33*SCALE), HEIGHT/2-21.2*SCALE, WIDTH-(OFFSET+33*SCALE), HEIGHT/2-18.2*SCALE\n canvas.create_line(coords, fill=RED, width=2)\n # - Bottom Right\n # - - Ticks\n coords = WIDTH-(OFFSET+29.5*SCALE), HEIGHT/2+39*SCALE, WIDTH-(OFFSET+29.5*SCALE), HEIGHT/2+5*SCALE\n canvas.create_line(coords, fill=RED, width=2)\n coords = WIDTH-(OFFSET+32.5*SCALE), HEIGHT/2+39*SCALE, WIDTH-(OFFSET+32.5*SCALE), HEIGHT/2+5*SCALE\n canvas.create_line(coords, fill=RED, width=2)\n # - - Circles\n coords = WIDTH-(OFFSET+16*SCALE), HEIGHT/2+37*SCALE, WIDTH-(OFFSET+46*SCALE), HEIGHT/2+7*SCALE\n canvas.create_oval(coords, outline=RED, width=2, fill=WHITE)\n coords = WIDTH-(OFFSET+30*SCALE), HEIGHT/2+23*SCALE, WIDTH-(OFFSET+32*SCALE), HEIGHT/2+21*SCALE\n canvas.create_oval(coords, fill=RED, outline=\"\")\n # - - Cross\n coords = WIDTH-(OFFSET+25*SCALE), HEIGHT/2+22.8*SCALE, WIDTH-(OFFSET+29*SCALE), HEIGHT/2+22.8*SCALE, WIDTH-(OFFSET+29*SCALE), HEIGHT/2+25.8*SCALE\n canvas.create_line(coords, fill=RED, width=2)\n coords = WIDTH-(OFFSET+25*SCALE), HEIGHT/2+21.2*SCALE, WIDTH-(OFFSET+29*SCALE), HEIGHT/2+21.2*SCALE, WIDTH-(OFFSET+29*SCALE), HEIGHT/2+18.2*SCALE\n canvas.create_line(coords, fill=RED, width=2)\n coords = WIDTH-(OFFSET+37*SCALE), HEIGHT/2+22.8*SCALE, WIDTH-(OFFSET+33*SCALE), HEIGHT/2+22.8*SCALE, WIDTH-(OFFSET+33*SCALE), HEIGHT/2+25.8*SCALE\n canvas.create_line(coords, fill=RED, width=2)\n coords = WIDTH-(OFFSET+37*SCALE), HEIGHT/2+21.2*SCALE, WIDTH-(OFFSET+33*SCALE), HEIGHT/2+21.2*SCALE, WIDTH-(OFFSET+33*SCALE), HEIGHT/2+18.2*SCALE\n canvas.create_line(coords, fill=RED, width=2)\n\n # NEUTRAL ZONE FACEOFF\n # - Top Left\n coords = WIDTH/2-21*SCALE, HEIGHT/2-23*SCALE, WIDTH/2-19*SCALE, HEIGHT/2-21*SCALE\n canvas.create_oval(coords, outline=\"\", fill=RED)\n # - Bottom Left\n coords = WIDTH/2-21*SCALE, HEIGHT/2+23*SCALE, WIDTH/2-19*SCALE, HEIGHT/2+21*SCALE\n canvas.create_oval(coords, outline=\"\", fill=RED)\n # - Top Right\n coords = WIDTH/2+21*SCALE, HEIGHT/2-23*SCALE, WIDTH/2+19*SCALE, HEIGHT/2-21*SCALE\n canvas.create_oval(coords, outline=\"\", fill=RED)\n # - Bottom Right\n coords = WIDTH/2+21*SCALE, HEIGHT/2+23*SCALE, WIDTH/2+19*SCALE, HEIGHT/2+21*SCALE\n canvas.create_oval(coords, outline=\"\", fill=RED)\n\n\n canvas.grid(row=1, columnspan=5)","def check_circuit_pool(self):\r\n # Get current number of circuits\r\n n = len(self.circuits.values())\r\n i = self.num_circuits-n\r\n if i > 0:\r\n plog(\"INFO\", \"Checked pool of circuits: we need to build \" + \r\n str(i) + \" circuits\")\r\n # Schedule (num_circs-n) circuit-buildups\r\n while (n < self.num_circuits): \r\n # TODO: Should mimic Tor's learning here\r\n self.build_circuit(\"255.255.255.255\", 80) \r\n plog(\"DEBUG\", \"Scheduled circuit No. \" + str(n+1))\r\n n += 1","def remote_concentric_circles(circle_turtle,dis_range,radius):\r\n for i in range(dis_range):\r\n color = random.choice(dark_colors)\r\n circle_turtle.color(color)\r\n circle_turtle.circle(radius*i)\r\n circle_turtle.up()\r\n circle_turtle.sety((radius*i)*(-1))\r\n circle_turtle.down()\r\n\r\n circle_turtle.up()\r\n circle_turtle.goto(0,0)\r\n circle_turtle.down()","def central_composite(d,center=(2,2),alpha='o',face='ccc'):\n \n return build_central_composite(d,center=center,alpha=alpha,face=face)","def build_lens_icosahedron(kabamland, vtx, rad, diameter_ratio, thickness_ratio, half_EPD, blockers=True, blocker_thickness_ratio=1.0/1000, light_confinement=False, focal_length=1.0, lens_system_name=None):\n # Get the list of lens meshes from the appropriate lens system as well as the lens material'''\n scale_rad = rad*diameter_ratio #max_radius->rad of the lens assembly\n lenses = lenssystem.get_lens_mesh_list(lens_system_name, scale_rad)\n lensmat = lenssystem.get_lens_material(lens_system_name)\n face = None\n for lns in lenses:\n #lns = mh.rotate(lns,make_rotation_matrix(ph,ax))\n if not face:\n face = Solid(lns, lensmat, kabamland.detector_material)\n else:\n face += Solid(lns, lensmat, kabamland.detector_material)\n\n if light_confinement:\n shield = mh.rotate(cylindrical_shell(rad*(1 - 0.001), rad, focal_length,32), make_rotation_matrix(np.pi/2.0, (1,0,0)))\n baffle = Solid(shield, lensmat, kabamland.detector_material, black_surface, 0xff0000)\n\n if blockers:\n blocker_thickness = 2*rad*blocker_thickness_ratio\n if half_EPD < rad:\n c1 = lenssystem.get_lens_sys(lens_system_name).c1*lenssystem.get_scale_factor(lens_system_name,scale_rad)\n offset = [0,0,c1-np.sqrt(c1*c1-rad*rad)]\n anulus_blocker = mh.shift(mh.rotate(cylindrical_shell(half_EPD, rad, blocker_thickness, 32), make_rotation_matrix(np.pi/2.0, (1,0,0))),offset)\n face += Solid(anulus_blocker, lensmat, kabamland.detector_material, black_surface, 0xff0000)\n phi, axs = rot_axis([0,0,1],vtx)\n for vx,ph,ax in zip(vtx,-phi,axs):\n kabamland.add_solid(face, rotation=make_rotation_matrix(ph,ax), displacement = -vx)\n if light_confinement:\n kabamland.add_solid(baffle, rotation=make_rotation_matrix(ph,ax), displacement = -normalize(vx)*(np.linalg.norm(vx)+focal_length/2.0))","def test_comb(pad_size = (200, 200), wire_width = 1, wire_gap = 3,\n comb_layer = 0, overlap_zigzag_layer = 1,\n comb_pad_layer = 2, comb_gnd_layer = 3,\n overlap_pad_layer = 4):\n CI = Device(\"test_comb\")\n\n # if comb_pad_layer is None: comb_pad_layer = comb_layer\n # if comb_gnd_layer is None: comb_gnd_layer = comb_layer\n # if overlap_pad_layer is None: overlap_pad_layer = overlap_zigzag_layer\n wire_spacing = wire_width + wire_gap*2\n\n # pad overlays\n overlay_padb = CI.add_ref(rectangle(size = (pad_size[0]*9 / 10,\n pad_size[1]*9 / 10),\n layer = overlap_pad_layer))\n overlay_padl = CI.add_ref(rectangle(size = (pad_size[0]*9 / 10,\n pad_size[1]*9 / 10),\n layer = comb_pad_layer))\n overlay_padt = CI.add_ref(rectangle(size = (pad_size[0]*9 / 10,\n pad_size[1]*9 / 10),\n layer = comb_pad_layer))\n overlay_padr = CI.add_ref(rectangle(size = (pad_size[0]*9 / 10,\n pad_size[1]*9 / 10),\n layer = comb_gnd_layer))\n overlay_padl.xmin = 0\n overlay_padl.ymin = 0\n overlay_padb.ymax = 0\n overlay_padb.xmin = overlay_padl.xmax + pad_size[1]/5\n overlay_padr.ymin = overlay_padl.ymin\n overlay_padr.xmin = overlay_padb.xmax + pad_size[1]/5\n overlay_padt.xmin = overlay_padl.xmax + pad_size[1]/5\n overlay_padt.ymin = overlay_padl.ymax\n\n # pads\n padl = CI.add_ref(rectangle(size = pad_size, layer = comb_layer))\n padt = CI.add_ref(rectangle(size = pad_size, layer = comb_layer))\n padr = CI.add_ref(rectangle(size = pad_size, layer = comb_layer))\n padb = CI.add_ref(rectangle(size = pad_size, layer = overlap_zigzag_layer))\n padl_nub = CI.add_ref(rectangle(size = (pad_size[0]/4,\n pad_size[1]/2),\n layer = comb_layer))\n padr_nub = CI.add_ref(rectangle(size = (pad_size[0]/4,\n pad_size[1]/2),\n layer = comb_layer))\n padl.xmin = overlay_padl.xmin\n padl.center = [padl.center[0], overlay_padl.center[1]]\n padt.ymax = overlay_padt.ymax\n padt.center = [overlay_padt.center[0], padt.center[1]]\n padr.xmax = overlay_padr.xmax\n padr.center = [padr.center[0], overlay_padr.center[1]]\n padb.ymin = overlay_padb.ymin\n padb.center = [overlay_padb.center[0], padb.center[1]]\n padl_nub.xmin = padl.xmax\n padl_nub.center = [padl_nub.center[0], padl.center[1]]\n padr_nub.xmax = padr.xmin\n padr_nub.center = [padr_nub.center[0], padr.center[1]]\n\n # connected zig\n head = CI.add_ref(compass(size = (pad_size[0]/12, wire_width),\n layer = comb_layer))\n head.xmin = padl_nub.xmax\n head.ymax = padl_nub.ymax\n connector = CI.add_ref(compass(size = (wire_width, wire_width),\n layer = comb_layer))\n connector.connect(port = 'W', destination = head.ports['E'])\n old_port = connector.ports['S']\n top = True\n obj = connector\n while(obj.xmax + pad_size[0]/12 < padr_nub.xmin):\n # long zig zag rectangle\n obj = CI.add_ref(compass(size = (pad_size[1]/2 - 2*wire_width,\n wire_width),\n layer = comb_layer))\n obj.connect(port = 'W', destination = old_port)\n old_port = obj.ports['E']\n if(top):\n # zig zag edge rectangle\n obj = CI.add_ref(compass(size = (wire_width, wire_width),\n layer = comb_layer))\n obj.connect(port = 'N', destination = old_port)\n top = False\n else:\n # zig zag edge rectangle\n obj = CI.add_ref(compass(size = (wire_width, wire_width),\n layer = comb_layer))\n obj.connect(port = 'S', destination = old_port)\n top = True\n # comb rectange\n comb = CI.add_ref(rectangle(\n size = ((padt.ymin - head.ymax) + pad_size[1]/2 \\\n - (wire_spacing + wire_width)/2, wire_width),\n layer = comb_layer))\n comb.rotate(90)\n comb.ymax = padt.ymin\n comb.xmax = obj.xmax - (wire_spacing + wire_width)/2\n old_port = obj.ports['E']\n obj = CI.add_ref(compass(size = (wire_spacing, wire_width),\n layer = comb_layer))\n obj.connect(port = 'W', destination = old_port)\n old_port = obj.ports['E']\n obj = CI.add_ref(compass(size = (wire_width, wire_width),\n layer = comb_layer))\n obj.connect(port = 'W', destination = old_port)\n if(top): old_port = obj.ports['S']\n else: old_port = obj.ports['N']\n old_port = obj.ports['E']\n if(padr_nub.xmin-obj.xmax > 0):\n tail = CI.add_ref(compass(size = (padr_nub.xmin-obj.xmax, wire_width),\n layer = comb_layer))\n else:\n tail = CI.add_ref(compass(size = (wire_width, wire_width),\n layer = comb_layer))\n tail.connect(port = 'W', destination = old_port)\n\n # disconnected zig\n dhead = CI.add_ref(compass(size = (padr_nub.ymin - padb.ymax - wire_width,\n wire_width),\n layer = overlap_zigzag_layer))\n dhead.rotate(90)\n dhead.ymin = padb.ymax\n dhead.xmax = tail.xmin - (wire_spacing+wire_width)/2\n connector = CI.add_ref(compass(size = (wire_width, wire_width),\n layer = overlap_zigzag_layer))\n connector.connect(port = 'S', destination = dhead.ports['E'])\n old_port = connector.ports['N']\n right = True\n obj = connector\n while(obj.ymax + wire_spacing + wire_width < head.ymax):\n obj = CI.add_ref(compass(size = (wire_spacing, wire_width),\n layer = overlap_zigzag_layer))\n obj.connect(port = 'W', destination = old_port)\n old_port = obj.ports['E']\n if(right):\n obj = CI.add_ref(compass(size = (wire_width, wire_width),\n layer = overlap_zigzag_layer))\n obj.connect(port = 'W', destination = old_port)\n right = False\n else:\n obj = CI.add_ref(compass(size = (wire_width, wire_width),\n layer = overlap_zigzag_layer))\n obj.connect(port = 'E', destination = old_port)\n right = True\n old_port = obj.ports['N']\n obj = CI.add_ref(compass(\n size = (dhead.xmin - (head.xmax+head.xmin+wire_width)/2,\n wire_width),\n layer = overlap_zigzag_layer))\n obj.connect(port = 'E', destination = old_port)\n old_port = obj.ports['W']\n obj = CI.add_ref(compass(size = (wire_width, wire_width),\n layer = overlap_zigzag_layer))\n obj.connect(port = 'S', destination = old_port)\n if(right):\n old_port = obj.ports['W']\n else:\n old_port = obj.ports['E']\n\n return CI","def test_create_cwb(self):\n \"\"\"burst-cwb.txt\"\"\"\n time.sleep(SLEEP_TIME)\n eventFile = os.path.join(testdatadir, \"burst-cwb.txt\")\n r = gracedb.createEvent(\"Test\", \"CWB\", eventFile)\n self.assertEqual(r.status, 201) # CREATED\n cwb_event = r.json()\n self.assertEqual(cwb_event['group'], \"Test\")\n self.assertEqual(cwb_event['pipeline'], \"CWB\")\n self.assertEqual(float(cwb_event['gpstime']), 1042312876.5090)","def theaterChase(self, color, wait_ms=50, iterations=10):\n for j in range(iterations):\n for q in range(3):\n for i in range(0, self.LEDS, 3):\n self.ring.setPixelColor(i + q, color)\n self.ring.show()\n time.sleep(wait_ms / 1000.0)\n for i in range(0, self.LEDS, 3):\n self.ring.setPixelColor(i + q, 0)","def HollowCircle(self,center=(0,0),inner_radius=1.0,outer_radius=2.,element_type='tri',isotropic=True,nrad=5,ncirc=10):\n\n # FOR SAFETY, RESET THE CLASS\n self.__reset__()\n\n if np.allclose(inner_radius,0):\n raise ValueError('inner_radius cannot be zero')\n\n t = np.linspace(0,2*np.pi,ncirc+1)\n if isotropic is True:\n radii = np.linspace(inner_radius,outer_radius,nrad+1)\n else:\n base = 3\n radii = np.zeros(nrad+1,dtype=np.float64)\n mm = np.linspace(np.power(inner_radius,1./base),np.power(outer_radius,1./base),nrad+1)\n for i in range(0,nrad+1):\n radii[i] = mm[i]**base\n\n\n # base = 3\n # mm = np.linspace(np.power(inner_radius,1./base),np.power(2.,1./base),nrad+1)\n # mm = np.append(mm,np.linspace(2,outer_radius,nrad+1))\n # radii = np.zeros(mm.shape[0],dtype=np.float64)\n # for i in range(0,mm.shape[0]):\n # radii[i] = mm[i]**base\n\n\n # dd = np.logspace(inner_radius,outer_radius,nrad+1,base=2)/2**np.linspace(inner_radius,outer_radius,nrad+1)\n # print dd*np.linspace(inner_radius,outer_radius,nrad+1)\n # print np.logspace(0,1.5,nrad+1,base=2)\n\n\n xy = np.zeros((radii.shape[0]*t.shape[0],2),dtype=np.float64)\n for i in range(0,radii.shape[0]):\n xy[i*t.shape[0]:(i+1)*t.shape[0],0] = radii[i]*np.cos(t)\n xy[i*t.shape[0]:(i+1)*t.shape[0],1] = radii[i]*np.sin(t)\n\n\n # REMOVE DUPLICATES GENERATED BY SIN/COS OF LINSPACE\n xy = xy[np.setdiff1d( np.arange(xy.shape[0]) , np.linspace(t.shape[0]-1,xy.shape[0]-1,radii.shape[0]).astype(int) ),:]\n\n connec = np.zeros((1,4),dtype=np.int64)\n\n for j in range(1,radii.shape[0]):\n for i in range((j-1)*(t.shape[0]-1),j*(t.shape[0]-1)):\n if i<j*(t.shape[0]-1)-1:\n connec = np.concatenate((connec,np.array([[i,t.shape[0]-1+i,t.shape[0]+i,i+1 ]])),axis=0)\n # connec = connec + ((i,t.shape[0]-1+i,t.shape[0]+i,i+1),)\n else:\n connec = np.concatenate((connec,np.array([[i,t.shape[0]-1+i,j*(t.shape[0]-1),(j-1)*(t.shape[0]-1) ]])),axis=0)\n # connec = connec + ((i,t.shape[0]-1+i,j*(t.shape[0]-1),(j-1)*(t.shape[0]-1)),)\n\n connec = connec[1:,:]\n # connec = np.asarray(connec[1:])\n\n\n if element_type == 'tri':\n connec_tri = np.zeros((2*connec.shape[0],3),dtype=np.int64)\n for i in range(connec.shape[0]):\n connec_tri[2*i,:] = np.array([connec[i,0],connec[i,1],connec[i,3]])\n connec_tri[2*i+1,:] = np.array([connec[i,2],connec[i,3],connec[i,1]])\n\n self.elements = connec_tri\n self.nelem = self.elements.shape[0]\n self.element_type = element_type\n # OBTAIN MESH EDGES\n self.GetBoundaryEdgesTri()\n\n elif element_type == 'quad':\n self.elements = connec\n self.nelem = self.elements.shape[0]\n self.element_type = element_type\n self.GetBoundaryEdgesQuad()\n\n # ASSIGN NODAL COORDINATES\n self.points = xy\n # IF CENTER IS DIFFERENT FROM (0,0)\n self.points[:,0] += center[0]\n self.points[:,1] += center[1]\n # ASSIGN PROPERTIES\n self.nnode = self.points.shape[0]","def test_methylcyclohexane(self):\n def draw(image: ShapeImage):\n image.add_regular_hexagon(\n 100, start_coord=(400, 400)\n )\n image.add_line((487, 350), (487, 250))\n\n self._test_shape(\n image_size=(1000, 1000),\n expected_corners=np.array([\n [[400, 400]],\n [[487, 350]],\n [[574, 400]],\n [[574, 500]],\n [[487, 550]],\n [[400, 500]],\n # Methyl group\n [[487, 250]]\n ]),\n drawer=draw,\n expected_edges=np.array([\n [[400, 400, 487, 350]],\n [[487, 350, 574, 400]],\n [[574, 400, 574, 500]],\n [[574, 500, 487, 550]],\n [[487, 550, 400, 500]],\n [[400, 500, 400, 400]],\n # To methyl group\n [[487, 350, 487, 250]]\n ])\n )"],"string":"[\n \"def add_cable_ring(self, env, info={}, cable_idx=0):\\n def rad_to_deg(rad):\\n return (rad * 180.0) / np.pi\\n\\n def get_discretized_rotations(num_rotations):\\n # counter-clockwise\\n theta = i * (2 * np.pi) / num_rotations\\n return (theta, rad_to_deg(theta))\\n\\n # Bead properties.\\n num_parts = self.num_parts\\n radius = self.radius\\n color = self.colors[cable_idx] + [1]\\n\\n # The `ring_radius` (not the bead radius!) has to be tuned somewhat.\\n # Try to make sure the beads don't have notable gaps between them.\\n ring_radius = info['ring_radius']\\n beads = []\\n bead_positions_l = []\\n\\n # Add beaded cable. Here, `position` is the circle center.\\n position = np.float32(info['center_position'])\\n part_shape = p.createCollisionShape(p.GEOM_BOX, halfExtents=[radius]*3)\\n part_visual = p.createVisualShape(p.GEOM_SPHERE, radius=radius*1.5)\\n\\n # Iterate through parts and create constraints as needed.\\n for i in range(num_parts):\\n angle_rad, _ = get_discretized_rotations(num_parts)\\n px = ring_radius * np.cos(angle_rad)\\n py = ring_radius * np.sin(angle_rad)\\n #print(f'pos: {px:0.2f}, {py:0.2f}, angle: {angle_rad:0.2f}, {angle_deg:0.1f}')\\n bead_position = np.float32([position[0] + px, position[1] + py, 0.01])\\n part_id = p.createMultiBody(0.1, part_shape, part_visual,\\n basePosition=bead_position)\\n p.changeVisualShape(part_id, -1, rgbaColor=color)\\n\\n if i > 0:\\n parent_frame = bead_position - bead_positions_l[-1]\\n constraint_id = p.createConstraint(\\n parentBodyUniqueId=beads[-1],\\n parentLinkIndex=-1,\\n childBodyUniqueId=part_id,\\n childLinkIndex=-1,\\n jointType=p.JOINT_POINT2POINT,\\n jointAxis=(0, 0, 0),\\n parentFramePosition=parent_frame,\\n childFramePosition=(0, 0, 0))\\n p.changeConstraint(constraint_id, maxForce=100)\\n\\n # Make a constraint with i=0. Careful with `parent_frame`!\\n if i == num_parts - 1:\\n parent_frame = bead_positions_l[0] - bead_position\\n constraint_id = p.createConstraint(\\n parentBodyUniqueId=part_id,\\n parentLinkIndex=-1,\\n childBodyUniqueId=beads[0],\\n childLinkIndex=-1,\\n jointType=p.JOINT_POINT2POINT,\\n jointAxis=(0, 0, 0),\\n parentFramePosition=parent_frame,\\n childFramePosition=(0, 0, 0))\\n p.changeConstraint(constraint_id, maxForce=100)\\n\\n # Track beads.\\n beads.append(part_id)\\n bead_positions_l.append(bead_position)\\n\\n # The usual for tracking IDs. Four things to add.\\n self.cable_bead_IDs.append(part_id)\\n self._IDs[part_id] = f'cable_part_{str(part_id).zfill(2)}'\\n env.objects.append(part_id)\\n self.object_points[part_id] = np.float32((0, 0, 0)).reshape(3, 1)\\n\\n if 'cable-ring' in self._name:\\n # For targets, we can assume the starting position gives us\\n # that. Later, apply a random force on the ring to perturb it.\\n true_position = (bead_position[0], bead_position[1], 0)\\n self.goal['places'][part_id] = (true_position, (0, 0, 0, 1.))\\n symmetry = 0\\n self.goal['steps'][0][part_id] = (symmetry, [part_id])\\n\\n # Make the true positions visible if desired.\\n if info['targets_visible']:\\n sq_pose = ((true_position[0], true_position[1], 0.002), (0,0,0,1))\\n sq_template = 'assets/square/square-template-allsides-green.urdf'\\n replace = {'DIM': (0.003,), 'HALF': (0.003 / 2,)}\\n urdf = self.fill_template(sq_template, replace)\\n env.add_object(urdf, sq_pose, fixed=True)\\n os.remove(urdf)\\n else:\\n print(f'Warning, env {self._name} will not have goals.')\",\n \"def make_circle_fill():\\n num_points = 40\\n batch = pyglet.graphics.Batch()\\n rad = math.pi * 2 / num_points # getting 360 / n in radians\\n index = list(itertools.chain.from_iterable( (0, x-1, x) for x in range(2, num_points+1) ))\\n index += [0, 1, num_points] # end of fan\\n vertices = [0, 0] # adding center of fan\\n for i in range(1, num_points + 1):\\n angle = rad * i\\n vertices += [math.cos(angle), math.sin(angle)]\\n vertices += [1, 0] # adding end of fan\\n circle = pyglet.graphics.vertex_list_indexed(num_points+2, index, ('v2f', vertices))\\n return circle\",\n \"def build_glyCB(self, gCBd: Dihedron): # -> None:\\n ...\",\n \"def add_cable(self, env, size_range, info={}, cable_idx=0,\\n direction='z', max_force=100):\\n num_parts = self.num_parts\\n radius = self.radius\\n length = self.length\\n color = self.colors[cable_idx] + [1]\\n color_end = U.COLORS['yellow'] + [1]\\n\\n # Add beaded cable.\\n distance = length / num_parts\\n position, _ = self.random_pose(env, size_range)\\n position = np.float32(position)\\n part_shape = p.createCollisionShape(p.GEOM_BOX, halfExtents=[radius]*3)\\n part_visual = p.createVisualShape(p.GEOM_SPHERE, radius=radius*1.5)\\n\\n # Iterate through parts and create constraints as needed.\\n for i in range(num_parts):\\n if direction == 'x':\\n position[0] += distance\\n parent_frame = (distance, 0, 0)\\n elif direction == 'y':\\n position[1] += distance\\n parent_frame = (0, distance, 0)\\n else:\\n position[2] += distance\\n parent_frame = (0, 0, distance)\\n\\n part_id = p.createMultiBody(0.1, part_shape, part_visual,\\n basePosition=position)\\n if i > 0:\\n constraint_id = p.createConstraint(\\n parentBodyUniqueId=env.objects[-1],\\n parentLinkIndex=-1,\\n childBodyUniqueId=part_id,\\n childLinkIndex=-1,\\n jointType=p.JOINT_POINT2POINT,\\n jointAxis=(0, 0, 0),\\n parentFramePosition=parent_frame,\\n childFramePosition=(0, 0, 0))\\n p.changeConstraint(constraint_id, maxForce=max_force)\\n\\n if (i > 0) and (i < num_parts - 1):\\n p.changeVisualShape(part_id, -1, rgbaColor=color)\\n elif i == num_parts - 1:\\n p.changeVisualShape(part_id, -1, rgbaColor=color_end)\\n\\n # The usual for tracking IDs. Four things to add.\\n self.cable_bead_IDs.append(part_id)\\n self._IDs[part_id] = f'cable_part_{str(part_id).zfill(2)}'\\n env.objects.append(part_id)\\n self.object_points[part_id] = np.float32((0, 0, 0)).reshape(3, 1)\\n\\n # Get target placing positions for each cable bead, if applicable.\\n if self._name == 'cable-shape' or self._name == 'cable-shape-notarget' or \\\\\\n self._name == 'cable-line-notarget':\\n # ----------------------------------------------------------- #\\n # Here, zone_pose = square_pose, unlike Ravens cable, where the\\n # zone_pose is shifted so that its center matches the straight\\n # line segment center. For `true_position`, we use `zone_pose`\\n # but apply the correct offset to deal with the sides. Note\\n # that `length` is the size of a fully smoothed cable, BUT we\\n # made a rectangle with each side <= length.\\n # ----------------------------------------------------------- #\\n lx = info['lengthx']\\n ly = info['lengthy']\\n r = radius\\n\\n if info['nb_sides'] == 1:\\n # Here it's just a straight line on the 'lx' side.\\n x_coord = lx / 2 - (distance * i)\\n y_coord = 0\\n true_position = (x_coord - r, y_coord, 0)\\n\\n elif info['nb_sides'] == 2:\\n # Start from lx side, go 'left' to the pivot point, then on\\n # the ly side, go 'upwards' but offset by `i`. For radius\\n # offset, I just got this by tuning. XD\\n if i < info['cutoff']:\\n x_coord = lx / 2 - (distance * i)\\n y_coord = -ly / 2\\n true_position = (x_coord - r, y_coord, 0)\\n else:\\n x_coord = -lx / 2\\n y_coord = -ly / 2 + (distance * (i - info['cutoff']))\\n true_position = (x_coord, y_coord + r, 0)\\n\\n elif info['nb_sides'] == 3:\\n # Start from positive lx, positive ly, go down to first\\n # pivot. Then go left to the second pivot, then up again.\\n # For v1, division by two is because we assume BOTH of the\\n # 'ly edges' were divided by two.\\n v1 = (self.num_parts - info['cutoff']) / 2\\n v2 = self.num_parts - v1\\n if i < v1:\\n x_coord = lx / 2\\n y_coord = ly / 2 - (distance * i)\\n true_position = (x_coord, y_coord - r, 0)\\n elif i < v2:\\n x_coord = lx / 2 - (distance * (i - v1))\\n y_coord = -ly / 2\\n true_position = (x_coord - r, y_coord, 0)\\n else:\\n x_coord = -lx / 2\\n y_coord = -ly / 2 + (distance * (i - v2))\\n true_position = (x_coord, y_coord + r, 0)\\n\\n elif info['nb_sides'] == 4:\\n # I think this is similar to the 2-side case: we start in\\n # the same direction and go counter-clockwise.\\n v1 = info['cutoff'] / 2\\n v2 = num_parts / 2\\n v3 = (num_parts + info['cutoff']) / 2\\n if i < v1:\\n x_coord = lx / 2 - (distance * i)\\n y_coord = -ly / 2\\n true_position = (x_coord, y_coord, 0)\\n elif i < v2:\\n x_coord = -lx / 2\\n y_coord = -ly / 2 + (distance * (i - v1))\\n true_position = (x_coord, y_coord, 0)\\n elif i < v3:\\n x_coord = -lx / 2 + (distance * (i - v2))\\n y_coord = ly / 2\\n true_position = (x_coord, y_coord, 0)\\n else:\\n x_coord = lx / 2\\n y_coord = ly / 2 - (distance * (i - v3))\\n true_position = (x_coord, y_coord, 0)\\n\\n # Map true_position onto the workspace from zone_pose.\\n true_position = self.apply(self.zone_pose, true_position)\\n\\n # See `cable.py`: just get the places and steps set.\\n self.goal['places'][part_id] = (true_position, (0, 0, 0, 1.))\\n symmetry = 0\\n self.goal['steps'][0][part_id] = (symmetry, [part_id])\\n\\n # Debugging target zones.\\n if self.target_debug_markers:\\n sq_pose = ((true_position[0], true_position[1], 0.002), (0,0,0,1))\\n sq_template = 'assets/square/square-template-allsides-blue.urdf'\\n replace = {'DIM': (0.003,), 'HALF': (0.003 / 2,)}\\n urdf = self.fill_template(sq_template, replace)\\n env.add_object(urdf, sq_pose, fixed=True)\\n os.remove(urdf)\\n else:\\n print(f'Warning, env {self._name} will not have goals.')\",\n \"def bolthole(location, diameter, clamp_length, nuthole_size, nuthole_depth):\\n bolthole = (\\n cq.Workplane()\\n .bolt(\\n bolt_size = diameter,\\n head_size = 2 * diameter,\\n head_length = 2 * diameter,\\n head_shape = \\\"cylindrical\\\", \\n head_angle = 90,\\n clamp_length = clamp_length,\\n nut_size = nuthole_size,\\n nut_length = nuthole_depth\\n )\\n .val()\\n .located(location * cq.Location(cq.Vector(0, 0, - clamp_length / 2)))\\n )\\n # show_object(bolthole) # Debug helper.\\n return bolthole\",\n \"def C(width = 1, size = (10, 20), layer = 0):\\n D = Device(name = 'C')\\n w = width/2\\n s1, s2 = size\\n points = [(-w, -w), (s1, -w), (s1, w), (w, w), (w, s2-w),\\n (s1, s2-w), (s1, s2+w), (-w, s2+w), (-w, -w)]\\n D.add_polygon(points, layer = layer)\\n D.add_port(name = 1, midpoint = (s1, s2), width = width, orientation = 0)\\n D.add_port(name = 2, midpoint = (s1, 0), width = width, orientation = 0)\\n return D\",\n \"def __bcc_left_diagonals(self) -> cq.cq.Workplane:\\n # In a cuboid ABCDA1B1C1D1 this is the angle C1AD\\n #angle_C1AD = 90 - degrees(acos(2**-.5))\\n angle_C1AD = 90 - degrees(acos(0.5))\\n angle_CAD = 90 - degrees(acos(sqrt(2/3)))\\n pseudo_unit_cell_size = sqrt(2/3)*self.unit_cell_size\\n corner_points = np.array(\\n [(0, 0),\\n (self.bcc_unit_cell_size, 0),\\n (self.bcc_unit_cell_size, self.unit_cell_size),\\n (0, self.unit_cell_size)]\\n )\\n result = (\\n cq.Workplane(\\\"XY\\\")\\n .pushPoints(corner_points)\\n .eachpointAdaptive(\\n create_bcc_diagonal_strut,\\n callback_extra_args = [\\n {\\\"unit_cell_size\\\": pseudo_unit_cell_size,\\n \\\"radius\\\": self.strut_radius,\\n \\\"angle_x\\\": - angle_CAD,\\n \\\"angle_y\\\": angle_C1AD},\\n {\\\"unit_cell_size\\\": 0.5 * pseudo_unit_cell_size,\\n \\\"radius\\\": self.strut_radius,\\n \\\"angle_x\\\": - angle_CAD,\\n \\\"angle_y\\\": - angle_C1AD},\\n {\\\"unit_cell_size\\\": 0.5 * pseudo_unit_cell_size,\\n \\\"radius\\\": self.strut_radius,\\n \\\"angle_x\\\": angle_CAD,\\n \\\"angle_y\\\": - angle_C1AD},\\n {\\\"unit_cell_size\\\": pseudo_unit_cell_size,\\n \\\"radius\\\": self.strut_radius,\\n \\\"angle_x\\\": angle_CAD,\\n \\\"angle_y\\\": angle_C1AD}\\n ],\\n useLocalCoords = True\\n )\\n )\\n return result\",\n \"def HollowCylinder(self,center=(0,0,0),inner_radius=1.0,outer_radius=2.,\\n element_type='hex',isotropic=True,nrad=5,ncirc=10, nlong=20,length=10):\\n\\n if element_type != \\\"hex\\\":\\n raise NotImplementedError('Generating {} mesh of cylinder is not supported yet'.format(element_type))\\n\\n if not isinstance(center,tuple):\\n raise ValueError(\\\"The center for the base of the cylinder should be given in a tuple with three elements (x,y,z)\\\")\\n\\n self.__reset__()\\n\\n nlong = int(nlong)\\n if nlong==0:\\n nlong = 1\\n\\n mesh = Mesh()\\n mesh.HollowCircle(center=(center[0],center[1]), inner_radius=inner_radius,\\n outer_radius=outer_radius, element_type=\\\"quad\\\",\\n isotropic=isotropic, nrad=nrad, ncirc=ncirc)\\n\\n self.Extrude(base_mesh=mesh, length=length, nlong=nlong)\\n self.points += center[2]\",\n \"def createCone( basePoint=(0,-1,0), tipPoint=(0,1,0), radius = 1.0, colour=(0.6,0.6,0.6), samples = 20 ):\\r\\n \\r\\n basePoint = PyUtils.toPoint3d(basePoint)\\r\\n tipPoint = PyUtils.toPoint3d(tipPoint)\\r\\n baseToTipVector = Vector3d(basePoint,tipPoint)\\r\\n if baseToTipVector.isZeroVector() :\\r\\n raise ValueError( 'Invalid points for cylinder: base and tip are equal!' )\\r\\n baseToTipUnitVector = baseToTipVector.unit()\\r\\n xUnitVector = baseToTipUnitVector.crossProductWith( Vector3d(0,0,1) )\\r\\n if xUnitVector.length() < 0.5 :\\r\\n xUnitVector = baseToTipUnitVector.crossProductWith( Vector3d(0,-1,0) )\\r\\n xUnitVector.toUnit()\\r\\n yUnitVector = baseToTipUnitVector.crossProductWith( Vector3d(-1,0,0) )\\r\\n if yUnitVector.length() < 0.5 :\\r\\n yUnitVector = baseToTipUnitVector.crossProductWith( Vector3d(0,1,0) )\\r\\n yUnitVector.toUnit()\\r\\n\\r\\n vertices = []\\r\\n for i in range(samples):\\r\\n theta = i * 2 * math.pi / float(samples)\\r\\n vertices.append( basePoint + xUnitVector * math.cos(theta) * radius + yUnitVector * math.sin(theta) * radius )\\r\\n for i in range(samples):\\r\\n theta = i * 2 * math.pi / float(samples)\\r\\n vertices.append( basePoint + xUnitVector * math.cos(theta) * radius + yUnitVector * math.sin(theta) * radius )\\r\\n vertices.append( tipPoint )\\r\\n \\r\\n faces = [ range(0,samples) ]\\r\\n for i in range(0,samples) :\\r\\n base = samples\\r\\n size = samples\\r\\n faces.append( (base+i, base+(i+1)%size, 2*samples ) )\\r\\n \\r\\n return create( vertices, faces, colour )\",\n \"def __bcc_diagonals(self) -> cq.cq.Workplane:\\n # In a cuboid ABCDA1B1C1D1 this is the angle C1AD\\n #angle_C1AD = 90 - degrees(acos(2**-.5))\\n angle_C1AD = 90 - degrees(acos(0.5))\\n angle_CAD = 90 - degrees(acos(sqrt(2/3)))\\n pseudo_unit_cell_size = sqrt(2/3)*self.unit_cell_size\\n corner_points = np.array(\\n [(0, 0),\\n (self.bcc_unit_cell_size, 0),\\n (self.bcc_unit_cell_size, self.unit_cell_size),\\n (0, self.unit_cell_size)]\\n )\\n result = (\\n cq.Workplane(\\\"XY\\\")\\n .pushPoints(corner_points)\\n .eachpointAdaptive(\\n create_bcc_diagonal_strut,\\n callback_extra_args = [\\n {\\\"unit_cell_size\\\": pseudo_unit_cell_size,\\n \\\"radius\\\": self.strut_radius,\\n \\\"angle_x\\\": - angle_CAD,\\n \\\"angle_y\\\": angle_C1AD},\\n {\\\"unit_cell_size\\\": pseudo_unit_cell_size,\\n \\\"radius\\\": self.strut_radius,\\n \\\"angle_x\\\": - angle_CAD,\\n \\\"angle_y\\\": - angle_C1AD},\\n {\\\"unit_cell_size\\\": pseudo_unit_cell_size,\\n \\\"radius\\\": self.strut_radius,\\n \\\"angle_x\\\": angle_CAD,\\n \\\"angle_y\\\": - angle_C1AD},\\n {\\\"unit_cell_size\\\": pseudo_unit_cell_size,\\n \\\"radius\\\": self.strut_radius,\\n \\\"angle_x\\\": angle_CAD,\\n \\\"angle_y\\\": angle_C1AD}\\n ],\\n useLocalCoords = True\\n )\\n )\\n return result\",\n \"def grating_coupler_circular(\\n taper_angle: float = 30.0,\\n taper_length: float = 10.0,\\n length: float = 30.0,\\n period: float = 1.0,\\n fill_factor: float = 0.7,\\n n_periods: int = 30,\\n bias_gap: float = 0,\\n port: Coordinate = (0.0, 0.0),\\n layer_slab: Optional[LayerSpec] = None,\\n layer_cladding: LayerSpec = \\\"WGCLAD\\\",\\n gaps: Optional[Floats] = None,\\n widths: Optional[Floats] = None,\\n direction: str = \\\"EAST\\\",\\n polarization: str = \\\"te\\\",\\n wavelength: float = 1.55,\\n fiber_marker_width: float = 11.0,\\n fiber_marker_layer: Optional[LayerSpec] = \\\"TE\\\",\\n cladding_offset: float = 2.0,\\n cross_section: CrossSectionSpec = \\\"strip\\\",\\n **kwargs,\\n) -> Component:\\n x = gf.get_cross_section(cross_section, **kwargs)\\n layer = x.layer\\n wg_width = x.width\\n\\n widths = widths or n_periods * [period * fill_factor]\\n gaps = gaps or n_periods * [period * (1 - fill_factor)]\\n\\n gaps = np.array(gaps) + bias_gap\\n widths = np.array(widths) - bias_gap\\n teeth_list = list(zip(gaps, widths))\\n\\n layer = gf.get_layer(layer)\\n layer_slab = gf.get_layer(layer_slab)\\n layer_cladding = gf.get_layer(layer_cladding)\\n\\n c = pc.GratingCoupler(\\n gf.call_if_func(\\n strip,\\n cladding_offset=cladding_offset,\\n wg_width=wg_width,\\n layer=layer,\\n layer_cladding=layer_cladding,\\n ),\\n theta=np.deg2rad(taper_angle),\\n length=length,\\n taper_length=taper_length,\\n period=period,\\n dutycycle=fill_factor,\\n ridge=bool(layer_slab),\\n ridge_layers=layer_slab,\\n teeth_list=teeth_list,\\n port=port,\\n direction=direction,\\n )\\n\\n c = gf.read.from_picwriter(c)\\n c.info[\\\"polarization\\\"] = polarization\\n c.info[\\\"wavelength\\\"] = wavelength\\n c.ports[\\\"o1\\\"].cross_section = x\\n\\n fiber_xoffset = np.round(c.center[0] + taper_length / 2, 3)\\n\\n if fiber_marker_layer:\\n circle = gf.components.circle(\\n radius=fiber_marker_width / 2, layer=fiber_marker_layer\\n )\\n circle_ref = c.add_ref(circle)\\n circle_ref.movex(fiber_xoffset)\\n\\n c.add_port(\\n name=f\\\"vertical_{polarization.lower()}\\\",\\n center=[fiber_xoffset, 0],\\n width=fiber_marker_width,\\n orientation=0,\\n layer=fiber_marker_layer,\\n )\\n if x.add_bbox:\\n c = x.add_bbox(c)\\n if x.add_pins:\\n c = x.add_pins(c)\\n return c\",\n \"def Cool_per_Grain(grain_size, grain_type, ZZ, fdist, ntot, xe, temp):\\n import numpy as np\\n import math\\n import compute_charge_dist as fz\\n \\n tau = grain_size * fz.AAtocm * fz.kb * temp / fz.echarge**2\\n \\n # Loop over species!\\n Cool_spec = 0\\n for partner in [\\\"electron\\\", \\\"hydrogen\\\", \\\"carbon\\\"]:\\n \\n Cool_Zall = 0\\n # Loop over charge\\n for zi in range(len(ZZ)):\\n \\n if partner == \\\"electron\\\":\\n nu = -1*ZZ[zi]\\n stick_coef = fz.get_stickCoef(ZZ[zi], grain_size, grain_type)\\n charge_frac = xe\\n mass = fz.me\\n \\n elif partner == \\\"hydrogen\\\":\\n nu = ZZ[zi]\\n stick_coef = 1.0\\n charge_frac = xe\\n mass = fz.mH\\n \\n elif partner == \\\"carbon\\\":\\n nu = ZZ[zi]\\n stick_coef = 1.0\\n # Maximum fraction of ionized Carbon is 1e-4*ntot.\\n charge_frac = min(1.0e-4, xe)\\n mass = fz.mC\\n \\n Cooltilde = 1.0\\n \\n if nu < 0:\\n Cooltilde = fz.Jtilde_neg(tau, nu)\\n elif nu == 0:\\n Cooltilde = fz.Jtilde_0(tau, nu)\\n else:\\n Cooltilde = fz.Jtilde_pos(tau, nu)\\n \\n #print(zi)\\n Cool_Zhere = fdist[zi]*Cooltilde*fz.kb*temp\\n Cool_Zall += Cool_Zhere\\n \\n #print(\\\"Collisional Partner = \\\", partner)\\n Cool_spec += ntot*charge_frac*stick_coef*np.sqrt(8.0*fz.kb*temp/(np.pi*mass))*Cool_Zall\\n \\n Cool_tot = math.pi * (grain_size*AAtocm)**2 * Cool_spec\\n \\n return Cool_tot\",\n \"def _createCadence(self, harmonicRhythm):\\n random = RandomManager.getActive()\\n\\n # choose cadence to apply\\n cadences = self.chordProfile.getCadences()\\n\\n #TODO: Choose cadence in more intelligent way\\n cadence = random.choice(cadences)\\n\\n scale = self.chordProfile.getScale().getName()\\n cadenceChordProgression = []\\n\\n reversedHarmonicRhythm = reversed(harmonicRhythm[:])\\n # create as many cadence\\n for count, durationObj in enumerate(reversedHarmonicRhythm):\\n duration = durationObj.getDuration()\\n code = cadence[-count+1]\\n chord = Chord(code, duration=duration, scale=scale, octave=4)\\n\\n if count >= len(cadence):\\n return cadenceChordProgression\\n\\n # prepend chord\\n cadenceChordProgression.insert(0, chord)\\n return cadenceChordProgression\",\n \"def createCylinder( basePoint=(0,-1,0), tipPoint=(0,1,0), radius = 1.0, colour=(0.6,0.6,0.6), samples = 20 ):\\r\\n \\r\\n basePoint = PyUtils.toPoint3d(basePoint)\\r\\n tipPoint = PyUtils.toPoint3d(tipPoint)\\r\\n baseToTipVector = Vector3d(basePoint,tipPoint)\\r\\n if baseToTipVector.isZeroVector() :\\r\\n raise ValueError( 'Invalid points for cylinder: base and tip are equal!' )\\r\\n baseToTipUnitVector = baseToTipVector.unit()\\r\\n xUnitVector = baseToTipUnitVector.crossProductWith( Vector3d(0,0,1) )\\r\\n if xUnitVector.length() < 0.5 :\\r\\n xUnitVector = baseToTipUnitVector.crossProductWith( Vector3d(0,-1,0) )\\r\\n xUnitVector.toUnit()\\r\\n yUnitVector = baseToTipUnitVector.crossProductWith( Vector3d(-1,0,0) )\\r\\n if yUnitVector.length() < 0.5 :\\r\\n yUnitVector = baseToTipUnitVector.crossProductWith( Vector3d(0,1,0) )\\r\\n yUnitVector.toUnit()\\r\\n\\r\\n vertices = []\\r\\n for i in range(samples):\\r\\n theta = i * 2 * math.pi / float(samples)\\r\\n vertices.append( basePoint + xUnitVector * math.cos(theta) * radius + yUnitVector * math.sin(theta) * radius )\\r\\n for i in range(samples):\\r\\n theta = i * 2 * math.pi / float(samples)\\r\\n vertices.append( tipPoint + xUnitVector * math.cos(theta) * radius + yUnitVector * math.sin(theta) * radius )\\r\\n for i in range(samples):\\r\\n theta = i * 2 * math.pi / float(samples)\\r\\n vertices.append( basePoint + xUnitVector * math.cos(theta) * radius + yUnitVector * math.sin(theta) * radius )\\r\\n vertices.append( tipPoint + xUnitVector * math.cos(theta) * radius + yUnitVector * math.sin(theta) * radius )\\r\\n \\r\\n faces = [ range(0,samples), range(samples,2*samples) ]\\r\\n for i in range(0,2*samples,2) :\\r\\n base = 2*samples\\r\\n size = 2*samples\\r\\n faces.append( (base+i, base+i+1, base+(i+3)%size, base+(i+2)%size ) )\\r\\n \\r\\n return create( vertices, faces, colour )\",\n \"def __bcc_top_diagonals(self) -> cq.cq.Workplane:\\n # In a cuboid ABCDA1B1C1D1 this is the angle C1AD\\n #angle_C1AD = 90 - degrees(acos(2**-.5))\\n angle_C1AD = 90 - degrees(acos(0.5))\\n angle_CAD = 90 - degrees(acos(sqrt(2/3)))\\n pseudo_unit_cell_size = sqrt(2/3)*self.unit_cell_size\\n corner_points = np.array(\\n [(0, 0),\\n (self.bcc_unit_cell_size, 0),\\n (self.bcc_unit_cell_size, self.unit_cell_size),\\n (0, self.unit_cell_size)]\\n )\\n result = (\\n cq.Workplane(\\\"XY\\\")\\n .pushPoints(corner_points)\\n .eachpointAdaptive(\\n create_bcc_diagonal_strut,\\n callback_extra_args = [\\n {\\\"unit_cell_size\\\": 0.5 * pseudo_unit_cell_size,\\n \\\"radius\\\": self.strut_radius,\\n \\\"angle_x\\\": - angle_CAD,\\n \\\"angle_y\\\": angle_C1AD},\\n {\\\"unit_cell_size\\\": pseudo_unit_cell_size,\\n \\\"radius\\\": self.strut_radius,\\n \\\"angle_x\\\": - angle_CAD,\\n \\\"angle_y\\\": - angle_C1AD},\\n {\\\"unit_cell_size\\\": pseudo_unit_cell_size,\\n \\\"radius\\\": self.strut_radius,\\n \\\"angle_x\\\": angle_CAD,\\n \\\"angle_y\\\": - angle_C1AD},\\n {\\\"unit_cell_size\\\": 0.5 * pseudo_unit_cell_size,\\n \\\"radius\\\": self.strut_radius,\\n \\\"angle_x\\\": angle_CAD,\\n \\\"angle_y\\\": angle_C1AD}\\n ],\\n useLocalCoords = True\\n )\\n )\\n return result\",\n \"def test_drawSolid(self):\\n\\n image_name = filename(sys._getframe().f_code.co_name)\\n result_file, reference_file = get_path(image_name)\\n\\n ''' This function is to create an empty image with a specific dimension\\n with white background, and black/white colored '''\\n\\n image, canvas = get_image('RGB', (640, 480), 'white')\\n\\n '''\\n for different representations of colors see\\n \\\"https://pillow.readthedocs.io/en/3.0.x/reference/ImageColor.html#color-names\\\"\\n '''\\n drawSolid(canvas, regularPolygon(3, np.array([160, 120]), 50), 'red')\\n drawSolid(canvas, regularPolygon(4, np.array([480, 120]), 90), 'blue')\\n drawSolid(canvas, regularPolygon(5, np.array([420, 360]), 60), 'green')\\n drawSolid(canvas, regularPolygon(6, np.array([160, 360]), 80), 'black')\\n drawSolid(canvas, regularPolygon(7, np.array([320, 160]), 70), 'brown')\\n\\n \\\"\\\"\\\" saving the file and closing it \\\"\\\"\\\"\\n image.save(result_file)\\n image.close()\\n\\n \\\"\\\"\\\" validate the resultant file against the reference images\\\"\\\"\\\"\\n\\n validate(reference_file, result_file)\",\n \"def ring(radius = 10, width = 0.5, angle_resolution = 2.5, layer = 0):\\n D = Device(name = 'ring')\\n inner_radius = radius - width/2\\n outer_radius = radius + width/2\\n n = int(np.round(360/angle_resolution))\\n t = np.linspace(0, 360, n+1) * pi/180\\n inner_points_x = (inner_radius*cos(t)).tolist()\\n inner_points_y = (inner_radius*sin(t)).tolist()\\n outer_points_x = (outer_radius*cos(t)).tolist()\\n outer_points_y = (outer_radius*sin(t)).tolist()\\n xpts = inner_points_x + outer_points_x[::-1]\\n ypts = inner_points_y + outer_points_y[::-1]\\n D.add_polygon(points = (xpts, ypts), layer = layer)\\n return D\",\n \"def generate_solid(self):\\n ext = os.path.splitext(self.filename)[1][1:]\\n if ext == 'stl':\\n shaft_compound = read_stl_file(self.filename)\\n elif ext == 'iges':\\n iges_reader = IGESControl_Reader()\\n iges_reader.ReadFile(self.filename)\\n iges_reader.TransferRoots()\\n shaft_compound = iges_reader.Shape()\\n else:\\n raise Exception('The shaft file is not in iges/stl formats')\\n sewer = BRepBuilderAPI_Sewing(1e-2)\\n sewer.Add(shaft_compound)\\n sewer.Perform()\\n result_sewed_shaft = sewer.SewedShape()\\n shaft_solid_maker = BRepBuilderAPI_MakeSolid()\\n shaft_solid_maker.Add(OCC.Core.TopoDS.topods_Shell(result_sewed_shaft))\\n if not shaft_solid_maker.IsDone():\\n raise RuntimeError('Unsuccessful assembling of solid shaft')\\n shaft_solid = shaft_solid_maker.Solid()\\n return shaft_solid\",\n \"def roof_cc(lenght, width, overhang=1, wall_height=3, roof_height=4):\\n a = min(0.1 * lenght, 0.1 * width, 0.4 * (wall_height + 0.5 * roof_height))\\n\\n area = (lenght + overhang)*(width + overhang)\\n area_3 = 8*a**2\\n area_1 = (lenght - 2)*(width - 4*a)\\n area_2 = area - area_3 - area_1\\n return area, area_1, area_2, area_3\",\n \"def test_create_circuit_noname(self):\\n q_program = QuantumProgram()\\n qr = q_program.create_quantum_register(size=3)\\n cr = q_program.create_classical_register(size=3)\\n qc = q_program.create_circuit(qregisters=[qr], cregisters=[cr])\\n self.assertIsInstance(qc, QuantumCircuit)\",\n \"def smear_coolant_wirewrap(info):\\n height = info[0]\\n fuel_radius = info[1] / 2\\n wirewrap_radius = info[2] / 2\\n wire_wrap_axial_pitch = info[3]\\n fuel_pitch = info[4]\\n coolant_material = info[5]\\n clad_material = info[6]\\n fuel_volume = utilities.get_cylinder_volume(fuel_radius, height)\\n wire_wrap_volume = utilities.get_toroidal_volume(fuel_radius, wirewrap_radius, wire_wrap_axial_pitch, height)\\n pin_hexagonal_universe_volume = utilities.get_hexagonal_prism_volume(fuel_pitch, height)\\n coolant_volume = pin_hexagonal_universe_volume - fuel_volume - wire_wrap_volume\\n total_coolant_wire_wrap_volume = coolant_volume + wire_wrap_volume\\n wire_wrap_volume_percent = wire_wrap_volume / total_coolant_wire_wrap_volume\\n coolant_volume_percent = coolant_volume / total_coolant_wire_wrap_volume\\n smeared_material_dict = {clad_material: wire_wrap_volume_percent, coolant_material: coolant_volume_percent}\\n return smeared_material_dict\",\n \"def test_cyclohexane(self):\\n self._test_shape(\\n image_size=(1000, 1000),\\n expected_corners=np.array([\\n [[400, 400]],\\n [[487, 350]],\\n [[574, 400]],\\n [[574, 500]],\\n [[487, 550]],\\n [[400, 500]]\\n ]),\\n drawer=lambda image: image.add_regular_hexagon(\\n 100, start_coord=(400, 400)\\n )\\n )\",\n \"def circuitSat(C):\",\n \"def to_circuit(self):\\n from qiskit.synthesis.cnotdihedral import synth_cnotdihedral_full\\n\\n return synth_cnotdihedral_full(self)\",\n \"def add_connector(self):\\n \\n no = len(self.connectors)\\n state = {}\\n state[\\\"s_pin\\\"] = no\\n state[\\\"p_pin\\\"] = no\\n state[\\\"s_label\\\"] = \\\"C%d\\\" % no\\n \\n if len(self.connectors)>0:\\n state = self.connectors[-1].get_state()\\n state[\\\"s_pin\\\"] = no\\n state[\\\"p_pin\\\"] = no\\n state[\\\"s_label\\\"] = \\\"C%d\\\" % (no)\\n else:\\n if self.mount == self.MOUNT_THT:\\n state[\\\"p_shape\\\"] = Con.SHAPE_HOLE\\n elif self.mount == self.MOUNT_SMD:\\n state[\\\"p_shape\\\"] = Con.SHAPE_PAD\\n \\n c = Con(no)\\n c.set_state(state) \\n \\n self.sch_layers[\\\"pins\\\"].add(c.s_svg)\\n self.pcb_layers[\\\"copper1\\\"].add(c.p_svg)\\n self.connectors.append(c)\",\n \"async def create_channel(self):\\n self._logger.info(\\\"Deploying chaincode...\\\")\\n network_file_path = os.path.join(os.getcwd(), \\\"network.json\\\")\\n channel_config_path = os.path.join(self.config_path, \\\"channel-artifacts\\\", \\\"channel.tx\\\")\\n\\n self.fabric_client = Client(net_profile=network_file_path)\\n\\n org1_admin = self.fabric_client.get_user(org_name='org1.example.com', name='Admin')\\n\\n # Create a New Channel, the response should be true if succeed\\n response = await self.fabric_client.channel_create(\\n orderer='orderer1.example.com',\\n channel_name='mychannel',\\n requestor=org1_admin,\\n config_tx=channel_config_path\\n )\\n self._logger.info(\\\"Result of channel creation: %s\\\", response)\",\n \"def bell():\\n qr = QuantumRegister(2, name='qr')\\n cr = ClassicalRegister(2, name='qc')\\n qc = QuantumCircuit(qr, cr, name='bell')\\n qc.h(qr[0])\\n qc.cx(qr[0], qr[1])\\n qc.measure(qr, cr)\\n\\n return qc\",\n \"def corrRing(self, angle):\\n c =\\\"/cli:python /app:matrix /cmd:setcorring\\\" + str(float(angle))\\n self.sendCMDstring(c)\",\n \"def walls_cc(lenght, width, wall_height=3, roof_height=4):\\n a = min(0.1*lenght, 0.1*width, 0.4*(wall_height+0.5*roof_height))\\n trian = 0.5*width*roof_height\\n trian_5 = 0.5*a*a*(wall_height/roof_height)\\n # trian_4 = trian - 2*trian_5\\n\\n area = (lenght + width)*2*wall_height + 2*trian\\n area_5 = 8*a*wall_height + 4*trian_5\\n area_4 = area - area_5\\n\\n return area, area_4, area_5\",\n \"async def _create_cycle(self, ctx: Context, number: int = None):\\n\\n guild: discord.Guild = ctx.guild\\n\\n if not number:\\n number = (\\n await self.config.guild(guild).get_raw(\\\"cycle\\\", \\\"number\\\") + 1\\n )\\n\\n msg = await ctx.send(\\n _(\\n \\\"Are you sure you want to create cycle `{}` channels? Make\\\"\\n \\\" sure you have the day text ready. Users will be able to talk\\\"\\n \\\" in the day and vote channels as soon as they are created.\\\"\\n ).format(number)\\n )\\n start_adding_reactions(msg, ReactionPredicate.YES_OR_NO_EMOJIS)\\n\\n pred = ReactionPredicate.yes_or_no(msg, ctx.author)\\n await ctx.bot.wait_for(\\\"reaction_add\\\", check=pred)\\n\\n if not pred.result:\\n return await ctx.send(_(\\\"Process aborted.\\\"))\\n\\n player_id = await self.config.guild(guild).player_id()\\n player_role = discord.utils.get(guild.roles, id=player_id)\\n\\n overwrites = {\\n guild.default_role: discord.PermissionOverwrite(\\n read_messages=True,\\n send_messages=False\\n ),\\n player_role: discord.PermissionOverwrite(\\n send_messages=True,\\n attach_files=False\\n ),\\n guild.me: discord.PermissionOverwrite(\\n send_messages=True,\\n embed_links=True\\n )\\n }\\n\\n cycle_category = await guild.create_category_channel(\\n f\\\"Cycle {number}\\\", overwrites=overwrites\\n )\\n\\n day = await cycle_category.create_text_channel(f\\\"day-{number}\\\")\\n vote = await cycle_category.create_text_channel(f\\\"day-{number}-votes\\\")\\n\\n night_overwrites = {\\n guild.default_role: discord.PermissionOverwrite(\\n read_messages=False\\n ),\\n guild.me: discord.PermissionOverwrite(\\n read_messages=True\\n )\\n }\\n\\n night = await cycle_category.create_text_channel(\\n f\\\"night-{number}\\\", overwrites=night_overwrites\\n )\\n\\n await self.config.guild(guild).na_submitted.clear()\\n\\n async with self.config.guild(guild).cycle() as cycle:\\n cycle[\\\"number\\\"] = number\\n cycle[\\\"day\\\"] = day.id\\n cycle[\\\"vote\\\"] = vote.id\\n cycle[\\\"night\\\"] = night.id\\n\\n await ctx.send(_(\\\"Created cycle {} channels!\\\").format(number))\",\n \"def short_circ():\\n \\n set_mode(mode_cv)\\n time.sleep(.250)\\n set_CV_volts(0.1)\\n time.sleep(.250)\\n \\n sc_vals = get_input_values()\\n sc_data_point = data_point(sc_vals)\\n jsc = sc_data_point[4]\\n print('Short circuit current: ', jsc)\\n write_data_tofile(sc_data_point)\\n\\n return jsc\",\n \"def construct_qcbm(circuit, n_qubits, depth):\\n\\n for d in range(depth):\\n for i in range(n_qubits):\\n circuit.append_gate(Gate('X', target = i, angle = np.random.random()*np.pi*2))\\n circuit.append_gate(Gate('Z', target = i, angle = np.random.random()*np.pi*2))\\n if n_qubits != 1:\\n for i in range(n_qubits):\\n circuit.append_gate(Gate('CNOT', control = i, target = (i+1)%n_qubits))\\n return circuit\",\n \"def test_rocket():\\n ring = [(0,0), (10, 0), (15,5), (10,9), (1,7), (6,4), (0,0)]\\n conv = ToPointsAndSegments()\\n conv.add_polygon([ring])\\n skel = calc_skel(conv, output=True, pause=True)\\n print \\\"DONE\\\"\",\n \"def circle(t, r):\\n circumference = math.pi * 2 * r\\n n = 60\\n length = circumference / n\\n polygon(t, length, n)\",\n \"def request_circuit_build(self, deferred, path=None):\\n if path is None:\\n\\n pick = self.relays['all'].pop\\n n = self.state.entry_guards.values()\\n choose = random.choice\\n\\n first, middle, last = (None for i in range(3))\\n\\n if self.relays['remaining']() >= 3:\\n first, middle, last = (pick() for i in range(3))\\n elif self.relays['remaining']() < 3:\\n first = choose(n)\\n middle = pick()\\n if self.relays['remaining'] == 2:\\n middle, last = (pick() for i in range(2))\\n elif self.relay['remaining'] == 1:\\n middle = pick()\\n last = choose(n)\\n else:\\n log.msg(\\\"Qu'est-que fuque?\\\")\\n else:\\n middle, last = (random.choice(self.state.routers.values())\\n for i in range(2))\\n\\n path = [first, middle, last]\\n\\n else:\\n assert isinstance(path, list), \\\\\\n \\\"Circuit path must be a list of relays!\\\"\\n assert len(path) >= 3, \\\\\\n \\\"Circuit path must be at least three hops!\\\"\\n\\n log.msg(\\\"Requesting a circuit: %s\\\"\\n % '->'.join(map(lambda node: node, path)))\\n\\n class AppendWaiting:\\n def __init__(self, attacher, deferred):\\n self.attacher = attacher\\n self.d = deferred\\n def __call__(self, circ):\\n \\\"\\\"\\\"\\n Return from build_circuit is a Circuit, however,\\n we want to wait until it is built before we can\\n issue an attach on it and callback to the Deferred\\n we issue here.\\n \\\"\\\"\\\"\\n log.msg(\\\"Circuit %s is in progress ...\\\" % circ.id)\\n self.attacher.waiting_circuits.append((circ.id, self.d))\\n\\n return self.state.build_circuit(path).addCallback(\\n AppendWaiting(self, deferred)).addErrback(\\n log.err)\",\n \"def solid(t, coord, ii, n_pixels, random_values):\\n\\n\\n return (100,100,100)\",\n \"def cliques_on_ring(cliques,labels,G, cut=0):\\n print(\\\"cliques_on_ring CUT:\\\", cut)\\n #if partitions\\n if cut > 1:\\n partitions = get_partitions(cliques,cut)\\n for partition in partitions:\\n if len(partition) > 1:\\n n1 = random.choice(partition[0])\\n for idx,clique in enumerate(partition):\\n if idx > 0:# and idx not in cuts:\\n candidates = [n for n in clique if labels[n.id] != labels[n1.id]]\\n candidates = candidates if len(candidates) > 0 else clique\\n n2 = random.choice(candidates)\\n G.add_edge(n1,n2)\\n n1 = random.choice(clique)\\n\\n else:\\n n1 = random.choice(cliques[0]) \\n for idx,clique in enumerate(cliques):\\n if idx > 0:# and idx not in cuts:\\n candidates = [n for n in clique if labels[n.id] != labels[n1.id]]\\n candidates = candidates if len(candidates) > 0 else clique\\n n2 = random.choice(candidates)\\n G.add_edge(n1,n2)\\n n1 = random.choice(clique)\\n \\n #Attach head and tail cliques\\n candidates = [n for n in cliques[0] if labels[n.id] != labels[n1.id]]\\n candidates = candidates if len(candidates) > 0 else cliques[0]\\n n2 = random.choice(candidates)\\n G.add_edge(n1,n2)\",\n \"def make_path(self, loop):\\n path=Path(closed=True)\\n for c in range(0,len(loop)):\\n connection=loop[c]\\n nextConnection = loop[(c+1)%len(loop)]\\n lastConnection = loop[(c-1)%len(loop)]\\n if self.dontFill(connection, nextConnection, lastConnection):\\n return False\\n cp = self.corner_pos(connection, nextConnection, lastConnection)\\n corner_offset = cp[0]\\n corner_dir = cp[1]\\n # catch case when it is the end of a single rod\\n if type(corner_offset) is list:\\n endpoints = corner_offset\\n corner_offset = endpoints[0]\\n else:\\n endpoints = False\\n if connection.other.radius is not None and ( corner_offset.length() < connection.other.radius or corner_dir >0):\\n # catch case when it is the end of a single rod\\n if endpoints:\\n para=(connection.this.pos-connection.other.pos).normalize()\\n d = math.sqrt(connection.other.radius**2 - corner_offset.length()**2)\\n path.add_point(PSharp(connection.other.pos + corner_offset + d*para))\\n path.add_point(PArc(connection.other.pos, radius=connection.other.radius, direction='cw'))\\n path.add_point(PSharp(connection.other.pos - corner_offset+d*para))\\n else:\\n path.add_point(PAroundcurve(connection.other.pos + corner_offset, centre=connection.other.pos, radius=connection.other.radius, direction='cw'))\\n\\n elif self.get_intRadius(connection, connection.other) is not None:\\n # path.add_point(PIncurve(connection.other.pos + corner_offset, radius=self.get_intRadius(connection, connection.other)))\\n # path.add_point(PIncurve(connection.other.pos - corner_offset, radius=self.get_intRadius(connection, connection.other)))\\n # path.add_point(PIncurve(connection.other.pos - corner_offset, radius=self.get_intRadius(connection, connection.other)))\\n path.add_point(PIncurve(connection.other.pos + corner_offset, radius=self.get_intRadius(connection, connection.other)))\\n else:\\n cornerpos = self.corner_pos(connection, nextConnection, lastConnection)\\n if type(cornerpos) is list:\\n path.add_point(PSharp(connection.other.pos + cornerpos[0]))\\n path.add_point(PSharp(connection.other.pos + cornerpos[1]))\\n else:\\n path.add_point(PSharp(connection.other.pos + cornerpos))#self.corner_pos(connection, nextConnection, lastConnection)))\\n # path.add_point(PSharp(connection.other.pos - cornerpos))#self.corner_pos(connection, nextConnection, lastConnection)))\\n if connection.other.holeRad is not None:\\n if type(connection.other.holeRad) is int or type(connection.other.holeRad) is float:\\n self.otherpaths.append(Circle(connection.other.pos, rad=connection.other.holeRad, side='in'))\\n else:\\n t=copy.deepcopy(connection.other.holeRad)\\n t.translate(connection.other.pos)\\n self.otherpaths.append(t)\\n return path\",\n \"def draw_C(self, frame):\\n c = self.get_real_leg()\\n cv2.circle(\\n frame,\\n (\\n Utils.ConvertX(c.x),\\n Utils.ConvertY(c.y)\\n ),\\n 8,\\n color=Utils.blue,\\n thickness=-1\\n )\",\n \"def ring(self):\\n pass\",\n \"def CreateFiller(filler_def):\\n filler_def = filler_def if isinstance(filler_def, str) \\\\\\n else filler_def.SerializeToString()\\n CreateFillerCC(filler_def)\",\n \"def create_brake_command(apply_brake, pcm_override, pcm_cancel_cmd, chime, idx):\\n pump_on = apply_brake > 0\\n brakelights = apply_brake > 0\\n brake_rq = apply_brake > 0\\n\\n pcm_fault_cmd = False\\n amount = struct.pack(\\\"!H\\\", (apply_brake << 6) + pump_on)\\n msg = amount + struct.pack(\\\"BBB\\\", (pcm_override << 4) |\\n (pcm_fault_cmd << 2) |\\n (pcm_cancel_cmd << 1) | brake_rq, 0x80,\\n brakelights << 7) + chr(chime) + \\\"\\\\x00\\\"\\n return make_can_msg(0x1fa, msg, idx, 0)\",\n \"def _create_main_shape(self):\\n\\n a, b = gc( self.size/2,\\n self._ZERO_DEGREES - self.angle,\\n self._180_DEGREES + self.angle)\\n self.wafer_points = zip(a,b)\\n self.wafer_polygon = gdspy.Polygon(self.wafer_points, self.WAFER_LAYER)\\n self.cell.add(self.wafer_polygon)\",\n \"def test_component_coolant_connection_list(self):\\n with PhysicsEngineHarness('tests/engineering-test.json') as physics_engine:\\n engineering = physics_engine.get_state().engineering\\n\\n connected_loops = engineering.components.CoolantConnectionMatrix()\\n self.assertEqual(connected_loops.shape, (3, N_COMPONENTS))\",\n \"def drawBrick(res_num1, atom1, res_num2, atom2, **kwargs):\\n\\n chain1 = str(kwargs.pop(\\\"chain1\\\", \\\"A\\\")).strip()\\n chain2 = str(kwargs.pop(\\\"chain2\\\", \\\"A\\\")).strip()\\n res_num1 = int(res_num1)\\n res_num2 = int(res_num2)\\n offset1 = str2array(kwargs.pop(\\\"offset1\\\", \\\"(0,0,0)\\\"))\\n offset2 = str2array(kwargs.pop(\\\"offset2\\\", \\\"(0,0,0)\\\"))\\n\\n boxname = kwargs.pop(\\\"boxname\\\", \\\"brick\\\")\\n selname = kwargs.pop(\\\"name\\\", \\\"(sel)\\\")\\n p1 = get_selection_first_coord(\\\"///%(chain1)s/`%(res_num1)d/%(atom1)s\\\" % vars(), selname)\\n p2 = get_selection_first_coord(\\\"///%(chain2)s/`%(res_num2)d/%(atom2)s\\\" % vars(), selname)\\n\\n #print \\\"lower_left: %r\\\" % lower_left\\n #print \\\"offset1: %r\\\" % offset1\\n\\n p1 += offset1\\n p2 += offset2\\n\\n lower_left = numpy.where(p1 < p2, p1, p2)\\n upper_right = numpy.where(p1 < p2, p2, p1)\\n\\n print \\\"--> lower left front corner: %(lower_left)r\\\" % vars()\\n print \\\"--> upper right back corner: %(upper_right)r\\\" % vars()\\n\\n boxCGO = box(lower_left, upper_right, **kwargs)\\n cmd.load_cgo(boxCGO, boxname)\\n return boxname\",\n \"def circlePrimitive(self):\\n\\n def drawWireframe(self):\\n\\n # Draw line\\n glFT.glBegin(OpenMayaRender.MGL_LINE_STRIP)\\n\\n # Get Color\\n # self.getColor(\\\"edge\\\")\\n\\n def_circle = 100\\n for idx in range(def_circle + 1):\\n\\n theta = 2 * 3.141592 * idx / def_circle\\n x = self.shape_size * math.cos(theta)\\n z = self.shape_size * math.sin(theta)\\n\\n point = OpenMaya.MVector(x, 0.0, z)\\n point = self.setUpAxis(point)\\n point = self.addOffsetRotation(point)\\n point = self.addOffsetPosition(point)\\n self.getBoundingBoxSize(point)\\n\\n glFT.glVertex3f(point.x, point.y, point.z)\\n\\n glFT.glEnd()\\n \\n def drawShaded(self):\\n\\n # Draw quad\\n glFT.glBegin(OpenMayaRender.MGL_POLYGON)\\n\\n # Get Color\\n # self.getColor(\\\"polygon\\\")\\n\\n def_circle = 100\\n for idx in range(def_circle + 1):\\n\\n theta = 2 * 3.141592 * idx / def_circle\\n x = self.shape_size * math.cos(theta)\\n z = self.shape_size * math.sin(theta)\\n\\n point = OpenMaya.MVector(x, 0.0, z)\\n point = self.setUpAxis(point)\\n point = self.addOffsetRotation(point)\\n point = self.addOffsetPosition(point)\\n self.getBoundingBoxSize(point)\\n\\n glFT.glVertex3f(point.x, point.y, point.z)\\n\\n glFT.glEnd()\\n\\n glFT.glNewList(self.vList_id, OpenMayaRender.MGL_COMPILE)\\n\\n # Draw lines\\n if self.draw_type == 0 or self.draw_type == 2:\\n drawWireframe(self)\\n \\n # Draww Polygons\\n if self.draw_type == 1 or self.draw_type == 2:\\n drawShaded(self)\\n\\n glFT.glEndList()\",\n \"def creates_valid_building(self, cell):\\n def wont_cut_off_other_commercial_buildings(pos):\\n \\\"\\\"\\\"Helper function that ensures other commercial buildings won't be cutoff if a commercial building is\\n placed at pos\\\"\\\"\\\"\\n for adj_cell in self.environment.grid.get_neighborhood(pos, moore=False, include_center=False):\\n # Check if the adj_cell is already touching at most 3 commercial buildings - can't cut anybody off\\n if self.num_adj_commercial_buildings(adj_cell) == 3:\\n return False\\n\\n return True\\n\\n return \\\\\\n self.environment.grid.is_cell_empty(cell) and \\\\\\n self.num_adj_commercial_buildings(cell) != 4 and \\\\\\n wont_cut_off_other_commercial_buildings(cell)\",\n \"def calc_chromatic_coupling(self):\\n raise NotImplementedError('Chromatic Coupling is not Implemented yet.')\",\n \"def test_component_coolant_connection_list(self):\\n with PhysicsEngineHarness('tests/engineering-test.json') as physics_engine:\\n engineering = physics_engine.get_state().engineering\\n\\n connected_loops = engineering.components.CoolantConnectionMatrix()\\n\\n self.assertEqual(connected_loops.shape, (3, N_COMPONENTS))\",\n \"def glycosylate(self):\\n chid = self.chain.get()\\n sequon = self.sequon.get()\\n self.sequon_colors[sequon] = [.7, .1, 0]\\n key = self.sequon.get()\\n residue = self.myGlycosylator.get_residue(key)\\n #Build new glycan\\n if self.selected_glycan:\\n self.myGlycosylator.connect_topology['SELECTED'] = self.selected_glycan[1]\\n #build from current glycan\\n if key in self.original_glycans:\\n original_glycan = self.original_glycanMolecules[key].atom_group\\n r,t = self.original_glycans[key]\\n connect_tree = self.myGlycosylator.build_connectivity_tree(r, t)\\n else:\\n original_glycan = None\\n connect_tree = None \\n #Use current glycan\\n else:\\n original_glycan = self.original_glycanMolecules[key]\\n r,t = self.original_glycans[key]\\n connect_tree = self.myGlycosylator.build_connectivity_tree(r, t)\\n self.myGlycosylator.connect_topology['SELECTED'] = self.myGlycosylator.build_connect_topology(original_glycan) \\n original_glycan = original_glycan.atom_group\\n \\n segname = 'G'+key.split(',')[2]\\n glycan,bonds = self.myGlycosylator.glycosylate('SELECTED', \\n template_glycan_tree = connect_tree, \\n template_glycan = original_glycan,\\n link_residue=residue, link_patch = 'NGLB', chain = 'G', segname=segname)\\n new_glycan = glc.Molecule(key)\\n new_glycan.set_AtomGroup(glycan, bonds = bonds)\\n self.myGlycosylator.assign_patches(new_glycan)\\n self.linked_glycanMolecules[key] = new_glycan\\n self.linked_glycans[key] = [new_glycan.rootRes, new_glycan.interresidue_connectivity]\\n self.names.update(new_glycan.get_names())\\n # Update glycoprotein and sequon panels\\n self.draw_glycoprotein(chid)\\n self.draw_glycan(sequon)\",\n \"def cmd_cb():\\n cmds = []\\n #cmds.append(\\\"r_m[0.0,-1,1]\\\")\\n cmds.append(\\\"r_m[0.0]\\\")\\n cmds.append('r_a[1.7,0,10]')\\n cmds.append('r_n[1.5,0,10]')\\n cmds.append(\\\"r_s[2.5,0,10]\\\")\\n cmds.append('RooCBShape::res(x,r_m,r_s,r_a,r_n)')\\n return cmds\",\n \"def corridor(x,z, emap, width=10, length=10, height=10, details=None, walls=\\\"ns\\\", name=\\\"wall\\\", mergeshape=None):\\r\\n global wallnum\\r\\n n = z + width / 2\\r\\n s = z - width / 2\\r\\n e = x + length / 2\\r\\n w = x - length / 2\\r\\n\\r\\n solid_objects = []\\r\\n\\r\\n if \\\"n\\\" in walls:\\r\\n # TODO: abstract out the mostly-duplicate code in these cases...\\r\\n nwall = SolidObject(name+str(wallnum),\\r\\n Size(length, height, 1),\\r\\n Position(x, emap.calcHeight(x, z) + height / 2, n-0.5), 0)\\r\\n solid_objects.append(nwall)\\r\\n nwallmodel = createMyCuboid(nwall.w() * 2, nwall.h() * 2, nwall.d() * 2,\\r\\n name=name+str(wallnum),\\r\\n x=nwall.x(),y=nwall.y(),z=nwall.z(),\\r\\n rx=0.0, ry=0.0, rz=0.0, cx=0.0, cy=0.0, cz=0.0)\\r\\n if mergeshape:\\r\\n mergeshape.add(nwallmodel)\\r\\n else:\\r\\n nwall.setmodel(nwallmodel, details)\\r\\n\\r\\n\\r\\n wallnum += 1\\r\\n\\r\\n if \\\"s\\\" in walls:\\r\\n swall = SolidObject(name+str(wallnum), Size(length, height, 1), Position(x, emap.calcHeight(x, z)+height / 2, s+0.5), 0)\\r\\n solid_objects.append(swall)\\r\\n swallmodel = createMyCuboid(swall.w()*2, swall.h()*2, swall.d()*2,\\r\\n name=name+str(wallnum),\\r\\n x=swall.x(), y=swall.y(), z=swall.z(),\\r\\n rx=0.0, ry=0.0, rz=0.0, cx=0.0,cy=0.0, cz=0.0)\\r\\n if mergeshape:\\r\\n mergeshape.add(swallmodel)\\r\\n else:\\r\\n swall.setmodel(swallmodel, details)\\r\\n\\r\\n wallnum += 1\\r\\n\\r\\n if \\\"e\\\" in walls:\\r\\n ewall = SolidObject(name+str(wallnum), Size(1, height, width), Position(e-0.5, emap.calcHeight(x, z)+height / 2, z), 0)\\r\\n solid_objects.append(ewall)\\r\\n ewallmodel = createMyCuboid(ewall.w()*2, ewall.h()*2, ewall.d()*2,\\r\\n name=name+str(wallnum),\\r\\n x=ewall.x(), y=ewall.y(), z=ewall.z(),\\r\\n rx=0.0, ry=0.0, rz=0.0, cx=0.0, cy=0.0, cz=0.0)\\r\\n if mergeshape:\\r\\n mergeshape.add(ewallmodel)\\r\\n else:\\r\\n ewall.setmodel(ewallmodel, details)\\r\\n\\r\\n wallnum += 1\\r\\n\\r\\n if \\\"w\\\" in walls:\\r\\n wwall = SolidObject(name+str(wallnum), Size(1, height, width), Position(w+0.5, emap.calcHeight(x, z)+height / 2, z), 0)\\r\\n solid_objects.append(wwall)\\r\\n wwallmodel = createMyCuboid(wwall.w()*2, wwall.h()*2, wwall.d()*2,\\r\\n name=name+str(wallnum),\\r\\n x=wwall.x(), y=wwall.y(), z=wwall.z(),\\r\\n rx=0.0, ry=0.0, rz=0.0, cx=0.0, cy=0.0, cz=0.0)\\r\\n if mergeshape:\\r\\n mergeshape.add(wwallmodel)\\r\\n else:\\r\\n wwall.setmodel(wwallmodel, details)\\r\\n wallnum += 1\\r\\n\\r\\n if \\\"o\\\" not in walls:\\r\\n ceiling = SolidObject(name+str(wallnum), Size(length, 1, width), Position(x, emap.calcHeight(x, z)+height+0.5, z), 0)\\r\\n solid_objects.append(ceiling)\\r\\n ceilingmodel = createMyCuboid(ceiling.w()*2, ceiling.h()*2, ceiling.d()*2,\\r\\n name=name+str(wallnum),\\r\\n x=ceiling.x(), y=ceiling.y(), z=ceiling.z(),\\r\\n rx=0.0, ry=0.0, rz=0.0, cx=0.0, cy=0.0, cz=0.0)\\r\\n if mergeshape:\\r\\n mergeshape.add(ceilingmodel)\\r\\n else:\\r\\n ceiling.setmodel(ceilingmodel, details)\\r\\n\\r\\n wallnum += 1\\r\\n\\r\\n return solid_objects\",\n \"def bc_is_solid(bc):\\n solid = BCProp(int(bc_solid[bc.xlb]),\\n int(bc_solid[bc.xrb]),\\n int(bc_solid[bc.ylb]),\\n int(bc_solid[bc.yrb]))\\n return solid\",\n \"def bamboo(screen, color, x, y, size):\\n rect(screen, color, (x, y + size * 6, size, size * 14 / 3))\\n rect(screen, color, (x, y, size, size * 16 / 3))\\n polygon(screen, color, [(x + size * 2 / 3, y - size * 2 / 3), (x, y - size),\\n (x + size / 3, y - size * 13 / 3), (x + size, y - size * 14 / 3)])\\n polygon(screen, color, [(x + size, y - size * 14 / 3), (x + size * 2 / 3, y - size * 73 / 15),\\n (x + size * 17 / 15, y - size * 29 / 3), (x + size * 22 / 15, y - size * 142 / 15)])\\n stick(screen, color, [x - size * 13 / 3, y - size * 5 / 3], [x - size * 1 / 3, y + size / 3], 3, 1, -30)\\n stick(screen, color, [x + size * 24 / 3, y - size * 25 / 3], [x + size * 4 / 3, y - size * 3], 5, 1, 30)\\n stick(screen, color, [x - size * 13 / 3, y - size * 25 / 3], [x - size * 1 / 3, y - size * 5], 5, 1, -30)\\n stick(screen, color, [x + size * 14 / 3, y - size * 5 / 3], [x + size * 4 / 3, y + size / 3], 3, 1, 30)\",\n \"def createCirclePolygon(h, k, r, dx):\\n D = 10.0\\n theta = 2 * np.arccos((r-(dx/D))/r)\\n npoints = int(360.0/theta)\\n x, y = getPointsInCircum(r, n=npoints, h=h, k=k)\\n p = Polygon(list(zip(x, y)))\\n return p\",\n \"def convert_to_circuit(x):\\n y = np.arcsin(x)\\n z = np.arccos(x**2)\\n qubits = cirq.GridQubit.rect(5, 1)\\n circuit = cirq.Circuit()\\n for i in range(5):\\n circuit.append(cirq.ry(y).on(qubits[i]))\\n circuit.append(cirq.rz(z).on(qubits[i]))\\n return circuit\",\n \"def conj(q_1: Q, conj_type: int = 0) -> Q:\\n\\n end_q_type = f\\\"{q_1.q_type}*\\\"\\n c_t, c_x, c_y, c_z = q_1.t, q_1.x, q_1.y, q_1.z\\n cq = Q()\\n\\n if conj_type % 4 == 0:\\n cq.t = c_t\\n if c_x != 0:\\n cq.x = -1 * c_x\\n if c_y != 0:\\n cq.y = -1 * c_y\\n if c_z != 0:\\n cq.z = -1 * c_z\\n\\n elif conj_type % 4 == 1:\\n if c_t != 0:\\n cq.t = -1 * c_t\\n cq.x = c_x\\n if c_y != 0:\\n cq.y = -1 * c_y\\n if c_z != 0:\\n cq.z = -1 * c_z\\n end_q_type += \\\"1\\\"\\n\\n elif conj_type % 4 == 2:\\n if c_t != 0:\\n cq.t = -1 * c_t\\n if c_x != 0:\\n cq.x = -1 * c_x\\n cq.y = c_y\\n if c_z != 0:\\n cq.z = -1 * c_z\\n end_q_type += \\\"2\\\"\\n\\n elif conj_type % 4 == 3:\\n if c_t != 0:\\n cq.t = -1 * c_t\\n if c_x != 0:\\n cq.x = -1 * c_x\\n if c_y != 0:\\n cq.y = -1 * c_y\\n cq.z = c_z\\n end_q_type += \\\"3\\\"\\n\\n cq.q_type = end_q_type\\n cq.representation = q_1.representation\\n\\n return cq\",\n \"def concent_graph(self):\\n r_big = self['M_RSMALL']\\n r_small = self['M_RBIG']\\n C = self['M_C']\\n \\n xcenter = self['X_IMAGE'] ; ycenter = self['Y_IMAGE']\\n xcenter = xcenter - self['MXMIN_IMAGE']\\n ycenter = ycenter - self['MYMIN_IMAGE']\\n center = (xcenter,ycenter)\\n \\n ellip = self['ELLIPTICITY'] \\n q = 1. - ellip\\n pa = self['THETA_IMAGE'] # Astronomical position angle.\\n\\n stamp = self['STAMP'].copy()\\n mask = self['MASKOTHER'].copy()\\n sky = self['BACKGROUND']\\n Img = stamp - sky\\n Img[num.where(mask != 0)] = 0.\\n \\n id = self._getGraphId()\\n root = 'C_%s' % (id,)\\n pngname = root + '.png' ; epsname = root + '.eps'\\n jpgname = root + '.jpg'\\n doStamp(Img,pngname,format='PNG')\\n Convert(pngname,jpgname)\\n \\n Painted = Paint(jpgname)\\n Painted.load()\\n Painted.DrawEllipse(center,r_big,q,pa,color='red',linewidth=2)\\n Painted.DrawEllipse(center,r_small,q,pa,color='green',linewidth=2)\\n \\n text = 'C=%5.2f' % (self['M_C'])\\n # Painted.Graffiti(text,commtextpos)\\n Painted.save(jpgname) \\n Painted.release()\\n \\n Convert(jpgname,epsname)\\n os.system('rm %s %s' % (pngname,jpgname))\\n \\n self['figures']['C'] = epsname\\n self['figcomms']['C'] = text\",\n \"def cones_and_cylinders(\\n network,\\n pore_diameter=\\\"pore.diameter\\\",\\n throat_diameter=\\\"throat.diameter\\\",\\n):\\n D1, Dt, D2 = network.get_conduit_data(pore_diameter.split('.', 1)[-1]).T\\n L1, Lt, L2 = _conduit_lengths.cones_and_cylinders(\\n network=network,\\n pore_diameter=pore_diameter,\\n throat_diameter=throat_diameter\\n ).T\\n\\n # Fi is the integral of (1/A^2) dx, x = [0, Li]\\n F1 = 16 / 3 * (L1 * (D1**2 + D1 * Dt + Dt**2) / (D1**3 * Dt**3 * _np.pi**2))\\n F2 = 16 / 3 * (L2 * (D2**2 + D2 * Dt + Dt**2) / (D2**3 * Dt**3 * _np.pi**2))\\n Ft = Lt / (_np.pi * Dt**2 / 4) ** 2\\n\\n # I is the integral of (y^2 + z^2) dA, divided by A^2\\n I1 = I2 = It = 1 / (2 * _np.pi)\\n\\n # S is 1 / (16 * pi^2 * I * F)\\n S1 = 1 / (16 * _np.pi**2 * I1 * F1)\\n St = 1 / (16 * _np.pi**2 * It * Ft)\\n S2 = 1 / (16 * _np.pi**2 * I2 * F2)\\n\\n return _np.vstack([S1, St, S2]).T\",\n \"def draw_housing():\\r\\n green.pensize(3)\\r\\n green.color(\\\"black\\\", \\\"darkgrey\\\")\\r\\n green.begin_fill()\\r\\n green.forward(80)\\r\\n green.left(90)\\r\\n green.forward(200)\\r\\n green.circle(40, 180)\\r\\n green.forward(200)\\r\\n green.left(90)\\r\\n green.end_fill()\",\n \"def generate_random_DC_crack_coupled_tensor():\\n # 1. Generate random DC MT and crack MT:\\n # generate DC MT:\\n DC_MT_to_rot = np.vstack(([0.,0.,1.],[0.,0.,0.], [1.,0.,0.])) # DC moment tensor\\n # generate crack MT (from Tape 2013, eq. 41 and Fig. 6):\\n # To randomly generate lune_perim_angle (from Tape 2013 eq. 41 and Fig. 6):\\n # --- To randomly generate lune_perim_angle (from Tape 2013 eq. 41 and Fig. 6) ---:\\n # Get between small range:\\n theta_lune_sphere = np.random.uniform(-1.,1.)*np.pi/2.\\n random_num = random.random()\\n if random_num <= 0.5:\\n phi_lune_sphere = 0. #np.pi/6. #0. #np.pi/6.\\n elif random_num > 0.5:\\n phi_lune_sphere = np.pi/3 #-1.*np.pi/6. #np.pi/3 #-1.*np.pi/6.\\n # calculate lune_perim_angle, allowing for outside tan(-pi/2->pi/2):\\n lune_perim_angle = np.arctan(np.sin(phi_lune_sphere)/np.sin(theta_lune_sphere)) # Generates uniform distribution of lune crack angle in Lune plot space #random.random()*2.*np.pi # Random number in uniform distribution betwen 0 and 2 pi\\n # And redistribute evenly everywhere on boundary:\\n random_num = random.random()\\n if random_num>0.25 and random_num<=0.5:\\n lune_perim_angle = lune_perim_angle+np.pi # Allow to use full 2 pi space\\n if random_num>0.5 and random_num<=0.75:\\n lune_perim_angle = lune_perim_angle+np.pi/2 # Allow to use full 2 pi space\\n if random_num>0.75 and random_num<=1.0:\\n lune_perim_angle = lune_perim_angle+3*np.pi/2 # Allow to use full 2 pi space\\n # --- ---\\n # random_num = random.random()\\n # if random_num <= 0.5:\\n # theta_lune_sphere = random.random()*np.pi/2.\\n # elif random_num > 0.5:\\n # theta_lune_sphere = -1.*random.random()*np.pi/2.\\n # random_num = random.random()\\n # if random_num <= 0.5:\\n # phi_lune_sphere = np.pi/6.\\n # elif random_num > 0.5:\\n # phi_lune_sphere = -1.*np.pi/6.\\n # lune_perim_angle = np.arctan(np.sin(phi_lune_sphere)/np.sin(theta_lune_sphere)) # Generates uniform distribution of lune crack angle in Lune plot space #random.random()*2.*np.pi # Random number in uniform distribution betwen 0 and 2 pi\\n crack_MT_to_rot = ((((4*(np.sin(lune_perim_angle)**2)) + (np.cos(lune_perim_angle)**2))**-0.5)/np.sqrt(3.)) * np.vstack(([np.cos(lune_perim_angle)-(np.sqrt(2)*np.sin(lune_perim_angle)),0.,0.],[0.,np.cos(lune_perim_angle)-(np.sqrt(2)*np.sin(lune_perim_angle)),0.], [0.,0.,np.cos(lune_perim_angle)+(2.*np.sqrt(2)*np.sin(lune_perim_angle))])) # crack moment tensor\\n # 2. Combine DC and crack tensors:\\n random_amp_frac = random.random() # random number between 0. and 1., for relative amplitude of DC and crack fractions.\\n DC_crack_MT_to_rot =random_amp_frac*DC_MT_to_rot + (1.-random_amp_frac)*crack_MT_to_rot\\n # 3. Randomly rotate DC-crack MT to random orientation:\\n # Get a random sample 3-vector on a 3-unit sphere to use to calculate random theta and phi rotation angles:\\n a_unnormalised = np.array([np.random.normal(loc=0.0, scale=1.0), np.random.normal(loc=0.0, scale=1.0), np.random.normal(loc=0.0, scale=1.0)], dtype=float) # Generate 3 indepdendent normal deviates\\n a_normalised = a_unnormalised/(np.sum(a_unnormalised**2)**-0.5) # Normallise sample onto unit 3-sphere - As in Muller (1959)\\n # And normallise so that vector magnitude = 1:\\n a_normalised = a_normalised/((np.sum(a_normalised**2))**0.5)\\n x = a_normalised[0]\\n y = a_normalised[1]\\n z = a_normalised[2]\\n theta = np.arctan2(np.sqrt((x**2)+(y**2)),z) #np.arccos(z)\\n phi = np.arctan2(y,x) #np.arccos(x/np.sin(theta))\\n DC_crack_MT_rotated = rot_mt_by_theta_phi(DC_crack_MT_to_rot, theta, phi)\\n # 4. Normalise and get 6 MT:\\n # Get 6 MT:\\n DC_crack_six_MT_rotated = get_six_MT_from_full_MT_array(DC_crack_MT_rotated)\\n # And normallise so that moment tensor magnitude = 1:\\n DC_crack_six_MT_rotated_normalised = DC_crack_six_MT_rotated/((np.sum(DC_crack_six_MT_rotated**2))**0.5)\\n # And set to correct dimensions (so matrix multiplication in forward model works correctly):\\n DC_crack_six_MT_rotated_normalised = np.reshape(DC_crack_six_MT_rotated_normalised, (6, 1))\\n return DC_crack_six_MT_rotated_normalised, random_amp_frac\",\n \"def build_fully_biconnected_test_graph():\\n graph = build_biconnected_test_graph()\\n\\n # Connect the first and third components to create a ring, converting everything into a single biconnected component\\n graph.new_edge(1, 12)\\n\\n return graph\",\n \"def test_pl_to_braket_circuit():\\n dev = _aws_device(wires=2, foo=\\\"bar\\\")\\n\\n with QuantumTape() as tape:\\n qml.RX(0.2, wires=0)\\n qml.RX(0.3, wires=1)\\n qml.CNOT(wires=[0, 1])\\n qml.expval(qml.PauliZ(0))\\n\\n braket_circuit_true = (\\n Circuit()\\n .rx(0, 0.2)\\n .rx(1, 0.3)\\n .cnot(0, 1)\\n .add_result_type(result_types.Expectation(observable=Observable.Z(), target=0))\\n )\\n\\n braket_circuit = dev._pl_to_braket_circuit(tape)\\n\\n assert braket_circuit_true == braket_circuit\",\n \"def setup_ringbuffer_datastream(context):\\n\\tchan = context.create_channel(\\\"ring\\\", 5000000, 50,\\n\\t\\t\\t0, ringbuffer=True)\\n\\tenabled = {\\n\\t\\t\\\"SCHED\\\" : True,\\n\\t\\t\\\"SIGNAL_FAM\\\" : True,\\n\\t\\t\\\"SYSCALL\\\" : True,\\n\\t\\t\\\"TASKALIAS\\\": True,\\n\\t\\t\\\"DSKITRACE\\\": True\\n\\t}\\n\\tring_ds = context.create_datastream(\\\"ds_ring\\\", \\\"ring\\\")\\n\\tds.process_enabled_dict(enabled)\\n\\treturn chan\",\n \"def test_cliches_write_good_basic(self):\\n assert chk.check_cliches_write_good(\\\"\\\"\\\"No cliches here.\\\"\\\"\\\") == []\\n # use one of the example cliches to verify basic functionality\\n assert chk.check_cliches_write_good(self.l_write_good) != []\\n assert \\\"cliches.write_good\\\" in chk.check_cliches_write_good(\\n self.l_write_good)[0]\",\n \"def create_cone(base=1.0, height=1.0, lat=20, lng=20, color=COLOR_WHITE):\\n if lat >= 3 and lng >= 10:\\n circlebase = create_circle(base - 0.05, 0.1, [0.0, 0.0, -1.0], color)\\n obj = glGenLists(1)\\n glNewList(obj, GL_COMPILE)\\n glPushMatrix()\\n glColor4fv(color)\\n try:\\n glutSolidCone(base, height, lat, lng)\\n except:\\n if not _ERRS[3]:\\n printGLError(\\n \\\"la version actual de OpenGL no posee la funcion glutSolidCone\\\")\\n _ERRS[3] = True\\n glCallList(circlebase)\\n glPopMatrix()\\n glEndList()\\n return obj\\n else:\\n raise Exception(\\n \\\"La latitud y longitud de la figura deben ser mayores a 3\\\")\",\n \"def ring_forming_scission(rct_zmas, prd_zmas):\\n ret = None\\n rct_zmas, rct_gras = shifted_standard_zmas_graphs(\\n rct_zmas, remove_stereo=True)\\n prd_zmas, prd_gras = shifted_standard_zmas_graphs(\\n prd_zmas, remove_stereo=True)\\n tras, _, _ = automol.graph.reac.ring_forming_scission(rct_gras, prd_gras)\\n if tras:\\n tra = tras[0]\\n brk_bnd_key, = automol.graph.trans.broken_bond_keys(tra)\\n frm_bnd_key, = automol.graph.trans.formed_bond_keys(tra)\\n ts_zma = rct_zmas[0]\\n\\n # set up radical atom, leaving atom, newly formed radical atom\\n # also set up chain between radical atom and newly formed radical atom\\n ts_gra = automol.zmatrix.graph(ts_zma)\\n rad_atm = list(automol.graph.sing_res_dom_radical_atom_keys(ts_gra))[0]\\n for atm in brk_bnd_key:\\n if atm not in frm_bnd_key:\\n leave_atm = atm\\n else:\\n new_rad_atm = atm\\n\\n chain_between = automol.zmatrix.chain_between(ts_zma, new_rad_atm, rad_atm)\\n\\n tors_names = automol.zmatrix.torsion_coordinate_names(ts_zma)\\n coo_dct = automol.zmatrix.coordinates(ts_zma)\\n ang_90 = numpy.pi/2.\\n ts_tors_names = []\\n const_tors_names = []\\n # (i) set torsion from rad atom towards chain to 90\\n for tors_name in tors_names:\\n axis = coo_dct[tors_name][0][1:3]\\n # (ii) remove torsions in chain_between from final torsion sampling list\\n if ((axis[0] not in chain_between) or (axis[1] not in chain_between)):\\n ts_tors_names.append(tors_name)\\n if ((rad_atm == axis[0] and axis[1] in chain_between) or\\n (rad_atm == axis[1] and axis[0] in chain_between)):\\n ts_zma_p = automol.zmatrix.set_values(ts_zma, {tors_name: ang_90})\\n # const_tors_names.append(tors_name)\\n\\n # (iii) vary torsions in chain_between to minimize distance from rad_atm to new_rad_atm\\n preopt_tors_names = []\\n for tors_name in tors_names:\\n axis = coo_dct[tors_name][0][1:3]\\n if ((axis[0] in chain_between) and (axis[1] in chain_between) and\\n (rad_atm not in axis) and (new_rad_atm not in axis)):\\n preopt_tors_names.append(tors_name)\\n # add any ring forming torsions to constraints to ensure 0 dihedrals for the ring\\n const_tors_names.append(tors_name)\\n\\n angles = [0., 2.*numpy.pi/3, 4.*numpy.pi/3]\\n # angles = [0., numpy.pi/3., 2.*numpy.pi/3, 3.*numpy.pi/3., 4.*numpy.pi/3, 5*numpy.pi/3.]\\n trial_zmas = [ts_zma_p]\\n for preopt_tors_name in preopt_tors_names:\\n new_trial_zmas = []\\n for zma_i in trial_zmas:\\n for ang in angles:\\n new_trial_zmas.append(\\n automol.zmatrix.set_values(\\n zma_i, {preopt_tors_name: ang}))\\n trial_zmas = new_trial_zmas\\n\\n dist_min = 1.0e30\\n for trial_zma in trial_zmas:\\n geo_i = automol.zmatrix.geometry(trial_zma)\\n dist = automol.geom.distance(geo_i, rad_atm, new_rad_atm)\\n if dist < dist_min:\\n dist_min = dist\\n ts_zma = trial_zma\\n\\n ang_stp = 2.*numpy.pi/6.\\n # (iv) vary torsion from new_rad_atm to leaving atom so that leave_atm is far from rad_atm\\n for tors_name in tors_names:\\n ang = -ang_stp\\n axis = coo_dct[tors_name][0][1:3]\\n if ((new_rad_atm == axis[0] and axis[1] in chain_between) or\\n (new_rad_atm == axis[1] and axis[0] in chain_between)):\\n dist_max = 0.0\\n for _ in range(6):\\n ang += ang_stp\\n ts_zma_i = automol.zmatrix.set_values(ts_zma, {tors_name: ang})\\n geo_i = automol.zmatrix.geometry(ts_zma_i)\\n dist = automol.geom.distance(geo_i, rad_atm, leave_atm)\\n if dist > dist_max:\\n dist_max = dist\\n ts_zma_max = ts_zma_i\\n const_tors_names.append(tors_name)\\n # set up ts torsions - remove ones with axis in the chain between new and old rad atoms\\n if ((axis[0] not in chain_between) or (axis[1] not in chain_between)):\\n ts_tors_names.append(tors_name)\\n # elif (axis[0] in chain_between) and (axis[1] in chain_between):\\n # if tors_name not in const_tors_names:\\n # const_tors_names.append(tors_name)\\n\\n ts_zma = ts_zma_max\\n\\n # (v) vary angles to decrease rad_atm to new_rad_atm to < 2.25 Ang\\n dist_thresh = 4.25\\n # dist_thresh = 4.\\n ang_names = automol.zmatrix.central_angle_names(ts_zma)\\n ring_angs = []\\n const_angs_names = []\\n for ang_name in ang_names:\\n ang_atms = coo_dct[ang_name][0]\\n if ((ang_atms[0] in chain_between) and (ang_atms[1] in chain_between) and\\n (ang_atms[2] in chain_between)):\\n ring_angs.append(ang_name)\\n const_angs_names.append(ang_name)\\n dist = 1.e30\\n ang_stp = numpy.pi/360.\\n # ang_stp = 0.5 degrees\\n counter = 0\\n while ((dist > dist_thresh) and (counter < 30)):\\n counter += 1\\n values = automol.zmatrix.values(ts_zma)\\n for ang_name in ring_angs:\\n ang = values[ang_name] - ang_stp\\n ts_zma = automol.zmatrix.set_values(ts_zma, {ang_name: ang})\\n geo_i = automol.zmatrix.geometry(ts_zma)\\n dist = automol.geom.distance(geo_i, rad_atm, new_rad_atm)\\n\\n brk_dist_name = automol.zmatrix.bond_key_from_idxs(ts_zma, brk_bnd_key)\\n\\n # Build the reactants graph\\n rcts_gra = automol.graph.union_from_sequence(rct_gras)\\n\\n # Set the indices for the const coords\\n\\n ret = (ts_zma, brk_dist_name, brk_bnd_key,\\n tuple(const_tors_names), tuple(ts_tors_names),\\n tuple(const_angs_names), rcts_gra)\\n\\n return ret\",\n \"def prepare_circ_burn(mission):\\n vessel = mission.conn.space_center.active_vessel\\n apo_time = vessel.orbit.time_to_apoapsis\\n ap = vessel.auto_pilot\\n\\n if mission.current_step[\\\"first_call\\\"]:\\n circ_burn = compute_circ_burn(vessel)\\n circ_burn[\\\"burn_start_time\\\"] = mission.ut() + apo_time - (circ_burn[\\\"burn_time\\\"] / 2.)\\n circ_burn[\\\"node\\\"] = vessel.control.add_node(mission.ut() + apo_time,\\n prograde=circ_burn[\\\"delta_v\\\"])\\n\\n mission.parameters[\\\"circ_burn\\\"] = circ_burn\\n vessel.control.rcs = True\\n ap.engage()\\n ap.reference_frame = circ_burn[\\\"node\\\"].reference_frame\\n ap.target_direction = (0, 1, 0)\\n\\n else:\\n circ_burn = mission.parameters[\\\"circ_burn\\\"]\\n burn_ut = circ_burn[\\\"burn_start_time\\\"]\\n\\n if burn_ut < mission.ut():\\n # burn right now!\\n mission.next('execute_circ_burn')\\n\\n elif ap.error < 1 and mission.ut() - mission.current_step[\\\"start_ut\\\"] > 1:\\n lead_time = 15\\n if burn_ut > mission.ut() + lead_time * 2:\\n mission.conn.space_center.warp_to(burn_ut - lead_time)\\n mission.next()\",\n \"async def handleChannelCreate(self, channel: discord.abc.GuildChannel):\\n self.logger.info(\\n \\\"Channel creation has been detected. Name: %s, ID: %s\\\", channel.name, channel.id\\n )\\n\\n if not isinstance(channel, discord.TextChannel):\\n return\\n\\n if channel.name == AH_CHANNEL:\\n self.logger.info(\\\"%s detected, applying exceptions\\\", AH_CHANNEL)\\n ctx = await self.getContext(channel)\\n if not ctx:\\n return\\n await self.notifyChannel(ctx)\\n await self.makeHighlightChanges(ctx, channel)\\n await self.makeStarboardChanges(ctx, channel)\\n await self.makeWordFilterChanges(ctx, channel)\\n async with self.config.guild(channel.guild).get_attr(KEY_CHANNEL_IDS)() as channelIds:\\n channelIds[channel.id] = {\\\"time\\\": datetime.now().timestamp()}\",\n \"def concur_wait(self, node):\\n global BARRIER_CTR\\n\\n # This method will be destructive, unless we make a new\\n # copy of the AST tree first\\n #\\n node = deepcopy(node)\\n\\n seen_channels = set()\\n\\n # Channels in this with_concur\\n concur_channels = find_all_channels(node)\\n\\n # For creating the Barriers, we want QGL1 scoped variables that will be real channel instances.\\n # We basically have that already.\\n real_chans = set()\\n for chan in concur_channels:\\n real_chans.add(chan)\\n\\n start_barrier = BARRIER_CTR\\n end_barrier = start_barrier + 1\\n BARRIER_CTR += 2\\n\\n for stmnt in node.body:\\n if not is_seq(stmnt):\\n NodeError.error_msg(stmnt,\\n 'non-seq block inside concur block?')\\n return node\\n\\n seq_channels = find_all_channels(stmnt)\\n\\n if seq_channels.intersection(seen_channels):\\n NodeError.error_msg(stmnt,\\n 'seq blocks have overlapping channels')\\n return node\\n\\n seen_channels = seen_channels.union(seq_channels)\\n\\n chan_name = ','.join(seq_channels)\\n\\n # mark stmnt with chan_name or seq_channels in another way\\n if hasattr(stmnt, 'qgl_chan_list'):\\n oldChanSet = set(stmnt.qgl_chan_list)\\n newChanSet = seq_channels\\n oldMissing = newChanSet - oldChanSet\\n oldExtra = oldChanSet - newChanSet\\n if len(oldMissing) > 0:\\n NodeError.diag_msg(stmnt, 'marked chan list %s was missing %s' % (str(oldChanSet), str(oldMissing)))\\n if len(oldExtra) > 0:\\n NodeError.diag_msg(stmnt, 'marked chan list %s had extra %s' % (str(oldChanSet), str(oldExtra)))\\n NodeError.diag_msg(stmnt, 'Marking chan list %s' % (str(seq_channels)))\\n stmnt.qgl_chan_list = list(seq_channels)\\n\\n new_seq_body = list()\\n\\n # Helper to ensure the string we feed to AST doesn't put quotes around\\n # our Qubit variable names\\n def appendChans(bString, chans):\\n bString += '['\\n first = True\\n for chan in chans:\\n if first:\\n bString += str(chan)\\n first = False\\n else:\\n bString += \\\",\\\" + str(chan)\\n bString += ']'\\n return bString\\n\\n # Add global ctr, chanlist=concur_channels\\n # FIXME: Hold concur_channels as a string? List?\\n bstring = 'Barrier(\\\"%s\\\", ' % str(start_barrier)\\n bstring = appendChans(bstring, list(real_chans))\\n bstring += ')\\\\n'\\n barrier_ast = expr2ast(bstring)\\n # barrier_ast = expr2ast('Barrier(%s, %s)\\\\n' % (str(start_barrier), list(real_chans)))\\n copy_all_loc(barrier_ast, node)\\n barrier_ast.channels = concur_channels\\n # print(\\\"*****Start barrier: %s\\\" % pyqgl2.ast_util.ast2str(barrier_ast))\\n\\n new_seq_body.append(barrier_ast)\\n\\n new_seq_body += stmnt.body\\n\\n bstring = 'Barrier(\\\"%s\\\", ' % str(end_barrier)\\n bstring = appendChans(bstring, list(real_chans))\\n bstring += ')\\\\n'\\n end_barrier_ast = expr2ast(bstring)\\n #end_barrier_ast = expr2ast('Barrier(%s, %s)\\\\n' % (str(end_barrier), list(real_chans)))\\n copy_all_loc(end_barrier_ast, node)\\n # Add global ctr, chanlist=concur_channels\\n end_barrier_ast.channels = concur_channels\\n\\n # print('End AST: %s' % ast2str(end_barrier_ast))\\n\\n new_seq_body.append(end_barrier_ast)\\n\\n stmnt.body = new_seq_body\\n\\n # FIXME: In new thinking, is the proper unseen set the global one,\\n # Or only those local to this with concur. I think only local\\n for unseen_chan in concur_channels - seen_channels:\\n #print('DIAG %s' % ast2str(stmnt))\\n NodeError.diag_msg(stmnt,\\n 'channels unreferenced in concur: %s' % str(unseen_chan))\\n\\n bstring = 'with seq:\\\\n Barrier(\\\"%s\\\", ' % str(start_barrier)\\n bstring = appendChans(bstring, list(real_chans))\\n bstring += ')\\\\n Barrier(\\\"%s\\\",' % str(end_barrier)\\n bstring = appendChans(bstring, list(real_chans))\\n bstring += ')\\\\n'\\n empty_seq_ast = expr2ast(bstring)\\n # print('Empty AST: %s' % ast2str(empty_seq_ast))\\n # empty_seq_ast = expr2ast(\\n # 'with seq:\\\\n Barrier(%s, %s)\\\\n Barrier(%s, %s)' % (str(start_barrier), list(real_chans), str(end_barrier), list(real_chans)))\\n\\n # Mark empty_seq_ast with unseen_chan\\n empty_seq_ast.qgl_chan_list = [unseen_chan]\\n copy_all_loc(empty_seq_ast, node)\\n node.body.append(empty_seq_ast)\\n\\n return node\",\n \"def draw_housing():\\n tess.pensize(3)\\n tess.color(\\\"black\\\", \\\"darkgrey\\\")\\n tess.begin_fill()\\n tess.forward(80)\\n tess.left(90)\\n tess.forward(200)\\n tess.circle(40, 180)\\n tess.forward(200)\\n tess.left(90)\\n tess.end_fill()\\n tess.hideturtle()\",\n \"def test_state_channel_identifier_invalid(\\n token_network: Contract, get_accounts: Callable, create_channel: Callable\\n) -> None:\\n (A, B, C) = get_accounts(3)\\n channel_id = 0\\n\\n pairs = permutations([A, B, C], 2)\\n for pair in pairs:\\n state = token_network.functions.getChannelState(channel_id, *pair).call()\\n settle_block_number = token_network.functions.settleable_after(channel_id).call()\\n assert settle_block_number == 0\\n assert state == ChannelState.NONEXISTENT\\n\\n for pair in pairs:\\n create_channel(*pair)\\n state = token_network.functions.getChannelState(0, *pair).call()\\n settle_block_number = token_network.functions.settleable_after(0)\\n assert settle_block_number == 0 # initialized on channel close\\n assert state == ChannelState.OPENED\\n\\n current_counter = token_network.functions.channel_counter().call()\\n\\n for pair in pairs:\\n state = token_network.functions.getChannelState(current_counter + 1, *pair).call()\\n settle_block_number = token_network.functions.settleable_after(current_counter + 1).call()\\n assert settle_block_number == 0\\n assert state == ChannelState.NONEXISTENT\",\n \"def build_cochlear_model(tensor_waveform,\\n signal_rate=20000,\\n filter_type='half-cosine',\\n filter_spacing='erb',\\n HIGH_LIM=8000,\\n LOW_LIM=20,\\n N=40,\\n SAMPLE_FACTOR=1,\\n bandwidth_scale_factor=1.0,\\n compression='stable_point3',\\n include_highpass=False,\\n include_lowpass=False,\\n linear_max=1.0,\\n rFFT=True,\\n rectify_and_lowpass_subbands=True,\\n return_subbands_only=True,\\n **kwargs):\\n signal_length = tensor_waveform.get_shape().as_list()[-1]\\n \\n if filter_type == 'half-cosine':\\n assert HIGH_LIM <= signal_rate/2, \\\"cochlear filterbank high_lim is above Nyquist frequency\\\"\\n filts, center_freqs, freqs = make_cos_filters_nx(\\n signal_length,\\n signal_rate,\\n N,\\n LOW_LIM,\\n HIGH_LIM,\\n SAMPLE_FACTOR,\\n padding_size=None,\\n full_filter=True,\\n strict=True,\\n bandwidth_scale_factor=bandwidth_scale_factor,\\n include_lowpass=include_lowpass,\\n include_highpass=include_highpass,\\n filter_spacing=filter_spacing)\\n assert filts.shape[1] == signal_length, \\\"filter array shape must match signal length\\\"\\n else:\\n raise ValueError('Specified filter_type {} is not supported'.format(filter_type))\\n \\n coch_container = {'input_signal': tensor_waveform}\\n coch_container = cochleagram_graph(\\n coch_container,\\n signal_length,\\n signal_rate,\\n LOW_LIM=LOW_LIM,\\n HIGH_LIM=HIGH_LIM,\\n N=N,\\n SAMPLE_FACTOR=SAMPLE_FACTOR,\\n custom_filts=filts,\\n linear_max=linear_max,\\n rFFT=rFFT,\\n rectify_and_lowpass_subbands=rectify_and_lowpass_subbands,\\n return_subbands_only=return_subbands_only,\\n **kwargs)\\n \\n tensor_cochlear_representation = coch_container['output_tfcoch_graph']\\n return tensor_cochlear_representation, coch_container\",\n \"def checkRing(self, verbose = 0):\\n angleSum = self.tfs.ANGLE.sum()\\n if self.verbose: print (\\\"check\\\")\\n print (\\\"---------------------------------- \\\\n Checking, if ring is closed: \\\\n\\\", \\\"angleSum = \\\", angleSum)\\n twoPi = 2*pi\\n \\n if angleSum != twoPi:\\n fudge = 2*pi - angleSum\\n print (\\\" ** Ring not closed - offset of: \\\", fudge)\",\n \"def open_circ():\\n\\n set_mode(mode_cc) # set operation mode to CC\\n time.sleep(.250)\\n set_CC_current(cc_current=0) # set CC mode current to 0 amps\\n time.sleep(.1)\\n \\n oc_vals = get_input_values() # read open circuits levels\\n oc_data_point = data_point(oc_vals) # create data point for open circuit measurement\\n voc = oc_data_point[3] # open circuit voltage measurement\\n print('Open circuit voltage: ', voc)\\n write_data_tofile(oc_data_point) # write data to file\\n \\n return voc\",\n \"def CascadeLlhVertexFit(tray, name, CascadeLlh, Pulses='TWNFEMergedPulses', If=lambda frame: True):\\r\\n\\ticetray.load('clast', False)\\r\\n\\ticetray.load('cscd-llh', False)\\r\\n\\t\\r\\n\\t# Settings from std-processing/releases/11-02-00/scripts/IC79/level2_DoCascadeReco.py\\r\\n\\tCscdLlhVertexFitter = icetray.module_altconfig('I3CscdLlhModule',\\r\\n\\tInputType='RecoPulse', MinHits=5,\\r\\n\\tMinimizer='Powell', PDF='UPandel',\\r\\n\\tParamT='1.0, 0.0, 0.0, false',\\r\\n\\tParamX='1.0, 0.0, 0.0, false',\\r\\n\\tParamY='1.0, 0.0, 0.0, false',\\r\\n\\tParamZ='1.0, 0.0, 0.0, false',\\r\\n\\t)\\r\\n\\r\\n\\tseed = name + '_CLastSeed'\\r\\n\\ttray.AddModule('I3CLastModule', name+'Clast',\\r\\n\\t Name=seed, InputReadout=Pulses, If=If, MinHits=5)\\r\\n\\tif CascadeLlh:\\r\\n\\t\\ttray.AddSegment(CscdLlhVertexFitter, name+'CscdLlh',\\r\\n\\t\\t\\tRecoSeries=Pulses, SeedKey=seed,\\r\\n\\t\\t\\tResultName=name+\\\"_CscdLlh\\\", If=If\\r\\n\\t)\\r\\n\\t\\r\\n\\treturn [seed, seed+'Params', name, name+'Params']\",\n \"def is_ring(self): # -> bool:\\n ...\",\n \"def make_shape_ccw(self):\\n\\n if not(self.closed):\\n return\\n\\n # Optimization for closed shapes\\n # Start value for the first sum\\n\\n if self.isDirectionOfGeosCCW(self.geos):\\n self.reverse()\\n logger.debug(self.tr(\\\"Had to reverse the shape to be CW\\\"))\\n self.cw = True\",\n \"def add_rand_circ() -> int:\\n r = randint(10, 100)\\n x = randint(r, WIDTH - r)\\n y = randint(r, HEIGHT - r)\\n vx = randint(-10, 10)\\n vy = randint(-10, 10)\\n color = COLORS[randint(0, len(COLORS) - 1)]\\n add_circ(x, y, r, vx, vy, color, int(100 / r))\\n return 0\",\n \"def gen_chip(cfpath, gfpath, bbox, theta, new_size, filter_list=[]):\\n chipBGR = ctool.compute_chip(gfpath, bbox, theta, new_size, filter_list)\\n return chipBGR, cfpath\",\n \"def bend_s(\\n size: Float2 = (10.0, 2.0),\\n nb_points: int = 99,\\n with_cladding_box: bool = True,\\n cross_section: CrossSectionFactory = strip,\\n **kwargs\\n) -> Component:\\n dx, dy = size\\n x = cross_section(**kwargs)\\n width = x.info[\\\"width\\\"]\\n layer = x.info[\\\"layer\\\"]\\n\\n c = Component()\\n\\n bend = bezier(\\n width=width,\\n control_points=[(0, 0), (dx / 2, 0), (dx / 2, dy), (dx, dy)],\\n npoints=nb_points,\\n layer=layer,\\n )\\n\\n bend_ref = c << bend\\n c.add_ports(bend_ref.ports)\\n c.copy_child_info(bend)\\n c.info[\\\"start_angle\\\"] = bend.info[\\\"start_angle\\\"]\\n c.info[\\\"end_angle\\\"] = bend.info[\\\"end_angle\\\"]\\n c.info[\\\"length\\\"] = bend.info[\\\"length\\\"]\\n c.info[\\\"min_bend_radius\\\"] = bend.info[\\\"min_bend_radius\\\"]\\n\\n if with_cladding_box and x.info[\\\"layers_cladding\\\"]:\\n layers_cladding = x.info[\\\"layers_cladding\\\"]\\n cladding_offset = x.info[\\\"cladding_offset\\\"]\\n points = get_padding_points(\\n component=c,\\n default=0,\\n bottom=cladding_offset,\\n top=cladding_offset,\\n )\\n for layer in layers_cladding or []:\\n c.add_polygon(points, layer=layer)\\n\\n auto_rename_ports(c)\\n return c\",\n \"def polyPlatonicSolid(*args, axis: Union[List[float, float, float], bool]=None, caching:\\n bool=True, constructionHistory: bool=True, createUVs: int=4, name:\\n AnyStr=\\\"\\\", nodeState: Union[int, bool]=0, object: bool=True, radius:\\n Union[float, bool]=1.0, sideLength: Union[float, bool]=1.0, solidType:\\n int=0, texture: int=0, q=True, query=True, e=True, edit=True,\\n **kwargs)->Union[List[AnyStr], Any]:\\n pass\",\n \"def __make_carriage(self):\\n # Create base rectangle\\n length = self.parameters['carriage_length']\\n width = self.parameters['carriage_width']\\n height = self.parameters['carriage_height']\\n carriage = fso.Box(x=length, y=width, z=height)\\n\\n # Subtract slide from carraige\\n slide_width = self.parameters['slide_width'] + 2*self.parameters['slide_tolerance']\\n slide_height = self.parameters['slide_height'] + 2*self.parameters['slide_tolerance']\\n slide_negative = fso.Box(x=2*length, y=slide_width, z=slide_height)\\n carriage = carriage - slide_negative\\n\\n # Create mounting holes\\n radius = 0.5*self.parameters['carriage_screw_size']\\n base_hole = fso.Cylinder(r=radius,l=2*height)\\n hole_list = []\\n for i in (-1,1):\\n for j in (-1,1):\\n xpos = i*0.5*self.parameters['carriage_screw_dL']\\n ypos = j*0.5*self.parameters['carriage_screw_dW']\\n hole = base_hole.copy()\\n hole.translate([xpos,ypos,0])\\n hole_list.append(hole)\\n # Remove hole material\\n # print hole_list\\n carriage -= hole_list\\n carriage.set_color(self.carriage_color,recursive=True)\\n self.carriage = carriage\",\n \"def ring_is_clockwise(ring):\\n total = 0\\n for (pt1, pt2) in pairwise(ring):\\n total += (pt2[0] - pt1[0]) * (pt2[1] + pt1[1])\\n return total >= 0\",\n \"def run(self, verbose=False, build_graph=False):\\n from sage.combinat.crystals.letters import CrystalOfLetters\\n letters = CrystalOfLetters(self.rigged_con.parent()._cartan_type.classical())\\n\\n # This is technically bad, but because the first thing we do is append\\n # an empty list to ret_crystal_path, we correct this. We do it this\\n # way so that we do not have to remove an empty list after the\\n # bijection has been performed.\\n ret_crystal_path = []\\n\\n for dim in self.rigged_con.parent().dims:\\n ret_crystal_path.append([])\\n\\n # Check to see if we are a spinor\\n if dim[0] == self.n:\\n # Perform the spinor bijection by converting to type A_{2n-1}^{(2)}\\n # doing the bijection there and pulling back\\n\\n from sage.combinat.rigged_configurations.bij_type_A2_odd import RCToKRTBijectionTypeA2Odd\\n from sage.combinat.rigged_configurations.rigged_configurations import RiggedConfigurations\\n from sage.combinat.rigged_configurations.rigged_partition import RiggedPartition, RiggedPartitionTypeB\\n \\n # Convert to a type A_{2n-1}^{(2)} RC\\n RC = RiggedConfigurations(['A', 2*self.n-1, 2], self.cur_dims)\\n if verbose:\\n print(\\\"====================\\\")\\n print(repr(RC(*self.cur_partitions, use_vacancy_numbers=True)))\\n print(\\\"--------------------\\\")\\n print(ret_crystal_path)\\n print(\\\"--------------------\\\\n\\\")\\n print(\\\"Applying doubling map\\\\n\\\")\\n # Convert the n-th partition into a regular rigged partition\\n self.cur_partitions[-1] = RiggedPartition(self.cur_partitions[-1]._list,\\n self.cur_partitions[-1].rigging,\\n self.cur_partitions[-1].vacancy_numbers)\\n\\n bij = RCToKRTBijectionTypeA2Odd(RC(*self.cur_partitions, use_vacancy_numbers=True))\\n for i in range(len(self.cur_dims)):\\n if bij.cur_dims[i][0] != self.n:\\n bij.cur_dims[i][1] *= 2\\n for i in range(self.n-1):\\n for j in range(len(bij.cur_partitions[i])):\\n bij.cur_partitions[i]._list[j] *= 2\\n bij.cur_partitions[i].rigging[j] *= 2\\n bij.cur_partitions[i].vacancy_numbers[j] *= 2\\n\\n if build_graph:\\n y = self.rigged_con.parent()(*[x._clone() for x in self.cur_partitions], use_vacancy_numbers=True)\\n self._graph.append([self._graph[-1][1], (y, len(self._graph)), '2x'])\\n \\n # Perform the type A_{2n-1}^{(2)} bijection\\n \\n # Iterate over each column\\n for dummy_var in range(dim[1]):\\n # Split off a new column if necessary\\n if bij.cur_dims[0][1] > 1:\\n bij.cur_dims[0][1] -= 1\\n bij.cur_dims.insert(0, [dim[0], 1])\\n \\n # Perform the corresponding splitting map on rigged configurations\\n # All it does is update the vacancy numbers on the RC side\\n for a in range(self.n):\\n bij._update_vacancy_numbers(a)\\n\\n if build_graph:\\n y = self.rigged_con.parent()(*[x._clone() for x in self.cur_partitions], use_vacancy_numbers=True)\\n self._graph.append([self._graph[-1][1], (y, len(self._graph)), 'ls'])\\n \\n while bij.cur_dims[0][0] > 0:\\n if verbose:\\n print(\\\"====================\\\")\\n print(repr(RC(*bij.cur_partitions, use_vacancy_numbers=True)))\\n print(\\\"--------------------\\\")\\n print(ret_crystal_path)\\n print(\\\"--------------------\\\\n\\\")\\n\\n bij.cur_dims[0][0] -= 1 # This takes care of the indexing\\n b = bij.next_state(bij.cur_dims[0][0])\\n # Make sure we have a crystal letter\\n ret_crystal_path[-1].append(letters(b)) # Append the rank\\n\\n if build_graph:\\n y = self.rigged_con.parent()(*[x._clone() for x in self.cur_partitions], use_vacancy_numbers=True)\\n self._graph.append([self._graph[-1][1], (y, len(self._graph)), letters(b)])\\n\\n bij.cur_dims.pop(0) # Pop off the leading column\\n\\n self.cur_dims.pop(0) # Pop off the spin rectangle\\n\\n self.cur_partitions = bij.cur_partitions\\n # Convert the n-th partition back into the special type B one\\n self.cur_partitions[-1] = RiggedPartitionTypeB(self.cur_partitions[-1])\\n\\n # Convert back to a type B_n^{(1)}\\n if verbose:\\n print(\\\"====================\\\")\\n print(repr(self.rigged_con.parent()(*bij.cur_partitions, use_vacancy_numbers=True)))\\n print(\\\"--------------------\\\")\\n print(ret_crystal_path)\\n print(\\\"--------------------\\\\n\\\")\\n print(\\\"Applying halving map\\\\n\\\")\\n\\n for i in range(self.n-1):\\n for j in range(len(self.cur_partitions[i])):\\n self.cur_partitions[i]._list[j] //= 2\\n self.cur_partitions[i].rigging[j] //= 2\\n self.cur_partitions[i].vacancy_numbers[j] //= 2\\n\\n if build_graph:\\n y = self.rigged_con.parent()(*[x._clone() for x in self.cur_partitions], use_vacancy_numbers=True)\\n self._graph.append([self._graph[-1][1], (y, len(self._graph)), '1/2x'])\\n else:\\n # Perform the regular type B_n^{(1)} bijection\\n\\n # Iterate over each column\\n for dummy_var in range(dim[1]):\\n # Split off a new column if necessary\\n if self.cur_dims[0][1] > 1:\\n if verbose:\\n print(\\\"====================\\\")\\n print(repr(self.rigged_con.parent()(*self.cur_partitions, use_vacancy_numbers=True)))\\n print(\\\"--------------------\\\")\\n print(ret_crystal_path)\\n print(\\\"--------------------\\\\n\\\")\\n print(\\\"Applying column split\\\")\\n\\n self.cur_dims[0][1] -= 1\\n self.cur_dims.insert(0, [dim[0], 1])\\n\\n # Perform the corresponding splitting map on rigged configurations\\n # All it does is update the vacancy numbers on the RC side\\n for a in range(self.n):\\n self._update_vacancy_numbers(a)\\n\\n if build_graph:\\n y = self.rigged_con.parent()(*[x._clone() for x in self.cur_partitions], use_vacancy_numbers=True)\\n self._graph.append([self._graph[-1][1], (y, len(self._graph)), '2x'])\\n\\n while self.cur_dims[0][0] > 0:\\n if verbose:\\n print(\\\"====================\\\")\\n print(repr(self.rigged_con.parent()(*self.cur_partitions, use_vacancy_numbers=True)))\\n print(\\\"--------------------\\\")\\n print(ret_crystal_path)\\n print(\\\"--------------------\\\\n\\\")\\n\\n self.cur_dims[0][0] -= 1 # This takes care of the indexing\\n b = self.next_state(self.cur_dims[0][0])\\n\\n # Make sure we have a crystal letter\\n ret_crystal_path[-1].append(letters(b)) # Append the rank\\n\\n if build_graph:\\n y = self.rigged_con.parent()(*[x._clone() for x in self.cur_partitions], use_vacancy_numbers=True)\\n self._graph.append([self._graph[-1][1], (y, len(self._graph)), letters(b)])\\n\\n self.cur_dims.pop(0) # Pop off the leading column\\n\\n if build_graph:\\n self._graph.pop(0) # Remove the dummy at the start\\n from sage.graphs.digraph import DiGraph\\n from sage.graphs.dot2tex_utils import have_dot2tex\\n self._graph = DiGraph(self._graph)\\n if have_dot2tex():\\n self._graph.set_latex_options(format=\\\"dot2tex\\\", edge_labels=True)\\n\\n return self.KRT(pathlist=ret_crystal_path)\",\n \"def _constructArc(self, a, b, c):\\n arc = pcbnew.PCB_SHAPE()\\n arc.SetShape(STROKE_T.S_ARC)\\n arc.SetLayer(Layer.Edge_Cuts)\\n arc.SetArcGeometry(toKiCADPoint(a), toKiCADPoint(b), toKiCADPoint(c))\\n return arc\",\n \"def _small_circuit():\\n qr = QuantumRegister(1, name='qr')\\n cr = ClassicalRegister(1, name='cr')\\n circuit = QuantumCircuit(qr, cr)\\n\\n circuit.x(qr[0])\\n circuit.barrier(qr[0])\\n circuit.measure(qr, cr)\\n\\n return circuit\",\n \"def CheckClearance(self, via, area, clearance):\\r\\n p1 = via.GetPosition()\\r\\n corners = area.GetNumCorners()\\r\\n # Calculate minimum distance from corners\\r\\n # TODO: remove?\\r\\n for i in range(corners):\\r\\n corner = area.GetCornerPosition(i)\\r\\n p2 = corner.getWxPoint()\\r\\n the_distance = norm(p2 - p1) # sqrt((p2.x - p1.x) ** 2 + (p2.y - p1.y) ** 2)\\r\\n\\r\\n if the_distance < clearance:\\r\\n return False\\r\\n\\r\\n for i in range(corners):\\r\\n corner1 = area.GetCornerPosition(i)\\r\\n corner2 = area.GetCornerPosition((i + 1) % corners)\\r\\n pc1 = corner1.getWxPoint()\\r\\n pc2 = corner2.getWxPoint()\\r\\n the_distance, _ = pnt2line(p1, pc1, pc2)\\r\\n\\r\\n if the_distance <= clearance:\\r\\n return False\\r\\n\\r\\n for edge in self.board_edges:\\r\\n if edge.ShowShape() == 'Line':\\r\\n the_distance, _ = pnt2line(p1, edge.GetStart(), edge.GetEnd())\\r\\n if the_distance <= clearance + via.GetWidth() / 2:\\r\\n return False\\r\\n if edge.ShowShape() == 'Arc':\\r\\n # distance from center of Arc and with angle within Arc angle should be outside Arc radius +- clearance + via Width/2\\r\\n center = edge.GetPosition()\\r\\n start = edge.GetStart()\\r\\n end = edge.GetEnd()\\r\\n radius = norm(center - end)\\r\\n dist = norm(p1 - center)\\r\\n if radius - (self.clearance + via.GetWidth() / 2) < dist < radius + (\\r\\n self.clearance + via.GetWidth() / 2):\\r\\n # via is in range need to check the angle\\r\\n start_angle = math.atan2((start - center).y, (start - center).x)\\r\\n end_angle = math.atan2((end - center).y, (end - center).x)\\r\\n if end_angle < start_angle:\\r\\n end_angle += 2 * math.pi\\r\\n point_angle = math.atan2((p1 - center).y, (p1 - center).x)\\r\\n if start_angle <= point_angle <= end_angle:\\r\\n return False\\r\\n\\r\\n return True\",\n \"def add_carboxyl(atom, atom_list, added_functional_groups, ct):\\n \\n global anywhere_map\\n global edge_map\\n current_size = len(atom_list)\\n placed = 0\\n alpha = random.randint(0,359)\\n x = atom.x\\n y = atom.y\\n z = atom.z\\n while (placed <= 359):\\n alpha += 1\\n carbon_atom = Atom(current_size + 1, 'C4', 'C1A', str(added_functional_groups + 1), float(\\\"{0:.3f}\\\".format(x)), float(\\\"{0:.3f}\\\".format(y)), float(\\\"{0:.3f}\\\".format(ct * 1.52 + z)))\\n atom_list.append(carbon_atom)\\n if ((len(identify_bonds(carbon_atom, atom_list)) == 1) and (identify_bonds(carbon_atom, atom_list)[0][0].atom_number == atom.atom_number)):\\n h = math.sin(math.radians(60)) * 1.20\\n oxygen_atom_1 = Atom(current_size + 2, 'OJ', 'C1A', str(added_functional_groups + 1), float(\\\"{0:.3f}\\\".format(carbon_atom.x - math.cos(math.radians(alpha)) * h)), float(\\\"{0:.3f}\\\".format(carbon_atom.y - math.sin(math.radians(alpha)) * h)), float(\\\"{0:.3f}\\\".format(carbon_atom.z + ct * math.cos(math.radians(60)) * 1.20)))\\n atom_list.append(oxygen_atom_1)\\n if ((len(identify_bonds(oxygen_atom_1, atom_list)) == 1) and (identify_bonds(oxygen_atom_1, atom_list)[0][0].atom_number == carbon_atom.atom_number)):\\n h = math.sin(math.radians(60)) * 1.34\\n oxygen_atom_2 = Atom(current_size + 3, 'OK', 'C1A', str(added_functional_groups + 1), float(\\\"{0:.3f}\\\".format(carbon_atom.x - math.cos(math.radians(alpha + 180)) * h)), float(\\\"{0:.3f}\\\".format(carbon_atom.y - math.sin(math.radians(alpha+180)) * h)), float(\\\"{0:.3f}\\\".format(carbon_atom.z + ct * math.cos(math.radians(60)) * 1.34)) )\\n atom_list.append(oxygen_atom_2)\\n if ((len(identify_bonds(oxygen_atom_2, atom_list)) == 1) and (identify_bonds(oxygen_atom_2, atom_list)[0][0].atom_number == carbon_atom.atom_number)):\\n hydrogen_atom = Atom(current_size + 4, 'HK', 'C1A', str(added_functional_groups + 1), float(\\\"{0:.3f}\\\".format(oxygen_atom_2.x)), float(\\\"{0:.3f}\\\".format(oxygen_atom_2.y)), float(\\\"{0:.3f}\\\".format(oxygen_atom_2.z+ct*0.98)))\\n atom_list.append(hydrogen_atom)\\n if ((len(identify_bonds(hydrogen_atom, atom_list)) == 1) and (identify_bonds(hydrogen_atom, atom_list)[0][0].atom_number == oxygen_atom_2.atom_number)):\\n placed = 888\\n if atom in edge_map: edge_map.remove(atom)\\n if atom in anywhere_map: anywhere_map.remove(atom)\\n CY = Atom(atom.atom_number, 'CY', 'C1A', carbon_atom.residue_number, atom.x, atom.y, atom.z)\\n atom_list.append(CY)\\n atom_list.remove(atom)\\n del atom\\n else:\\n placed += 5\\n del hydrogen_atom\\n del atom_list[current_size + 3]\\n del oxygen_atom_2\\n del atom_list[current_size + 2]\\n del oxygen_atom_1\\n del atom_list[current_size + 1]\\n del carbon_atom\\n del atom_list[current_size + 0]\\n else:\\n placed += 5\\n del oxygen_atom_2\\n del atom_list[current_size + 2]\\n del oxygen_atom_1\\n del atom_list[current_size + 1]\\n del carbon_atom\\n del atom_list[current_size + 0]\\n else:\\n placed += 5\\n del oxygen_atom_1\\n del atom_list[current_size + 1]\\n del carbon_atom\\n del atom_list[current_size + 0]\\n else:\\n placed += 5\\n del carbon_atom \\n del atom_list[current_size + 0]\\n return atom_list\",\n \"def create_rink():\\n\\n # RINK\\n coords = OFFSET, OFFSET, OFFSET+22*SCALE, OFFSET+22*SCALE\\n canvas.create_arc(coords, start=90, extent=90, fill=WHITE, outline=\\\"\\\")\\n coords = OFFSET, HEIGHT-OFFSET-22*SCALE, OFFSET+22*SCALE, HEIGHT-OFFSET\\n canvas.create_arc(coords, start=180, extent=90, fill=WHITE, outline=WHITE)\\n coords = WIDTH-OFFSET-22*SCALE, HEIGHT-OFFSET-22*SCALE, WIDTH-OFFSET, HEIGHT-OFFSET\\n canvas.create_arc(coords, start=270, extent=90, fill=WHITE, outline=WHITE)\\n coords = WIDTH-OFFSET-22*SCALE, OFFSET, WIDTH-OFFSET, OFFSET+22*SCALE\\n canvas.create_arc(coords, start=0, extent=90, fill=WHITE, outline=WHITE)\\n coords = OFFSET+11*SCALE, OFFSET, WIDTH-OFFSET-11*SCALE, OFFSET, WIDTH-OFFSET-11*SCALE, HEIGHT-OFFSET, OFFSET+11*SCALE, HEIGHT-OFFSET\\n canvas.create_polygon(coords, fill=WHITE, outline=WHITE)\\n coords = OFFSET, OFFSET+11*SCALE, WIDTH-OFFSET, OFFSET+11*SCALE, WIDTH-OFFSET, HEIGHT-OFFSET-11*SCALE, OFFSET, HEIGHT-OFFSET-11*SCALE\\n canvas.create_polygon(coords, fill=WHITE, outline=WHITE)\\n\\n # CENTER CIRCLE\\n coords = WIDTH/2-15*SCALE, HEIGHT/2-15*SCALE, WIDTH/2+15*SCALE, HEIGHT/2+15*SCALE\\n canvas.create_oval(coords, outline=BLUE, width=2, fill=WHITE)\\n\\n # HALF CENTER CIRCLE\\n coords = WIDTH/2-10*SCALE, HEIGHT-OFFSET-10*SCALE, WIDTH/2+10*SCALE, HEIGHT-OFFSET+10*SCALE\\n canvas.create_arc(coords, outline=RED, width=2, start=0, extent=180)\\n\\n # GOAL AREA\\n # - Left\\n # - - Crease\\n coords = OFFSET+5*SCALE, HEIGHT/2-6*SCALE, OFFSET+17*SCALE, HEIGHT/2+6*SCALE\\n canvas.create_arc(coords, fill=LIGHT_BLUE, start=318, extent=84, outline=\\\"\\\")\\n canvas.create_arc(coords, outline=RED, start=318, extent=84, style=ARC)\\n coords = OFFSET+11*SCALE, HEIGHT/2-4*SCALE, OFFSET+15.5*SCALE, HEIGHT/2-4*SCALE, OFFSET+15.5*SCALE, HEIGHT/2+4*SCALE, OFFSET+11*SCALE, HEIGHT/2+4*SCALE\\n canvas.create_polygon(coords, fill=LIGHT_BLUE, outline=\\\"\\\")\\n coords = OFFSET+11*SCALE, HEIGHT/2-4*SCALE, OFFSET+15.2*SCALE+1, HEIGHT/2-4*SCALE\\n canvas.create_line(coords, fill=RED)\\n coords = OFFSET+15.2*SCALE+1, HEIGHT/2+4*SCALE, OFFSET+11*SCALE, HEIGHT/2+4*SCALE\\n canvas.create_line(coords, fill=RED)\\n # - - Restricted Area\\n coords = OFFSET, HEIGHT/2-14*SCALE, OFFSET+11*SCALE, HEIGHT/2-9*SCALE\\n canvas.create_line(coords, fill=RED)\\n coords = OFFSET, HEIGHT/2+14*SCALE, OFFSET+11*SCALE, HEIGHT/2+9*SCALE\\n canvas.create_line(coords, fill=RED)\\n # - - Goal\\n coords = OFFSET+8*SCALE, HEIGHT/2-3*SCALE, OFFSET+11*SCALE, HEIGHT/2-3*SCALE, OFFSET+11*SCALE, HEIGHT/2+3*SCALE, OFFSET+8*SCALE, HEIGHT/2+3*SCALE\\n canvas.create_polygon(coords, fill=GRAY, outline=RED)\\n # - Right\\n # - - Crease\\n coords = WIDTH-(OFFSET+5*SCALE), HEIGHT/2-6*SCALE, WIDTH-(OFFSET+17*SCALE), HEIGHT/2+6*SCALE\\n canvas.create_arc(coords, fill=LIGHT_BLUE, start=138, extent=84, outline=\\\"\\\")\\n canvas.create_arc(coords, outline=RED, start=138, extent=84, style=ARC)\\n coords = WIDTH-(OFFSET+11*SCALE), HEIGHT/2-4*SCALE, WIDTH-(OFFSET+15.5*SCALE), HEIGHT/2-4*SCALE, WIDTH-(OFFSET+15.5*SCALE), HEIGHT/2+4*SCALE, WIDTH-(OFFSET+11*SCALE), HEIGHT/2+4*SCALE\\n canvas.create_polygon(coords, fill=LIGHT_BLUE, outline=\\\"\\\")\\n coords = WIDTH-(OFFSET+11*SCALE), HEIGHT/2-4*SCALE, WIDTH-(OFFSET+15.2*SCALE+1), HEIGHT/2-4*SCALE\\n canvas.create_line(coords, fill=RED)\\n coords = WIDTH-(OFFSET+15.2*SCALE+1), HEIGHT/2+4*SCALE, WIDTH-(OFFSET+11*SCALE), HEIGHT/2+4*SCALE\\n canvas.create_line(coords, fill=RED)\\n # - - Restricted Area\\n coords = WIDTH-OFFSET, HEIGHT/2-14*SCALE, WIDTH-OFFSET-11*SCALE, HEIGHT/2-9*SCALE\\n canvas.create_line(coords, fill=RED)\\n coords = WIDTH-OFFSET, HEIGHT/2+14*SCALE, WIDTH-OFFSET-11*SCALE, HEIGHT/2+9*SCALE\\n canvas.create_line(coords, fill=RED)\\n # - - Goal\\n coords = WIDTH-(OFFSET+8*SCALE), HEIGHT/2-3*SCALE, WIDTH-(OFFSET+11*SCALE), HEIGHT/2-3*SCALE, WIDTH-(OFFSET+11*SCALE), HEIGHT/2+3*SCALE, WIDTH-(OFFSET+8*SCALE), HEIGHT/2+3*SCALE\\n canvas.create_polygon(coords, fill=GRAY, outline=RED)\\n\\n # LINES\\n # - Left Baseline\\n coords = OFFSET+11*SCALE, OFFSET, OFFSET+11*SCALE, HEIGHT-OFFSET\\n canvas.create_line(coords, fill=RED, width=1.5)\\n # - Right Baseline\\n coords = WIDTH-OFFSET-11*SCALE, OFFSET, WIDTH-OFFSET-11*SCALE, HEIGHT-OFFSET\\n canvas.create_line(coords, fill=RED, width=1.5)\\n # - Left Blueline\\n coords = OFFSET+70*SCALE, OFFSET, OFFSET+70*SCALE, HEIGHT-OFFSET\\n canvas.create_line(coords, fill=BLUE, width=7)\\n # - Right Blueline\\n coords = WIDTH-(OFFSET+70*SCALE), OFFSET, WIDTH-(OFFSET+70*SCALE), HEIGHT-OFFSET\\n canvas.create_line(coords, fill=BLUE, width=7)\\n # - Redline\\n coords = WIDTH/2, OFFSET, WIDTH/2, HEIGHT-OFFSET\\n canvas.create_line(coords, fill=RED, width=7)\\n coords = WIDTH/2, OFFSET, WIDTH/2, HEIGHT-OFFSET\\n canvas.create_line(coords, fill=WHITE, width=5, dash=(9,9))\\n\\n # RINK OUTLINE\\n coords = OFFSET, OFFSET, OFFSET+22*SCALE, OFFSET+22*SCALE\\n canvas.create_arc(coords, start=90, extent=90, outline=BLACK, style=ARC, width=2)\\n coords = OFFSET, HEIGHT-OFFSET-22*SCALE, OFFSET+22*SCALE, HEIGHT-OFFSET\\n canvas.create_arc(coords, start=180, extent=90, outline=BLACK, style=ARC, width=2)\\n coords = WIDTH-OFFSET-22*SCALE, HEIGHT-OFFSET-22*SCALE, WIDTH-OFFSET, HEIGHT-OFFSET\\n canvas.create_arc(coords, start=270, extent=90, outline=BLACK, style=ARC, width=2)\\n coords = WIDTH-OFFSET-22*SCALE, OFFSET, WIDTH-OFFSET, OFFSET+22*SCALE\\n canvas.create_arc(coords, start=0, extent=90, outline=BLACK, style=ARC, width=2)\\n coords = OFFSET+11*SCALE, OFFSET, WIDTH-OFFSET-11*SCALE, OFFSET\\n canvas.create_line(coords, fill=BLACK, width=2)\\n coords = WIDTH-OFFSET, OFFSET+11*SCALE, WIDTH-OFFSET, HEIGHT-OFFSET-11*SCALE\\n canvas.create_line(coords, fill=BLACK, width=2)\\n coords = WIDTH-OFFSET-11*SCALE, HEIGHT-OFFSET, OFFSET+11*SCALE, HEIGHT-OFFSET\\n canvas.create_line(coords, fill=BLACK, width=2)\\n coords = OFFSET, OFFSET+11*SCALE, OFFSET, HEIGHT-OFFSET-11*SCALE\\n canvas.create_line(coords, fill=BLACK, width=2)\\n\\n\\n # CENTER DOT\\n coords = WIDTH/2-1*SCALE-1, HEIGHT/2-1*SCALE-1, WIDTH/2+1*SCALE+1, HEIGHT/2+1*SCALE+1\\n canvas.create_oval(coords, outline=WHITE, fill=BLUE)\\n\\n # FACEOFF\\n # - Top Left\\n # - - Ticks\\n coords = OFFSET+29.5*SCALE, HEIGHT/2-39*SCALE, OFFSET+29.5*SCALE, HEIGHT/2-5*SCALE\\n canvas.create_line(coords, fill=RED, width=2)\\n coords = OFFSET+32.5*SCALE, HEIGHT/2-39*SCALE, OFFSET+32.5*SCALE, HEIGHT/2-5*SCALE\\n canvas.create_line(coords, fill=RED, width=2)\\n # - - Circles\\n coords = OFFSET+16*SCALE, HEIGHT/2-37*SCALE, OFFSET+46*SCALE, HEIGHT/2-7*SCALE\\n canvas.create_oval(coords, outline=RED, width=2, fill=WHITE)\\n coords = OFFSET+30*SCALE, HEIGHT/2-23*SCALE, OFFSET+32*SCALE, HEIGHT/2-21*SCALE\\n canvas.create_oval(coords, fill=RED, outline=\\\"\\\")\\n # - - Cross\\n coords = OFFSET+25*SCALE, HEIGHT/2-22.8*SCALE, OFFSET+29*SCALE, HEIGHT/2-22.8*SCALE, OFFSET+29*SCALE, HEIGHT/2-25.8*SCALE\\n canvas.create_line(coords, fill=RED, width=2)\\n coords = OFFSET+25*SCALE, HEIGHT/2-21.2*SCALE, OFFSET+29*SCALE, HEIGHT/2-21.2*SCALE, OFFSET+29*SCALE, HEIGHT/2-18.2*SCALE\\n canvas.create_line(coords, fill=RED, width=2)\\n coords = OFFSET+37*SCALE, HEIGHT/2-22.8*SCALE, OFFSET+33*SCALE, HEIGHT/2-22.8*SCALE, OFFSET+33*SCALE, HEIGHT/2-25.8*SCALE\\n canvas.create_line(coords, fill=RED, width=2)\\n coords = OFFSET+37*SCALE, HEIGHT/2-21.2*SCALE, OFFSET+33*SCALE, HEIGHT/2-21.2*SCALE, OFFSET+33*SCALE, HEIGHT/2-18.2*SCALE\\n canvas.create_line(coords, fill=RED, width=2)\\n # - Bottom Left\\n # - - Ticks\\n coords = OFFSET+29.5*SCALE, HEIGHT/2+39*SCALE, OFFSET+29.5*SCALE, HEIGHT/2+5*SCALE\\n canvas.create_line(coords, fill=RED, width=2)\\n coords = OFFSET+32.5*SCALE, HEIGHT/2+39*SCALE, OFFSET+32.5*SCALE, HEIGHT/2+5*SCALE\\n canvas.create_line(coords, fill=RED, width=2)\\n # - - Circles\\n coords = OFFSET+16*SCALE, HEIGHT/2+37*SCALE, OFFSET+46*SCALE, HEIGHT/2+7*SCALE\\n canvas.create_oval(coords, outline=RED, width=2, fill=WHITE)\\n coords = OFFSET+30*SCALE, HEIGHT/2+23*SCALE, OFFSET+32*SCALE, HEIGHT/2+21*SCALE\\n canvas.create_oval(coords, fill=RED, outline=\\\"\\\")\\n # - - Cross\\n coords = OFFSET+25*SCALE, HEIGHT/2+22.8*SCALE, OFFSET+29*SCALE, HEIGHT/2+22.8*SCALE, OFFSET+29*SCALE, HEIGHT/2+25.8*SCALE\\n canvas.create_line(coords, fill=RED, width=2)\\n coords = OFFSET+25*SCALE, HEIGHT/2+21.2*SCALE, OFFSET+29*SCALE, HEIGHT/2+21.2*SCALE, OFFSET+29*SCALE, HEIGHT/2+18.2*SCALE\\n canvas.create_line(coords, fill=RED, width=2)\\n coords = OFFSET+37*SCALE, HEIGHT/2+22.8*SCALE, OFFSET+33*SCALE, HEIGHT/2+22.8*SCALE, OFFSET+33*SCALE, HEIGHT/2+25.8*SCALE\\n canvas.create_line(coords, fill=RED, width=2)\\n coords = OFFSET+37*SCALE, HEIGHT/2+21.2*SCALE, OFFSET+33*SCALE, HEIGHT/2+21.2*SCALE, OFFSET+33*SCALE, HEIGHT/2+18.2*SCALE\\n canvas.create_line(coords, fill=RED, width=2)\\n # - Top Right\\n # - - Ticks\\n coords = WIDTH-(OFFSET+29.5*SCALE), HEIGHT/2-39*SCALE, WIDTH-(OFFSET+29.5*SCALE), HEIGHT/2-5*SCALE\\n canvas.create_line(coords, fill=RED, width=2)\\n coords = WIDTH-(OFFSET+32.5*SCALE), HEIGHT/2-39*SCALE, WIDTH-(OFFSET+32.5*SCALE), HEIGHT/2-5*SCALE\\n canvas.create_line(coords, fill=RED, width=2)\\n # - - Circles\\n coords = WIDTH-(OFFSET+16*SCALE), HEIGHT/2-37*SCALE, WIDTH-(OFFSET+46*SCALE), HEIGHT/2-7*SCALE\\n canvas.create_oval(coords, outline=RED, width=2, fill=WHITE)\\n coords = WIDTH-(OFFSET+30*SCALE), HEIGHT/2-23*SCALE, WIDTH-(OFFSET+32*SCALE), HEIGHT/2-21*SCALE\\n canvas.create_oval(coords, fill=RED, outline=\\\"\\\")\\n # - - Cross\\n coords = WIDTH-(OFFSET+25*SCALE), HEIGHT/2-22.8*SCALE, WIDTH-(OFFSET+29*SCALE), HEIGHT/2-22.8*SCALE, WIDTH-(OFFSET+29*SCALE), HEIGHT/2-25.8*SCALE\\n canvas.create_line(coords, fill=RED, width=2)\\n coords = WIDTH-(OFFSET+25*SCALE), HEIGHT/2-21.2*SCALE, WIDTH-(OFFSET+29*SCALE), HEIGHT/2-21.2*SCALE, WIDTH-(OFFSET+29*SCALE), HEIGHT/2-18.2*SCALE\\n canvas.create_line(coords, fill=RED, width=2)\\n coords = WIDTH-(OFFSET+37*SCALE), HEIGHT/2-22.8*SCALE, WIDTH-(OFFSET+33*SCALE), HEIGHT/2-22.8*SCALE, WIDTH-(OFFSET+33*SCALE), HEIGHT/2-25.8*SCALE\\n canvas.create_line(coords, fill=RED, width=2)\\n coords = WIDTH-(OFFSET+37*SCALE), HEIGHT/2-21.2*SCALE, WIDTH-(OFFSET+33*SCALE), HEIGHT/2-21.2*SCALE, WIDTH-(OFFSET+33*SCALE), HEIGHT/2-18.2*SCALE\\n canvas.create_line(coords, fill=RED, width=2)\\n # - Bottom Right\\n # - - Ticks\\n coords = WIDTH-(OFFSET+29.5*SCALE), HEIGHT/2+39*SCALE, WIDTH-(OFFSET+29.5*SCALE), HEIGHT/2+5*SCALE\\n canvas.create_line(coords, fill=RED, width=2)\\n coords = WIDTH-(OFFSET+32.5*SCALE), HEIGHT/2+39*SCALE, WIDTH-(OFFSET+32.5*SCALE), HEIGHT/2+5*SCALE\\n canvas.create_line(coords, fill=RED, width=2)\\n # - - Circles\\n coords = WIDTH-(OFFSET+16*SCALE), HEIGHT/2+37*SCALE, WIDTH-(OFFSET+46*SCALE), HEIGHT/2+7*SCALE\\n canvas.create_oval(coords, outline=RED, width=2, fill=WHITE)\\n coords = WIDTH-(OFFSET+30*SCALE), HEIGHT/2+23*SCALE, WIDTH-(OFFSET+32*SCALE), HEIGHT/2+21*SCALE\\n canvas.create_oval(coords, fill=RED, outline=\\\"\\\")\\n # - - Cross\\n coords = WIDTH-(OFFSET+25*SCALE), HEIGHT/2+22.8*SCALE, WIDTH-(OFFSET+29*SCALE), HEIGHT/2+22.8*SCALE, WIDTH-(OFFSET+29*SCALE), HEIGHT/2+25.8*SCALE\\n canvas.create_line(coords, fill=RED, width=2)\\n coords = WIDTH-(OFFSET+25*SCALE), HEIGHT/2+21.2*SCALE, WIDTH-(OFFSET+29*SCALE), HEIGHT/2+21.2*SCALE, WIDTH-(OFFSET+29*SCALE), HEIGHT/2+18.2*SCALE\\n canvas.create_line(coords, fill=RED, width=2)\\n coords = WIDTH-(OFFSET+37*SCALE), HEIGHT/2+22.8*SCALE, WIDTH-(OFFSET+33*SCALE), HEIGHT/2+22.8*SCALE, WIDTH-(OFFSET+33*SCALE), HEIGHT/2+25.8*SCALE\\n canvas.create_line(coords, fill=RED, width=2)\\n coords = WIDTH-(OFFSET+37*SCALE), HEIGHT/2+21.2*SCALE, WIDTH-(OFFSET+33*SCALE), HEIGHT/2+21.2*SCALE, WIDTH-(OFFSET+33*SCALE), HEIGHT/2+18.2*SCALE\\n canvas.create_line(coords, fill=RED, width=2)\\n\\n # NEUTRAL ZONE FACEOFF\\n # - Top Left\\n coords = WIDTH/2-21*SCALE, HEIGHT/2-23*SCALE, WIDTH/2-19*SCALE, HEIGHT/2-21*SCALE\\n canvas.create_oval(coords, outline=\\\"\\\", fill=RED)\\n # - Bottom Left\\n coords = WIDTH/2-21*SCALE, HEIGHT/2+23*SCALE, WIDTH/2-19*SCALE, HEIGHT/2+21*SCALE\\n canvas.create_oval(coords, outline=\\\"\\\", fill=RED)\\n # - Top Right\\n coords = WIDTH/2+21*SCALE, HEIGHT/2-23*SCALE, WIDTH/2+19*SCALE, HEIGHT/2-21*SCALE\\n canvas.create_oval(coords, outline=\\\"\\\", fill=RED)\\n # - Bottom Right\\n coords = WIDTH/2+21*SCALE, HEIGHT/2+23*SCALE, WIDTH/2+19*SCALE, HEIGHT/2+21*SCALE\\n canvas.create_oval(coords, outline=\\\"\\\", fill=RED)\\n\\n\\n canvas.grid(row=1, columnspan=5)\",\n \"def check_circuit_pool(self):\\r\\n # Get current number of circuits\\r\\n n = len(self.circuits.values())\\r\\n i = self.num_circuits-n\\r\\n if i > 0:\\r\\n plog(\\\"INFO\\\", \\\"Checked pool of circuits: we need to build \\\" + \\r\\n str(i) + \\\" circuits\\\")\\r\\n # Schedule (num_circs-n) circuit-buildups\\r\\n while (n < self.num_circuits): \\r\\n # TODO: Should mimic Tor's learning here\\r\\n self.build_circuit(\\\"255.255.255.255\\\", 80) \\r\\n plog(\\\"DEBUG\\\", \\\"Scheduled circuit No. \\\" + str(n+1))\\r\\n n += 1\",\n \"def remote_concentric_circles(circle_turtle,dis_range,radius):\\r\\n for i in range(dis_range):\\r\\n color = random.choice(dark_colors)\\r\\n circle_turtle.color(color)\\r\\n circle_turtle.circle(radius*i)\\r\\n circle_turtle.up()\\r\\n circle_turtle.sety((radius*i)*(-1))\\r\\n circle_turtle.down()\\r\\n\\r\\n circle_turtle.up()\\r\\n circle_turtle.goto(0,0)\\r\\n circle_turtle.down()\",\n \"def central_composite(d,center=(2,2),alpha='o',face='ccc'):\\n \\n return build_central_composite(d,center=center,alpha=alpha,face=face)\",\n \"def build_lens_icosahedron(kabamland, vtx, rad, diameter_ratio, thickness_ratio, half_EPD, blockers=True, blocker_thickness_ratio=1.0/1000, light_confinement=False, focal_length=1.0, lens_system_name=None):\\n # Get the list of lens meshes from the appropriate lens system as well as the lens material'''\\n scale_rad = rad*diameter_ratio #max_radius->rad of the lens assembly\\n lenses = lenssystem.get_lens_mesh_list(lens_system_name, scale_rad)\\n lensmat = lenssystem.get_lens_material(lens_system_name)\\n face = None\\n for lns in lenses:\\n #lns = mh.rotate(lns,make_rotation_matrix(ph,ax))\\n if not face:\\n face = Solid(lns, lensmat, kabamland.detector_material)\\n else:\\n face += Solid(lns, lensmat, kabamland.detector_material)\\n\\n if light_confinement:\\n shield = mh.rotate(cylindrical_shell(rad*(1 - 0.001), rad, focal_length,32), make_rotation_matrix(np.pi/2.0, (1,0,0)))\\n baffle = Solid(shield, lensmat, kabamland.detector_material, black_surface, 0xff0000)\\n\\n if blockers:\\n blocker_thickness = 2*rad*blocker_thickness_ratio\\n if half_EPD < rad:\\n c1 = lenssystem.get_lens_sys(lens_system_name).c1*lenssystem.get_scale_factor(lens_system_name,scale_rad)\\n offset = [0,0,c1-np.sqrt(c1*c1-rad*rad)]\\n anulus_blocker = mh.shift(mh.rotate(cylindrical_shell(half_EPD, rad, blocker_thickness, 32), make_rotation_matrix(np.pi/2.0, (1,0,0))),offset)\\n face += Solid(anulus_blocker, lensmat, kabamland.detector_material, black_surface, 0xff0000)\\n phi, axs = rot_axis([0,0,1],vtx)\\n for vx,ph,ax in zip(vtx,-phi,axs):\\n kabamland.add_solid(face, rotation=make_rotation_matrix(ph,ax), displacement = -vx)\\n if light_confinement:\\n kabamland.add_solid(baffle, rotation=make_rotation_matrix(ph,ax), displacement = -normalize(vx)*(np.linalg.norm(vx)+focal_length/2.0))\",\n \"def test_comb(pad_size = (200, 200), wire_width = 1, wire_gap = 3,\\n comb_layer = 0, overlap_zigzag_layer = 1,\\n comb_pad_layer = 2, comb_gnd_layer = 3,\\n overlap_pad_layer = 4):\\n CI = Device(\\\"test_comb\\\")\\n\\n # if comb_pad_layer is None: comb_pad_layer = comb_layer\\n # if comb_gnd_layer is None: comb_gnd_layer = comb_layer\\n # if overlap_pad_layer is None: overlap_pad_layer = overlap_zigzag_layer\\n wire_spacing = wire_width + wire_gap*2\\n\\n # pad overlays\\n overlay_padb = CI.add_ref(rectangle(size = (pad_size[0]*9 / 10,\\n pad_size[1]*9 / 10),\\n layer = overlap_pad_layer))\\n overlay_padl = CI.add_ref(rectangle(size = (pad_size[0]*9 / 10,\\n pad_size[1]*9 / 10),\\n layer = comb_pad_layer))\\n overlay_padt = CI.add_ref(rectangle(size = (pad_size[0]*9 / 10,\\n pad_size[1]*9 / 10),\\n layer = comb_pad_layer))\\n overlay_padr = CI.add_ref(rectangle(size = (pad_size[0]*9 / 10,\\n pad_size[1]*9 / 10),\\n layer = comb_gnd_layer))\\n overlay_padl.xmin = 0\\n overlay_padl.ymin = 0\\n overlay_padb.ymax = 0\\n overlay_padb.xmin = overlay_padl.xmax + pad_size[1]/5\\n overlay_padr.ymin = overlay_padl.ymin\\n overlay_padr.xmin = overlay_padb.xmax + pad_size[1]/5\\n overlay_padt.xmin = overlay_padl.xmax + pad_size[1]/5\\n overlay_padt.ymin = overlay_padl.ymax\\n\\n # pads\\n padl = CI.add_ref(rectangle(size = pad_size, layer = comb_layer))\\n padt = CI.add_ref(rectangle(size = pad_size, layer = comb_layer))\\n padr = CI.add_ref(rectangle(size = pad_size, layer = comb_layer))\\n padb = CI.add_ref(rectangle(size = pad_size, layer = overlap_zigzag_layer))\\n padl_nub = CI.add_ref(rectangle(size = (pad_size[0]/4,\\n pad_size[1]/2),\\n layer = comb_layer))\\n padr_nub = CI.add_ref(rectangle(size = (pad_size[0]/4,\\n pad_size[1]/2),\\n layer = comb_layer))\\n padl.xmin = overlay_padl.xmin\\n padl.center = [padl.center[0], overlay_padl.center[1]]\\n padt.ymax = overlay_padt.ymax\\n padt.center = [overlay_padt.center[0], padt.center[1]]\\n padr.xmax = overlay_padr.xmax\\n padr.center = [padr.center[0], overlay_padr.center[1]]\\n padb.ymin = overlay_padb.ymin\\n padb.center = [overlay_padb.center[0], padb.center[1]]\\n padl_nub.xmin = padl.xmax\\n padl_nub.center = [padl_nub.center[0], padl.center[1]]\\n padr_nub.xmax = padr.xmin\\n padr_nub.center = [padr_nub.center[0], padr.center[1]]\\n\\n # connected zig\\n head = CI.add_ref(compass(size = (pad_size[0]/12, wire_width),\\n layer = comb_layer))\\n head.xmin = padl_nub.xmax\\n head.ymax = padl_nub.ymax\\n connector = CI.add_ref(compass(size = (wire_width, wire_width),\\n layer = comb_layer))\\n connector.connect(port = 'W', destination = head.ports['E'])\\n old_port = connector.ports['S']\\n top = True\\n obj = connector\\n while(obj.xmax + pad_size[0]/12 < padr_nub.xmin):\\n # long zig zag rectangle\\n obj = CI.add_ref(compass(size = (pad_size[1]/2 - 2*wire_width,\\n wire_width),\\n layer = comb_layer))\\n obj.connect(port = 'W', destination = old_port)\\n old_port = obj.ports['E']\\n if(top):\\n # zig zag edge rectangle\\n obj = CI.add_ref(compass(size = (wire_width, wire_width),\\n layer = comb_layer))\\n obj.connect(port = 'N', destination = old_port)\\n top = False\\n else:\\n # zig zag edge rectangle\\n obj = CI.add_ref(compass(size = (wire_width, wire_width),\\n layer = comb_layer))\\n obj.connect(port = 'S', destination = old_port)\\n top = True\\n # comb rectange\\n comb = CI.add_ref(rectangle(\\n size = ((padt.ymin - head.ymax) + pad_size[1]/2 \\\\\\n - (wire_spacing + wire_width)/2, wire_width),\\n layer = comb_layer))\\n comb.rotate(90)\\n comb.ymax = padt.ymin\\n comb.xmax = obj.xmax - (wire_spacing + wire_width)/2\\n old_port = obj.ports['E']\\n obj = CI.add_ref(compass(size = (wire_spacing, wire_width),\\n layer = comb_layer))\\n obj.connect(port = 'W', destination = old_port)\\n old_port = obj.ports['E']\\n obj = CI.add_ref(compass(size = (wire_width, wire_width),\\n layer = comb_layer))\\n obj.connect(port = 'W', destination = old_port)\\n if(top): old_port = obj.ports['S']\\n else: old_port = obj.ports['N']\\n old_port = obj.ports['E']\\n if(padr_nub.xmin-obj.xmax > 0):\\n tail = CI.add_ref(compass(size = (padr_nub.xmin-obj.xmax, wire_width),\\n layer = comb_layer))\\n else:\\n tail = CI.add_ref(compass(size = (wire_width, wire_width),\\n layer = comb_layer))\\n tail.connect(port = 'W', destination = old_port)\\n\\n # disconnected zig\\n dhead = CI.add_ref(compass(size = (padr_nub.ymin - padb.ymax - wire_width,\\n wire_width),\\n layer = overlap_zigzag_layer))\\n dhead.rotate(90)\\n dhead.ymin = padb.ymax\\n dhead.xmax = tail.xmin - (wire_spacing+wire_width)/2\\n connector = CI.add_ref(compass(size = (wire_width, wire_width),\\n layer = overlap_zigzag_layer))\\n connector.connect(port = 'S', destination = dhead.ports['E'])\\n old_port = connector.ports['N']\\n right = True\\n obj = connector\\n while(obj.ymax + wire_spacing + wire_width < head.ymax):\\n obj = CI.add_ref(compass(size = (wire_spacing, wire_width),\\n layer = overlap_zigzag_layer))\\n obj.connect(port = 'W', destination = old_port)\\n old_port = obj.ports['E']\\n if(right):\\n obj = CI.add_ref(compass(size = (wire_width, wire_width),\\n layer = overlap_zigzag_layer))\\n obj.connect(port = 'W', destination = old_port)\\n right = False\\n else:\\n obj = CI.add_ref(compass(size = (wire_width, wire_width),\\n layer = overlap_zigzag_layer))\\n obj.connect(port = 'E', destination = old_port)\\n right = True\\n old_port = obj.ports['N']\\n obj = CI.add_ref(compass(\\n size = (dhead.xmin - (head.xmax+head.xmin+wire_width)/2,\\n wire_width),\\n layer = overlap_zigzag_layer))\\n obj.connect(port = 'E', destination = old_port)\\n old_port = obj.ports['W']\\n obj = CI.add_ref(compass(size = (wire_width, wire_width),\\n layer = overlap_zigzag_layer))\\n obj.connect(port = 'S', destination = old_port)\\n if(right):\\n old_port = obj.ports['W']\\n else:\\n old_port = obj.ports['E']\\n\\n return CI\",\n \"def test_create_cwb(self):\\n \\\"\\\"\\\"burst-cwb.txt\\\"\\\"\\\"\\n time.sleep(SLEEP_TIME)\\n eventFile = os.path.join(testdatadir, \\\"burst-cwb.txt\\\")\\n r = gracedb.createEvent(\\\"Test\\\", \\\"CWB\\\", eventFile)\\n self.assertEqual(r.status, 201) # CREATED\\n cwb_event = r.json()\\n self.assertEqual(cwb_event['group'], \\\"Test\\\")\\n self.assertEqual(cwb_event['pipeline'], \\\"CWB\\\")\\n self.assertEqual(float(cwb_event['gpstime']), 1042312876.5090)\",\n \"def theaterChase(self, color, wait_ms=50, iterations=10):\\n for j in range(iterations):\\n for q in range(3):\\n for i in range(0, self.LEDS, 3):\\n self.ring.setPixelColor(i + q, color)\\n self.ring.show()\\n time.sleep(wait_ms / 1000.0)\\n for i in range(0, self.LEDS, 3):\\n self.ring.setPixelColor(i + q, 0)\",\n \"def HollowCircle(self,center=(0,0),inner_radius=1.0,outer_radius=2.,element_type='tri',isotropic=True,nrad=5,ncirc=10):\\n\\n # FOR SAFETY, RESET THE CLASS\\n self.__reset__()\\n\\n if np.allclose(inner_radius,0):\\n raise ValueError('inner_radius cannot be zero')\\n\\n t = np.linspace(0,2*np.pi,ncirc+1)\\n if isotropic is True:\\n radii = np.linspace(inner_radius,outer_radius,nrad+1)\\n else:\\n base = 3\\n radii = np.zeros(nrad+1,dtype=np.float64)\\n mm = np.linspace(np.power(inner_radius,1./base),np.power(outer_radius,1./base),nrad+1)\\n for i in range(0,nrad+1):\\n radii[i] = mm[i]**base\\n\\n\\n # base = 3\\n # mm = np.linspace(np.power(inner_radius,1./base),np.power(2.,1./base),nrad+1)\\n # mm = np.append(mm,np.linspace(2,outer_radius,nrad+1))\\n # radii = np.zeros(mm.shape[0],dtype=np.float64)\\n # for i in range(0,mm.shape[0]):\\n # radii[i] = mm[i]**base\\n\\n\\n # dd = np.logspace(inner_radius,outer_radius,nrad+1,base=2)/2**np.linspace(inner_radius,outer_radius,nrad+1)\\n # print dd*np.linspace(inner_radius,outer_radius,nrad+1)\\n # print np.logspace(0,1.5,nrad+1,base=2)\\n\\n\\n xy = np.zeros((radii.shape[0]*t.shape[0],2),dtype=np.float64)\\n for i in range(0,radii.shape[0]):\\n xy[i*t.shape[0]:(i+1)*t.shape[0],0] = radii[i]*np.cos(t)\\n xy[i*t.shape[0]:(i+1)*t.shape[0],1] = radii[i]*np.sin(t)\\n\\n\\n # REMOVE DUPLICATES GENERATED BY SIN/COS OF LINSPACE\\n xy = xy[np.setdiff1d( np.arange(xy.shape[0]) , np.linspace(t.shape[0]-1,xy.shape[0]-1,radii.shape[0]).astype(int) ),:]\\n\\n connec = np.zeros((1,4),dtype=np.int64)\\n\\n for j in range(1,radii.shape[0]):\\n for i in range((j-1)*(t.shape[0]-1),j*(t.shape[0]-1)):\\n if i<j*(t.shape[0]-1)-1:\\n connec = np.concatenate((connec,np.array([[i,t.shape[0]-1+i,t.shape[0]+i,i+1 ]])),axis=0)\\n # connec = connec + ((i,t.shape[0]-1+i,t.shape[0]+i,i+1),)\\n else:\\n connec = np.concatenate((connec,np.array([[i,t.shape[0]-1+i,j*(t.shape[0]-1),(j-1)*(t.shape[0]-1) ]])),axis=0)\\n # connec = connec + ((i,t.shape[0]-1+i,j*(t.shape[0]-1),(j-1)*(t.shape[0]-1)),)\\n\\n connec = connec[1:,:]\\n # connec = np.asarray(connec[1:])\\n\\n\\n if element_type == 'tri':\\n connec_tri = np.zeros((2*connec.shape[0],3),dtype=np.int64)\\n for i in range(connec.shape[0]):\\n connec_tri[2*i,:] = np.array([connec[i,0],connec[i,1],connec[i,3]])\\n connec_tri[2*i+1,:] = np.array([connec[i,2],connec[i,3],connec[i,1]])\\n\\n self.elements = connec_tri\\n self.nelem = self.elements.shape[0]\\n self.element_type = element_type\\n # OBTAIN MESH EDGES\\n self.GetBoundaryEdgesTri()\\n\\n elif element_type == 'quad':\\n self.elements = connec\\n self.nelem = self.elements.shape[0]\\n self.element_type = element_type\\n self.GetBoundaryEdgesQuad()\\n\\n # ASSIGN NODAL COORDINATES\\n self.points = xy\\n # IF CENTER IS DIFFERENT FROM (0,0)\\n self.points[:,0] += center[0]\\n self.points[:,1] += center[1]\\n # ASSIGN PROPERTIES\\n self.nnode = self.points.shape[0]\",\n \"def test_methylcyclohexane(self):\\n def draw(image: ShapeImage):\\n image.add_regular_hexagon(\\n 100, start_coord=(400, 400)\\n )\\n image.add_line((487, 350), (487, 250))\\n\\n self._test_shape(\\n image_size=(1000, 1000),\\n expected_corners=np.array([\\n [[400, 400]],\\n [[487, 350]],\\n [[574, 400]],\\n [[574, 500]],\\n [[487, 550]],\\n [[400, 500]],\\n # Methyl group\\n [[487, 250]]\\n ]),\\n drawer=draw,\\n expected_edges=np.array([\\n [[400, 400, 487, 350]],\\n [[487, 350, 574, 400]],\\n [[574, 400, 574, 500]],\\n [[574, 500, 487, 550]],\\n [[487, 550, 400, 500]],\\n [[400, 500, 400, 400]],\\n # To methyl group\\n [[487, 350, 487, 250]]\\n ])\\n )\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6032365","0.5329425","0.5172214","0.5099691","0.50813854","0.5008946","0.5005978","0.49561918","0.4910132","0.4908677","0.48693416","0.48510155","0.48496482","0.4801606","0.48015696","0.4749347","0.47295332","0.47240025","0.4691071","0.4684929","0.4680642","0.4671949","0.46698233","0.46616057","0.4646462","0.46398896","0.4628478","0.46231756","0.46118242","0.46020222","0.45941985","0.458843","0.45571068","0.45501658","0.4540986","0.4539049","0.45226943","0.45204422","0.45129445","0.45048118","0.4502893","0.44989845","0.44936708","0.4480575","0.44739166","0.44711798","0.44660893","0.4460269","0.445915","0.4457693","0.4457048","0.4447847","0.44475603","0.44445238","0.44409296","0.44277507","0.44084692","0.4406198","0.44020602","0.44010055","0.4398955","0.43817163","0.43805966","0.4376213","0.43739253","0.43698916","0.43657395","0.43630424","0.43600127","0.43571","0.43526047","0.43498194","0.43430164","0.43423802","0.43404227","0.43393713","0.4334904","0.43318024","0.43313286","0.43283257","0.43277678","0.43268093","0.43248513","0.4324423","0.4324094","0.4323458","0.43230912","0.43187654","0.43172175","0.43158475","0.43105036","0.4309502","0.43086305","0.43078697","0.4302417","0.4300521","0.42917046","0.42914748","0.42889497"],"string":"[\n \"0.6032365\",\n \"0.5329425\",\n \"0.5172214\",\n \"0.5099691\",\n \"0.50813854\",\n \"0.5008946\",\n \"0.5005978\",\n \"0.49561918\",\n \"0.4910132\",\n \"0.4908677\",\n \"0.48693416\",\n \"0.48510155\",\n \"0.48496482\",\n \"0.4801606\",\n \"0.48015696\",\n \"0.4749347\",\n \"0.47295332\",\n \"0.47240025\",\n \"0.4691071\",\n \"0.4684929\",\n \"0.4680642\",\n \"0.4671949\",\n \"0.46698233\",\n \"0.46616057\",\n \"0.4646462\",\n \"0.46398896\",\n \"0.4628478\",\n \"0.46231756\",\n \"0.46118242\",\n \"0.46020222\",\n \"0.45941985\",\n \"0.458843\",\n \"0.45571068\",\n \"0.45501658\",\n \"0.4540986\",\n \"0.4539049\",\n \"0.45226943\",\n \"0.45204422\",\n \"0.45129445\",\n \"0.45048118\",\n \"0.4502893\",\n \"0.44989845\",\n \"0.44936708\",\n \"0.4480575\",\n \"0.44739166\",\n \"0.44711798\",\n \"0.44660893\",\n \"0.4460269\",\n \"0.445915\",\n \"0.4457693\",\n \"0.4457048\",\n \"0.4447847\",\n \"0.44475603\",\n \"0.44445238\",\n \"0.44409296\",\n \"0.44277507\",\n \"0.44084692\",\n \"0.4406198\",\n \"0.44020602\",\n \"0.44010055\",\n \"0.4398955\",\n \"0.43817163\",\n \"0.43805966\",\n \"0.4376213\",\n \"0.43739253\",\n \"0.43698916\",\n \"0.43657395\",\n \"0.43630424\",\n \"0.43600127\",\n \"0.43571\",\n \"0.43526047\",\n \"0.43498194\",\n \"0.43430164\",\n \"0.43423802\",\n \"0.43404227\",\n \"0.43393713\",\n \"0.4334904\",\n \"0.43318024\",\n \"0.43313286\",\n \"0.43283257\",\n \"0.43277678\",\n \"0.43268093\",\n \"0.43248513\",\n \"0.4324423\",\n \"0.4324094\",\n \"0.4323458\",\n \"0.43230912\",\n \"0.43187654\",\n \"0.43172175\",\n \"0.43158475\",\n \"0.43105036\",\n \"0.4309502\",\n \"0.43086305\",\n \"0.43078697\",\n \"0.4302417\",\n \"0.4300521\",\n \"0.42917046\",\n \"0.42914748\",\n \"0.42889497\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.42844978"},"document_rank":{"kind":"string","value":"99"}}},{"rowIdx":89885,"cells":{"query":{"kind":"string","value":"Creates a CoolantChannelRingStraight shape and checks that the areas of its faces are correct."},"document":{"kind":"string","value":"def test_faces(self):\n\n self.test_shape.workplane = \"XY\"\n self.test_shape.rotation_axis = \"Z\"\n\n assert self.test_shape.area == pytest.approx((((math.pi * (10**2)) * 2) + (math.pi * (10 * 2) * 100)) * 8)\n assert len(self.test_shape.areas) == 24\n assert self.test_shape.areas.count(pytest.approx(math.pi * (10**2))) == 16\n assert self.test_shape.areas.count(pytest.approx(math.pi * (10 * 2) * 100)) == 8"},"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 add_cable_ring(self, env, info={}, cable_idx=0):\n def rad_to_deg(rad):\n return (rad * 180.0) / np.pi\n\n def get_discretized_rotations(num_rotations):\n # counter-clockwise\n theta = i * (2 * np.pi) / num_rotations\n return (theta, rad_to_deg(theta))\n\n # Bead properties.\n num_parts = self.num_parts\n radius = self.radius\n color = self.colors[cable_idx] + [1]\n\n # The `ring_radius` (not the bead radius!) has to be tuned somewhat.\n # Try to make sure the beads don't have notable gaps between them.\n ring_radius = info['ring_radius']\n beads = []\n bead_positions_l = []\n\n # Add beaded cable. Here, `position` is the circle center.\n position = np.float32(info['center_position'])\n part_shape = p.createCollisionShape(p.GEOM_BOX, halfExtents=[radius]*3)\n part_visual = p.createVisualShape(p.GEOM_SPHERE, radius=radius*1.5)\n\n # Iterate through parts and create constraints as needed.\n for i in range(num_parts):\n angle_rad, _ = get_discretized_rotations(num_parts)\n px = ring_radius * np.cos(angle_rad)\n py = ring_radius * np.sin(angle_rad)\n #print(f'pos: {px:0.2f}, {py:0.2f}, angle: {angle_rad:0.2f}, {angle_deg:0.1f}')\n bead_position = np.float32([position[0] + px, position[1] + py, 0.01])\n part_id = p.createMultiBody(0.1, part_shape, part_visual,\n basePosition=bead_position)\n p.changeVisualShape(part_id, -1, rgbaColor=color)\n\n if i > 0:\n parent_frame = bead_position - bead_positions_l[-1]\n constraint_id = p.createConstraint(\n parentBodyUniqueId=beads[-1],\n parentLinkIndex=-1,\n childBodyUniqueId=part_id,\n childLinkIndex=-1,\n jointType=p.JOINT_POINT2POINT,\n jointAxis=(0, 0, 0),\n parentFramePosition=parent_frame,\n childFramePosition=(0, 0, 0))\n p.changeConstraint(constraint_id, maxForce=100)\n\n # Make a constraint with i=0. Careful with `parent_frame`!\n if i == num_parts - 1:\n parent_frame = bead_positions_l[0] - bead_position\n constraint_id = p.createConstraint(\n parentBodyUniqueId=part_id,\n parentLinkIndex=-1,\n childBodyUniqueId=beads[0],\n childLinkIndex=-1,\n jointType=p.JOINT_POINT2POINT,\n jointAxis=(0, 0, 0),\n parentFramePosition=parent_frame,\n childFramePosition=(0, 0, 0))\n p.changeConstraint(constraint_id, maxForce=100)\n\n # Track beads.\n beads.append(part_id)\n bead_positions_l.append(bead_position)\n\n # The usual for tracking IDs. Four things to add.\n self.cable_bead_IDs.append(part_id)\n self._IDs[part_id] = f'cable_part_{str(part_id).zfill(2)}'\n env.objects.append(part_id)\n self.object_points[part_id] = np.float32((0, 0, 0)).reshape(3, 1)\n\n if 'cable-ring' in self._name:\n # For targets, we can assume the starting position gives us\n # that. Later, apply a random force on the ring to perturb it.\n true_position = (bead_position[0], bead_position[1], 0)\n self.goal['places'][part_id] = (true_position, (0, 0, 0, 1.))\n symmetry = 0\n self.goal['steps'][0][part_id] = (symmetry, [part_id])\n\n # Make the true positions visible if desired.\n if info['targets_visible']:\n sq_pose = ((true_position[0], true_position[1], 0.002), (0,0,0,1))\n sq_template = 'assets/square/square-template-allsides-green.urdf'\n replace = {'DIM': (0.003,), 'HALF': (0.003 / 2,)}\n urdf = self.fill_template(sq_template, replace)\n env.add_object(urdf, sq_pose, fixed=True)\n os.remove(urdf)\n else:\n print(f'Warning, env {self._name} will not have goals.')","def generate_solid(self):\n ext = os.path.splitext(self.filename)[1][1:]\n if ext == 'stl':\n shaft_compound = read_stl_file(self.filename)\n elif ext == 'iges':\n iges_reader = IGESControl_Reader()\n iges_reader.ReadFile(self.filename)\n iges_reader.TransferRoots()\n shaft_compound = iges_reader.Shape()\n else:\n raise Exception('The shaft file is not in iges/stl formats')\n sewer = BRepBuilderAPI_Sewing(1e-2)\n sewer.Add(shaft_compound)\n sewer.Perform()\n result_sewed_shaft = sewer.SewedShape()\n shaft_solid_maker = BRepBuilderAPI_MakeSolid()\n shaft_solid_maker.Add(OCC.Core.TopoDS.topods_Shell(result_sewed_shaft))\n if not shaft_solid_maker.IsDone():\n raise RuntimeError('Unsuccessful assembling of solid shaft')\n shaft_solid = shaft_solid_maker.Solid()\n return shaft_solid","def test_drawSolid(self):\n\n image_name = filename(sys._getframe().f_code.co_name)\n result_file, reference_file = get_path(image_name)\n\n ''' This function is to create an empty image with a specific dimension\n with white background, and black/white colored '''\n\n image, canvas = get_image('RGB', (640, 480), 'white')\n\n '''\n for different representations of colors see\n \"https://pillow.readthedocs.io/en/3.0.x/reference/ImageColor.html#color-names\"\n '''\n drawSolid(canvas, regularPolygon(3, np.array([160, 120]), 50), 'red')\n drawSolid(canvas, regularPolygon(4, np.array([480, 120]), 90), 'blue')\n drawSolid(canvas, regularPolygon(5, np.array([420, 360]), 60), 'green')\n drawSolid(canvas, regularPolygon(6, np.array([160, 360]), 80), 'black')\n drawSolid(canvas, regularPolygon(7, np.array([320, 160]), 70), 'brown')\n\n \"\"\" saving the file and closing it \"\"\"\n image.save(result_file)\n image.close()\n\n \"\"\" validate the resultant file against the reference images\"\"\"\n\n validate(reference_file, result_file)","def __bcc_left_diagonals(self) -> cq.cq.Workplane:\n # In a cuboid ABCDA1B1C1D1 this is the angle C1AD\n #angle_C1AD = 90 - degrees(acos(2**-.5))\n angle_C1AD = 90 - degrees(acos(0.5))\n angle_CAD = 90 - degrees(acos(sqrt(2/3)))\n pseudo_unit_cell_size = sqrt(2/3)*self.unit_cell_size\n corner_points = np.array(\n [(0, 0),\n (self.bcc_unit_cell_size, 0),\n (self.bcc_unit_cell_size, self.unit_cell_size),\n (0, self.unit_cell_size)]\n )\n result = (\n cq.Workplane(\"XY\")\n .pushPoints(corner_points)\n .eachpointAdaptive(\n create_bcc_diagonal_strut,\n callback_extra_args = [\n {\"unit_cell_size\": pseudo_unit_cell_size,\n \"radius\": self.strut_radius,\n \"angle_x\": - angle_CAD,\n \"angle_y\": angle_C1AD},\n {\"unit_cell_size\": 0.5 * pseudo_unit_cell_size,\n \"radius\": self.strut_radius,\n \"angle_x\": - angle_CAD,\n \"angle_y\": - angle_C1AD},\n {\"unit_cell_size\": 0.5 * pseudo_unit_cell_size,\n \"radius\": self.strut_radius,\n \"angle_x\": angle_CAD,\n \"angle_y\": - angle_C1AD},\n {\"unit_cell_size\": pseudo_unit_cell_size,\n \"radius\": self.strut_radius,\n \"angle_x\": angle_CAD,\n \"angle_y\": angle_C1AD}\n ],\n useLocalCoords = True\n )\n )\n return result","def _create_main_shape(self):\n\n a, b = gc( self.size/2,\n self._ZERO_DEGREES - self.angle,\n self._180_DEGREES + self.angle)\n self.wafer_points = zip(a,b)\n self.wafer_polygon = gdspy.Polygon(self.wafer_points, self.WAFER_LAYER)\n self.cell.add(self.wafer_polygon)","def make_circle_fill():\n num_points = 40\n batch = pyglet.graphics.Batch()\n rad = math.pi * 2 / num_points # getting 360 / n in radians\n index = list(itertools.chain.from_iterable( (0, x-1, x) for x in range(2, num_points+1) ))\n index += [0, 1, num_points] # end of fan\n vertices = [0, 0] # adding center of fan\n for i in range(1, num_points + 1):\n angle = rad * i\n vertices += [math.cos(angle), math.sin(angle)]\n vertices += [1, 0] # adding end of fan\n circle = pyglet.graphics.vertex_list_indexed(num_points+2, index, ('v2f', vertices))\n return circle","def boundaries_and_initialize():\n greenLower = (29, 86, 6) # define the lower and upper boundaries of the \"green\"\n greenUpper = (64, 255, 255)\n pts = [((200,300),(255,255,255), 0)]\n blanks = []\n linecolor = (0,0,0)\n counter = 1\n radius = 11\n return greenLower, greenUpper, pts, linecolor, counter, blanks, radius","def poly_enclose(points, color, inc=1.2, rad=0.3, lw=2):\n points = np.log(points)\n hull = ConvexHull(points)\n\n cent = np.mean(points, 0)\n pts = []\n for pt in points[hull.simplices]:\n pts.append(pt[0].tolist())\n pts.append(pt[1].tolist())\n \n pts.sort(key=lambda p: np.arctan2(p[1] - cent[1],\n p[0] - cent[0]))\n pts = pts[0::2] # Deleting duplicates\n pts.insert(len(pts), pts[0])\n \n \n verts = inc*(np.array(pts)- cent) + cent\n verts2 = np.zeros((3*verts.shape[0]-2,2))\n verts2[0::3] = verts\n verts2[1::3,:] = (1-rad)*verts[0:-1,:] + rad*verts[1:,:]\n verts2[2::3,:] = rad*verts[0:-1,:] + (1-rad)*verts[1:,:]\n verts2[0:-1] = verts2[1:]\n verts2[-1] = verts2[0]\n\n\n \n codes = [Path.MOVETO, Path.LINETO, Path.CURVE3,]\n for j in range(len(pts)-2):\n codes.extend([Path.CURVE3, Path.LINETO, Path.CURVE3,])\n codes.append(Path.CURVE3)\n \n \n path = Path(verts2, codes)\n patch = patches.PathPatch(path, facecolor=color, lw=0, alpha=0.2)\n edge = patches.PathPatch(path, edgecolor=color, facecolor='none', lw=lw)\n patch._path._vertices = np.exp(patch._path._vertices)\n return patch, edge","def make_flower(shape, x, y, c1, c2, l, s):\n shape.penup()\n shape.speed(20)\n shape.setpos(x, y)\n shape.color(c2, c1)\n shape.begin_fill()\n shape.pendown()\n for side in range(6):\n shape.left(60)\n shape.forward(s) # s stands for short side\n shape.right(60)\n shape.forward(l) # l stands for long side\n shape.right(60)\n shape.forward(s)\n shape.right(60)\n shape.forward(s)\n shape.right(60)\n shape.forward(l)\n shape.right(60)\n shape.forward(s)\n shape.right(60)\n shape.end_fill()\n shape.pendown()\n\n shape.color(\"green\")\n shape.right(90)\n shape.penup()\n shape.forward(10)\n shape.pendown()\n shape.forward(110)\n shape.left(90)\n\n\n\n # ...","def test_clip_points_by_polygons_with_holes_real(self):\n\n # Read real polygon with holes\n filename = '%s/%s' % (TESTDATA, 'donut.shp')\n L = read_layer(filename)\n\n # --------------------------------------------\n # Pick one polygon that has 2 inner rings\n P = L.get_geometry(as_geometry_objects=True)[1]\n\n outer_ring = P.outer_ring\n inner_ring0 = P.inner_rings[0]\n inner_ring1 = P.inner_rings[1]\n\n # Make some test points\n points_in_bbox = generate_random_points_in_bbox(outer_ring, 1000)\n points_in_inner_ring0 = populate_polygon(inner_ring0, 2, seed=13)\n points_in_inner_ring1 = populate_polygon(inner_ring1, 2, seed=17)\n points = numpy.concatenate((points_in_bbox,\n points_in_inner_ring0,\n points_in_inner_ring1))\n\n # Clip\n indices = inside_polygon(points, P.outer_ring, holes=P.inner_rings)\n\n # Sanity\n for point in points[indices, :]:\n # Must be inside outer ring\n assert is_inside_polygon(point, outer_ring)\n\n # But not in any of the inner rings\n assert not is_inside_polygon(point, inner_ring0)\n assert not is_inside_polygon(point, inner_ring1)\n\n # ---------------------------------------------------------\n # Pick a polygon that has 1 inner ring (nice visualisation)\n P = L.get_geometry(as_geometry_objects=True)[9]\n\n outer_ring = P.outer_ring\n inner_ring = P.inner_rings[0]\n\n # Make some test points\n points = generate_random_points_in_bbox(outer_ring, 500)\n\n # Clip\n indices = inside_polygon(points, P.outer_ring, holes=P.inner_rings)\n\n # Sanity\n for point in points[indices, :]:\n # Must be inside outer ring\n assert is_inside_polygon(point, outer_ring)\n\n # But not in the inner ring\n assert not is_inside_polygon(point, inner_ring)\n\n # Store for visual check (nice one!)\n # Uncomment os.remove if you want see the layers\n pol = Vector(geometry=[P])\n tmp_filename = unique_filename(suffix='.shp')\n pol.write_to_file(tmp_filename)\n #print 'Polygon with holes written to %s' % tmp_filename\n os.remove(tmp_filename)\n\n pts = Vector(geometry=points[indices, :])\n tmp_filename = unique_filename(suffix='.shp')\n pts.write_to_file(tmp_filename)\n #print 'Clipped points written to %s' % tmp_filename\n os.remove(tmp_filename)","def RemovePolygonHoles_management(in_fc, threshold=0.0):\n desc = arcpy.Describe(in_fc)\n if desc.dataType != \"FeatureClass\" and desc.dataType != \"ShapeFile\":\n print(\"Invalid data type. The input is supposed to be a Polygon FeatureClass or Shapefile.\")\n return\n else:\n if desc.shapeType != \"Polygon\":\n print(\"The input is supposed to be a Polygon FeatureClass or Shapefile.\")\n return\n if threshold < 0.0:\n threshold = 0.0\n with arcpy.da.UpdateCursor(in_fc, [\"SHAPE@\"]) as updateCursor:\n for updateRow in updateCursor:\n shape = updateRow[0]\n new_shape = arcpy.Array()\n for part in shape:\n new_part = arcpy.Array()\n if threshold > 0:\n # find None point in shape part\n # in arcpy module, a None point is used to seperate exterior and interior vertices\n null_point_index = []\n for i in range(len(part)):\n if part[i] is None:\n null_point_index.append(i)\n # if interior vertices exist, create polygons and compare polygon shape area to given threshold\n # if larger, keep vertices, else, dismiss them\n if len(null_point_index) > 0:\n for k in range(0, null_point_index[0]):\n new_part.add(part[k])\n for i in range(len(null_point_index)):\n pointArray = arcpy.Array()\n # determine if the None point is the last one\n if i+1 < len(null_point_index):\n for j in range(null_point_index[i] + 1, null_point_index[i+1]):\n pointArray.add(part[j])\n else:\n for j in range(null_point_index[i] + 1, len(part)):\n pointArray.add(part[j])\n # create a polygon to check shape area against the given threshold\n inner_poly = arcpy.Polygon(pointArray)\n # if larger than threshold, then add to the new part Array\n if inner_poly.area > threshold:\n if i+1 < len(null_point_index):\n for k in range(null_point_index[i], null_point_index[i+1]):\n new_part.add(part[k])\n else:\n for k in range(null_point_index[i], len(part)):\n new_part.add(part[k])\n new_shape.add(new_part)\n # if interior does not exist, add the whole part\n else:\n new_shape.add(part)\n else:\n # get the first None point index\n first_null_point_index = 0\n for i in range(len(part)):\n if part[i] is None:\n first_null_point_index = i\n break\n if first_null_point_index == 0:\n new_shape.add(part)\n else:\n for j in range(first_null_point_index):\n new_part.add(part[j])\n new_shape.add(new_part)\n if len(new_shape) > 0:\n new_poly = arcpy.Polygon(new_shape)\n updateRow[0] = new_poly\n updateCursor.updateRow(updateRow)","def make_shape_ccw(self):\n\n if not(self.closed):\n return\n\n # Optimization for closed shapes\n # Start value for the first sum\n\n if self.isDirectionOfGeosCCW(self.geos):\n self.reverse()\n logger.debug(self.tr(\"Had to reverse the shape to be CW\"))\n self.cw = True","def createCylinder( basePoint=(0,-1,0), tipPoint=(0,1,0), radius = 1.0, colour=(0.6,0.6,0.6), samples = 20 ):\r\n \r\n basePoint = PyUtils.toPoint3d(basePoint)\r\n tipPoint = PyUtils.toPoint3d(tipPoint)\r\n baseToTipVector = Vector3d(basePoint,tipPoint)\r\n if baseToTipVector.isZeroVector() :\r\n raise ValueError( 'Invalid points for cylinder: base and tip are equal!' )\r\n baseToTipUnitVector = baseToTipVector.unit()\r\n xUnitVector = baseToTipUnitVector.crossProductWith( Vector3d(0,0,1) )\r\n if xUnitVector.length() < 0.5 :\r\n xUnitVector = baseToTipUnitVector.crossProductWith( Vector3d(0,-1,0) )\r\n xUnitVector.toUnit()\r\n yUnitVector = baseToTipUnitVector.crossProductWith( Vector3d(-1,0,0) )\r\n if yUnitVector.length() < 0.5 :\r\n yUnitVector = baseToTipUnitVector.crossProductWith( Vector3d(0,1,0) )\r\n yUnitVector.toUnit()\r\n\r\n vertices = []\r\n for i in range(samples):\r\n theta = i * 2 * math.pi / float(samples)\r\n vertices.append( basePoint + xUnitVector * math.cos(theta) * radius + yUnitVector * math.sin(theta) * radius )\r\n for i in range(samples):\r\n theta = i * 2 * math.pi / float(samples)\r\n vertices.append( tipPoint + xUnitVector * math.cos(theta) * radius + yUnitVector * math.sin(theta) * radius )\r\n for i in range(samples):\r\n theta = i * 2 * math.pi / float(samples)\r\n vertices.append( basePoint + xUnitVector * math.cos(theta) * radius + yUnitVector * math.sin(theta) * radius )\r\n vertices.append( tipPoint + xUnitVector * math.cos(theta) * radius + yUnitVector * math.sin(theta) * radius )\r\n \r\n faces = [ range(0,samples), range(samples,2*samples) ]\r\n for i in range(0,2*samples,2) :\r\n base = 2*samples\r\n size = 2*samples\r\n faces.append( (base+i, base+i+1, base+(i+3)%size, base+(i+2)%size ) )\r\n \r\n return create( vertices, faces, colour )","def __bcc_diagonals(self) -> cq.cq.Workplane:\n # In a cuboid ABCDA1B1C1D1 this is the angle C1AD\n #angle_C1AD = 90 - degrees(acos(2**-.5))\n angle_C1AD = 90 - degrees(acos(0.5))\n angle_CAD = 90 - degrees(acos(sqrt(2/3)))\n pseudo_unit_cell_size = sqrt(2/3)*self.unit_cell_size\n corner_points = np.array(\n [(0, 0),\n (self.bcc_unit_cell_size, 0),\n (self.bcc_unit_cell_size, self.unit_cell_size),\n (0, self.unit_cell_size)]\n )\n result = (\n cq.Workplane(\"XY\")\n .pushPoints(corner_points)\n .eachpointAdaptive(\n create_bcc_diagonal_strut,\n callback_extra_args = [\n {\"unit_cell_size\": pseudo_unit_cell_size,\n \"radius\": self.strut_radius,\n \"angle_x\": - angle_CAD,\n \"angle_y\": angle_C1AD},\n {\"unit_cell_size\": pseudo_unit_cell_size,\n \"radius\": self.strut_radius,\n \"angle_x\": - angle_CAD,\n \"angle_y\": - angle_C1AD},\n {\"unit_cell_size\": pseudo_unit_cell_size,\n \"radius\": self.strut_radius,\n \"angle_x\": angle_CAD,\n \"angle_y\": - angle_C1AD},\n {\"unit_cell_size\": pseudo_unit_cell_size,\n \"radius\": self.strut_radius,\n \"angle_x\": angle_CAD,\n \"angle_y\": angle_C1AD}\n ],\n useLocalCoords = True\n )\n )\n return result","def __bcc_top_diagonals(self) -> cq.cq.Workplane:\n # In a cuboid ABCDA1B1C1D1 this is the angle C1AD\n #angle_C1AD = 90 - degrees(acos(2**-.5))\n angle_C1AD = 90 - degrees(acos(0.5))\n angle_CAD = 90 - degrees(acos(sqrt(2/3)))\n pseudo_unit_cell_size = sqrt(2/3)*self.unit_cell_size\n corner_points = np.array(\n [(0, 0),\n (self.bcc_unit_cell_size, 0),\n (self.bcc_unit_cell_size, self.unit_cell_size),\n (0, self.unit_cell_size)]\n )\n result = (\n cq.Workplane(\"XY\")\n .pushPoints(corner_points)\n .eachpointAdaptive(\n create_bcc_diagonal_strut,\n callback_extra_args = [\n {\"unit_cell_size\": 0.5 * pseudo_unit_cell_size,\n \"radius\": self.strut_radius,\n \"angle_x\": - angle_CAD,\n \"angle_y\": angle_C1AD},\n {\"unit_cell_size\": pseudo_unit_cell_size,\n \"radius\": self.strut_radius,\n \"angle_x\": - angle_CAD,\n \"angle_y\": - angle_C1AD},\n {\"unit_cell_size\": pseudo_unit_cell_size,\n \"radius\": self.strut_radius,\n \"angle_x\": angle_CAD,\n \"angle_y\": - angle_C1AD},\n {\"unit_cell_size\": 0.5 * pseudo_unit_cell_size,\n \"radius\": self.strut_radius,\n \"angle_x\": angle_CAD,\n \"angle_y\": angle_C1AD}\n ],\n useLocalCoords = True\n )\n )\n return result","def tail_shaft_circle(self):\n _profile = Circle(position=self.stabilizer_vright.position, radius=(self.critical_thickness / 2.0) * 1.5)\n _extrude = ExtrudedSolid(island=_profile, distance=self.stabilizer_h.root_chord)\n return _profile, _extrude","def test_clip_points_by_polygons_with_holes0(self):\n\n # Define an outer ring\n outer_ring = numpy.array([[106.79, -6.233],\n [106.80, -6.24],\n [106.78, -6.23],\n [106.77, -6.21],\n [106.79, -6.233]])\n\n # Define inner rings\n inner_rings = [numpy.array([[106.77827, -6.2252],\n [106.77775, -6.22378],\n [106.78, -6.22311],\n [106.78017, -6.22530],\n [106.77827, -6.2252]])[::-1],\n numpy.array([[106.78652, -6.23215],\n [106.78642, -6.23075],\n [106.78746, -6.23143],\n [106.78831, -6.23307],\n [106.78652, -6.23215]])[::-1]]\n\n v = Vector(geometry=[Polygon(outer_ring=outer_ring,\n inner_rings=inner_rings)])\n assert v.is_polygon_data\n\n # Write it to file\n tmp_filename = unique_filename(suffix='.shp')\n v.write_to_file(tmp_filename)\n\n # Read polygon it back\n L = read_layer(tmp_filename)\n P = L.get_geometry(as_geometry_objects=True)[0]\n\n outer_ring = P.outer_ring\n inner_ring0 = P.inner_rings[0]\n inner_ring1 = P.inner_rings[1]\n\n # Make some test points\n points = generate_random_points_in_bbox(outer_ring, 1000, seed=13)\n\n # Clip to outer ring, excluding holes\n indices = inside_polygon(points, P.outer_ring, holes=P.inner_rings)\n\n # Sanity\n for point in points[indices, :]:\n # Must be inside outer ring\n assert is_inside_polygon(point, outer_ring)\n\n # But not in any of the inner rings\n assert not is_inside_polygon(point, inner_ring0)\n assert not is_inside_polygon(point, inner_ring1)\n\n if False:\n # Store for visual check\n pol = Vector(geometry=[P])\n tmp_filename = unique_filename(suffix='.shp')\n pol.write_to_file(tmp_filename)\n print 'Polygon with holes written to %s' % tmp_filename\n\n pts = Vector(geometry=points[indices, :])\n tmp_filename = unique_filename(suffix='.shp')\n pts.write_to_file(tmp_filename)\n print 'Clipped points written to %s' % tmp_filename","def _createpoly(self):\n return self.cv.create_polygon((0, 0, 0, 0, 0, 0), fill=\"\", outline=\"\")","def test_polygons_with_inner_rings(self):\n\n # Define two (closed) outer rings - clock wise direction\n outer_rings = [numpy.array([[106.79, -6.233],\n [106.80, -6.24],\n [106.78, -6.23],\n [106.77, -6.21],\n [106.79, -6.233]]),\n numpy.array([[106.76, -6.23],\n [106.72, -6.23],\n [106.72, -6.22],\n [106.72, -6.21],\n [106.76, -6.23]])]\n\n tmp_filename = unique_filename(suffix='.shp')\n\n # Do outer rings first (use default geometry type polygon)\n v_ref = Vector(geometry=outer_rings)\n assert v_ref.is_polygon_data\n\n v_ref.write_to_file(tmp_filename)\n v_file = read_layer(tmp_filename)\n assert v_file == v_ref\n assert v_file.is_polygon_data\n\n # Do it again but with (closed) inner rings as well\n\n # Define inner rings (counter clock wise)\n inner_rings = [\n # 2 rings for feature 0\n [numpy.array([[106.77827, -6.2252],\n [106.77775, -6.22378],\n [106.78, -6.22311],\n [106.78017, -6.22530],\n [106.77827, -6.2252]])[::-1],\n numpy.array([[106.78652, -6.23215],\n [106.78642, -6.23075],\n [106.78746, -6.23143],\n [106.78831, -6.23307],\n [106.78652, -6.23215]])[::-1]],\n # 1 ring for feature 1\n [numpy.array([[106.73709, -6.22752],\n [106.73911, -6.22585],\n [106.74265, -6.22814],\n [106.73971, -6.22926],\n [106.73709, -6.22752]])[::-1]]]\n\n polygons = []\n for i, outer_ring in enumerate(outer_rings):\n p = Polygon(outer_ring=outer_ring, inner_rings=inner_rings[i])\n polygons.append(p)\n\n v_ref = Vector(geometry=polygons)\n assert v_ref.is_polygon_data\n data_bbox = v_ref.get_bounding_box()\n\n # Check data from Vector object\n geometry = v_ref.get_geometry(as_geometry_objects=True)\n for i, g in enumerate(geometry):\n assert numpy.allclose(g.outer_ring, outer_rings[i])\n if i == 0:\n assert len(g.inner_rings) == 2\n else:\n assert len(g.inner_rings) == 1\n\n for j, ring in enumerate(inner_rings[i]):\n assert numpy.allclose(ring, g.inner_rings[j])\n\n # Write to file and read again\n v_ref.write_to_file(tmp_filename)\n #print 'With inner rings, written to ', tmp_filename\n v_file = read_layer(tmp_filename)\n assert v_file == v_ref\n assert v_file.is_polygon_data\n assert numpy.allclose(v_file.get_bounding_box(), data_bbox,\n rtol=1.0e-12, atol=1.0e-12)\n\n # Check data from file\n geometry = v_file.get_geometry(as_geometry_objects=True)\n for i, g in enumerate(geometry):\n assert numpy.allclose(g.outer_ring, outer_rings[i])\n if i == 0:\n assert len(g.inner_rings) == 2\n else:\n assert len(g.inner_rings) == 1\n\n for j, ring in enumerate(inner_rings[i]):\n assert numpy.allclose(ring, g.inner_rings[j])","def test_creation(self):\n\n assert self.test_shape.solid is not None\n assert self.test_shape.volume() > 1000","def test_creation(self):\n\n assert self.test_shape.solid is not None\n assert self.test_shape.volume() > 1000","def CheckClearance(self, via, area, clearance):\r\n p1 = via.GetPosition()\r\n corners = area.GetNumCorners()\r\n # Calculate minimum distance from corners\r\n # TODO: remove?\r\n for i in range(corners):\r\n corner = area.GetCornerPosition(i)\r\n p2 = corner.getWxPoint()\r\n the_distance = norm(p2 - p1) # sqrt((p2.x - p1.x) ** 2 + (p2.y - p1.y) ** 2)\r\n\r\n if the_distance < clearance:\r\n return False\r\n\r\n for i in range(corners):\r\n corner1 = area.GetCornerPosition(i)\r\n corner2 = area.GetCornerPosition((i + 1) % corners)\r\n pc1 = corner1.getWxPoint()\r\n pc2 = corner2.getWxPoint()\r\n the_distance, _ = pnt2line(p1, pc1, pc2)\r\n\r\n if the_distance <= clearance:\r\n return False\r\n\r\n for edge in self.board_edges:\r\n if edge.ShowShape() == 'Line':\r\n the_distance, _ = pnt2line(p1, edge.GetStart(), edge.GetEnd())\r\n if the_distance <= clearance + via.GetWidth() / 2:\r\n return False\r\n if edge.ShowShape() == 'Arc':\r\n # distance from center of Arc and with angle within Arc angle should be outside Arc radius +- clearance + via Width/2\r\n center = edge.GetPosition()\r\n start = edge.GetStart()\r\n end = edge.GetEnd()\r\n radius = norm(center - end)\r\n dist = norm(p1 - center)\r\n if radius - (self.clearance + via.GetWidth() / 2) < dist < radius + (\r\n self.clearance + via.GetWidth() / 2):\r\n # via is in range need to check the angle\r\n start_angle = math.atan2((start - center).y, (start - center).x)\r\n end_angle = math.atan2((end - center).y, (end - center).x)\r\n if end_angle < start_angle:\r\n end_angle += 2 * math.pi\r\n point_angle = math.atan2((p1 - center).y, (p1 - center).x)\r\n if start_angle <= point_angle <= end_angle:\r\n return False\r\n\r\n return True","def solid(self):\r\n return not not self.prototype.solid","def __fill_lip_solid(self, outer, inner):\n inner[0].reverse()\n inner[1].reverse()\n outer_curve = zip(outer[0], outer[1])\n inner_curve = zip(inner[0], inner[1])\n points = []\n for point in outer_curve:\n points.append(np.array(point, dtype=np.int32))\n for point in inner_curve:\n points.append(np.array(point, dtype=np.int32))\n points = np.array(points, dtype=np.int32)\n self.red_l = int(self.red_l)\n self.green_l = int(self.green_l)\n self.blue_l = int(self.blue_l)\n cv2.fillPoly(self.image, [points], (self.red_l, self.green_l, self.blue_l))","def checkRing(self, verbose = 0):\n angleSum = self.tfs.ANGLE.sum()\n if self.verbose: print (\"check\")\n print (\"---------------------------------- \\n Checking, if ring is closed: \\n\", \"angleSum = \", angleSum)\n twoPi = 2*pi\n \n if angleSum != twoPi:\n fudge = 2*pi - angleSum\n print (\" ** Ring not closed - offset of: \", fudge)","def ring_is_clockwise(ring):\n total = 0\n for (pt1, pt2) in pairwise(ring):\n total += (pt2[0] - pt1[0]) * (pt2[1] + pt1[1])\n return total >= 0","def grating_coupler_circular(\n taper_angle: float = 30.0,\n taper_length: float = 10.0,\n length: float = 30.0,\n period: float = 1.0,\n fill_factor: float = 0.7,\n n_periods: int = 30,\n bias_gap: float = 0,\n port: Coordinate = (0.0, 0.0),\n layer_slab: Optional[LayerSpec] = None,\n layer_cladding: LayerSpec = \"WGCLAD\",\n gaps: Optional[Floats] = None,\n widths: Optional[Floats] = None,\n direction: str = \"EAST\",\n polarization: str = \"te\",\n wavelength: float = 1.55,\n fiber_marker_width: float = 11.0,\n fiber_marker_layer: Optional[LayerSpec] = \"TE\",\n cladding_offset: float = 2.0,\n cross_section: CrossSectionSpec = \"strip\",\n **kwargs,\n) -> Component:\n x = gf.get_cross_section(cross_section, **kwargs)\n layer = x.layer\n wg_width = x.width\n\n widths = widths or n_periods * [period * fill_factor]\n gaps = gaps or n_periods * [period * (1 - fill_factor)]\n\n gaps = np.array(gaps) + bias_gap\n widths = np.array(widths) - bias_gap\n teeth_list = list(zip(gaps, widths))\n\n layer = gf.get_layer(layer)\n layer_slab = gf.get_layer(layer_slab)\n layer_cladding = gf.get_layer(layer_cladding)\n\n c = pc.GratingCoupler(\n gf.call_if_func(\n strip,\n cladding_offset=cladding_offset,\n wg_width=wg_width,\n layer=layer,\n layer_cladding=layer_cladding,\n ),\n theta=np.deg2rad(taper_angle),\n length=length,\n taper_length=taper_length,\n period=period,\n dutycycle=fill_factor,\n ridge=bool(layer_slab),\n ridge_layers=layer_slab,\n teeth_list=teeth_list,\n port=port,\n direction=direction,\n )\n\n c = gf.read.from_picwriter(c)\n c.info[\"polarization\"] = polarization\n c.info[\"wavelength\"] = wavelength\n c.ports[\"o1\"].cross_section = x\n\n fiber_xoffset = np.round(c.center[0] + taper_length / 2, 3)\n\n if fiber_marker_layer:\n circle = gf.components.circle(\n radius=fiber_marker_width / 2, layer=fiber_marker_layer\n )\n circle_ref = c.add_ref(circle)\n circle_ref.movex(fiber_xoffset)\n\n c.add_port(\n name=f\"vertical_{polarization.lower()}\",\n center=[fiber_xoffset, 0],\n width=fiber_marker_width,\n orientation=0,\n layer=fiber_marker_layer,\n )\n if x.add_bbox:\n c = x.add_bbox(c)\n if x.add_pins:\n c = x.add_pins(c)\n return c","def test_conv_full(self):\n\n points = np.array([[1, 4], [2, 1], [3, 2], [3, 3], [3, 5], [4, 2], [5, 1], [5, 3]]) # example of points \n \n cv_hull = convex_hull.convex_hull(points) # convex hull returned by the function \n\n right_conv_hull = np.array([[2, 1], [5, 1], [5, 3], [3, 5], [1, 4], [2, 1] ]) # right convex hull\n self.assertTrue((right_conv_hull == cv_hull).all())","def __init__(self, points,\n fill=False,\n point_mode=0,\n point_size=[0.01, 0.01],\n point_radius=0.01,\n point_width=1,\n point_fill=False,\n side_width=1,\n color=None,\n point_color=colors.WHITE,\n side_color=colors.WHITE,\n area_color=colors.WHITE,\n cross_point_color=colors.WHITE,\n cross_point_radius=0.01,\n cross_point_mode=0,\n cross_point_width=1,\n cross_point_size=[0.1, 0.1],\n point_show=True,\n side_show=True,\n area_show=False):\n self.points = points\n\n self.point_mode = point_mode\n self.point_size = point_size\n self.point_width = point_width\n self.point_radius = point_radius\n self.point_color = point_color or color\n self.point_show = point_show\n self.point_fill = point_fill\n\n self.side_width = side_width\n self.side_color = side_color or color\n self.side_show = side_show\n\n self.area_color = area_color or color\n self.area_show = area_show or fill\n\n self.cross_point_color = cross_point_color\n self.cross_point_radius = cross_point_radius\n self.cross_point_mode = cross_point_mode\n self.cross_point_width = cross_point_width\n self.cross_point_size = cross_point_size","def test_rocket():\n ring = [(0,0), (10, 0), (15,5), (10,9), (1,7), (6,4), (0,0)]\n conv = ToPointsAndSegments()\n conv.add_polygon([ring])\n skel = calc_skel(conv, output=True, pause=True)\n print \"DONE\"","def check_win(self):\n\n # Sets rings initially to False\n black_ring = False\n white_ring = False\n\n # Gets board\n board = self._game_board.get_board_area()\n\n # Iterate through stone-holding points\n for i in range(1, 19):\n for j in range(1, 19):\n # Get the surroundings of each point\n surround = {board[i+1][j], board[i-1][j], board[i+1][j+1], board[i+1][j-1], board[i-1][j],\n board[i-1][j-1], board[i-1][j+1], board[i][j-1]}\n\n # If the point is empty and surrounded by \"B\", there's a black ring\n if board[i][j] == \" \" and surround == {\"B\"}:\n black_ring = True\n\n # If the point is empty and surrounded by \"W\", there's a white ring\n if board[i][j] == \" \" and surround == {\"W\"}:\n white_ring = True\n\n if not black_ring:\n return \"WHITE_WON\"\n\n if not white_ring:\n return \"BLACK_WON\"\n\n return \"UNFINISHED\"","def special_corner() -> None:\r\n if example[1, 1] == 0: # NW\r\n if conflict_space[0, 0] == conflict_space[0, 2] and conflict_space[2, 0] == conflict_space[0, 0] \\\r\n and conflict_space[0, 0] != 0:\r\n example[0, 0] = 0\r\n safeboard[0, 0] = 0\r\n progress_handler(False, True)\r\n \r\n if example[1, shape-2] == 0: # NE\r\n if conflict_space[0, shape-1] == conflict_space[0, shape-3] and \\\r\n conflict_space[2, shape-1] == conflict_space[0, shape-1] and conflict_space[0, shape-1] != 0:\r\n example[0, shape-1] = 0\r\n safeboard[0, shape-1] = 0\r\n progress_handler(False, True)\r\n \r\n if example[shape-2, shape-2] == 0: # SE\r\n if conflict_space[shape-1, shape-1] == conflict_space[shape-1, shape-3] and \\\r\n conflict_space[shape-1, shape-1] == conflict_space[shape-3, shape-1] \\\r\n and conflict_space[shape-1, shape-1] != 0:\r\n example[shape-1, shape-1] = 0\r\n safeboard[shape-1, shape-1] = 0\r\n progress_handler(False, True)\r\n \r\n if example[shape-2, 1] == 0: # SW\r\n if conflict_space[shape-1, 0] == conflict_space[shape-1, 2] and \\\r\n conflict_space[shape-1, 0] == conflict_space[shape-3, 0] and conflict_space[shape-1, 0] != 0:\r\n example[shape-1, 0] = 0\r\n safeboard[shape-1, 0] = 0\r\n progress_handler(False, True)\r\n if progress_handler(True, False):\r\n conflict_check()","def proc_filled_polygon(self, tokens):\n\n return self._proc_polygon(tokens, filled=True)","def test_cyclohexane(self):\n self._test_shape(\n image_size=(1000, 1000),\n expected_corners=np.array([\n [[400, 400]],\n [[487, 350]],\n [[574, 400]],\n [[574, 500]],\n [[487, 550]],\n [[400, 500]]\n ]),\n drawer=lambda image: image.add_regular_hexagon(\n 100, start_coord=(400, 400)\n )\n )","def bc_is_solid(bc):\n solid = BCProp(int(bc_solid[bc.xlb]),\n int(bc_solid[bc.xrb]),\n int(bc_solid[bc.ylb]),\n int(bc_solid[bc.yrb]))\n return solid","def draw_filled_polygon(\n self, points: Iterable[Vec3], properties: Properties\n ) -> None:\n raise NotImplementedError","def add_cable(self, env, size_range, info={}, cable_idx=0,\n direction='z', max_force=100):\n num_parts = self.num_parts\n radius = self.radius\n length = self.length\n color = self.colors[cable_idx] + [1]\n color_end = U.COLORS['yellow'] + [1]\n\n # Add beaded cable.\n distance = length / num_parts\n position, _ = self.random_pose(env, size_range)\n position = np.float32(position)\n part_shape = p.createCollisionShape(p.GEOM_BOX, halfExtents=[radius]*3)\n part_visual = p.createVisualShape(p.GEOM_SPHERE, radius=radius*1.5)\n\n # Iterate through parts and create constraints as needed.\n for i in range(num_parts):\n if direction == 'x':\n position[0] += distance\n parent_frame = (distance, 0, 0)\n elif direction == 'y':\n position[1] += distance\n parent_frame = (0, distance, 0)\n else:\n position[2] += distance\n parent_frame = (0, 0, distance)\n\n part_id = p.createMultiBody(0.1, part_shape, part_visual,\n basePosition=position)\n if i > 0:\n constraint_id = p.createConstraint(\n parentBodyUniqueId=env.objects[-1],\n parentLinkIndex=-1,\n childBodyUniqueId=part_id,\n childLinkIndex=-1,\n jointType=p.JOINT_POINT2POINT,\n jointAxis=(0, 0, 0),\n parentFramePosition=parent_frame,\n childFramePosition=(0, 0, 0))\n p.changeConstraint(constraint_id, maxForce=max_force)\n\n if (i > 0) and (i < num_parts - 1):\n p.changeVisualShape(part_id, -1, rgbaColor=color)\n elif i == num_parts - 1:\n p.changeVisualShape(part_id, -1, rgbaColor=color_end)\n\n # The usual for tracking IDs. Four things to add.\n self.cable_bead_IDs.append(part_id)\n self._IDs[part_id] = f'cable_part_{str(part_id).zfill(2)}'\n env.objects.append(part_id)\n self.object_points[part_id] = np.float32((0, 0, 0)).reshape(3, 1)\n\n # Get target placing positions for each cable bead, if applicable.\n if self._name == 'cable-shape' or self._name == 'cable-shape-notarget' or \\\n self._name == 'cable-line-notarget':\n # ----------------------------------------------------------- #\n # Here, zone_pose = square_pose, unlike Ravens cable, where the\n # zone_pose is shifted so that its center matches the straight\n # line segment center. For `true_position`, we use `zone_pose`\n # but apply the correct offset to deal with the sides. Note\n # that `length` is the size of a fully smoothed cable, BUT we\n # made a rectangle with each side <= length.\n # ----------------------------------------------------------- #\n lx = info['lengthx']\n ly = info['lengthy']\n r = radius\n\n if info['nb_sides'] == 1:\n # Here it's just a straight line on the 'lx' side.\n x_coord = lx / 2 - (distance * i)\n y_coord = 0\n true_position = (x_coord - r, y_coord, 0)\n\n elif info['nb_sides'] == 2:\n # Start from lx side, go 'left' to the pivot point, then on\n # the ly side, go 'upwards' but offset by `i`. For radius\n # offset, I just got this by tuning. XD\n if i < info['cutoff']:\n x_coord = lx / 2 - (distance * i)\n y_coord = -ly / 2\n true_position = (x_coord - r, y_coord, 0)\n else:\n x_coord = -lx / 2\n y_coord = -ly / 2 + (distance * (i - info['cutoff']))\n true_position = (x_coord, y_coord + r, 0)\n\n elif info['nb_sides'] == 3:\n # Start from positive lx, positive ly, go down to first\n # pivot. Then go left to the second pivot, then up again.\n # For v1, division by two is because we assume BOTH of the\n # 'ly edges' were divided by two.\n v1 = (self.num_parts - info['cutoff']) / 2\n v2 = self.num_parts - v1\n if i < v1:\n x_coord = lx / 2\n y_coord = ly / 2 - (distance * i)\n true_position = (x_coord, y_coord - r, 0)\n elif i < v2:\n x_coord = lx / 2 - (distance * (i - v1))\n y_coord = -ly / 2\n true_position = (x_coord - r, y_coord, 0)\n else:\n x_coord = -lx / 2\n y_coord = -ly / 2 + (distance * (i - v2))\n true_position = (x_coord, y_coord + r, 0)\n\n elif info['nb_sides'] == 4:\n # I think this is similar to the 2-side case: we start in\n # the same direction and go counter-clockwise.\n v1 = info['cutoff'] / 2\n v2 = num_parts / 2\n v3 = (num_parts + info['cutoff']) / 2\n if i < v1:\n x_coord = lx / 2 - (distance * i)\n y_coord = -ly / 2\n true_position = (x_coord, y_coord, 0)\n elif i < v2:\n x_coord = -lx / 2\n y_coord = -ly / 2 + (distance * (i - v1))\n true_position = (x_coord, y_coord, 0)\n elif i < v3:\n x_coord = -lx / 2 + (distance * (i - v2))\n y_coord = ly / 2\n true_position = (x_coord, y_coord, 0)\n else:\n x_coord = lx / 2\n y_coord = ly / 2 - (distance * (i - v3))\n true_position = (x_coord, y_coord, 0)\n\n # Map true_position onto the workspace from zone_pose.\n true_position = self.apply(self.zone_pose, true_position)\n\n # See `cable.py`: just get the places and steps set.\n self.goal['places'][part_id] = (true_position, (0, 0, 0, 1.))\n symmetry = 0\n self.goal['steps'][0][part_id] = (symmetry, [part_id])\n\n # Debugging target zones.\n if self.target_debug_markers:\n sq_pose = ((true_position[0], true_position[1], 0.002), (0,0,0,1))\n sq_template = 'assets/square/square-template-allsides-blue.urdf'\n replace = {'DIM': (0.003,), 'HALF': (0.003 / 2,)}\n urdf = self.fill_template(sq_template, replace)\n env.add_object(urdf, sq_pose, fixed=True)\n os.remove(urdf)\n else:\n print(f'Warning, env {self._name} will not have goals.')","def _convex_hull_side(image, start, end):\n\n convex_points = [start]\n\n x_start, y_start = start\n x_end, y_end = end\n\n side = (x_start <= x_end, y_start <= y_end)\n\n\n ranges = {\n (True, True): [\n [x_start + 1, x_end + 1],\n [y_start, y_end + 1],\n False\n ],\n (False, True): [\n [y_start + 1, y_end + 1],\n [x_start, x_end - 1, -1],\n True\n ],\n (False, False): [\n [x_start - 1, x_end - 1, -1],\n [y_start, y_end - 1, -1],\n False\n ],\n (True, False): [\n [y_start - 1, y_end - 1, -1],\n [x_start, x_end + 1],\n True\n ]\n }\n\n prev = 0\n\n for outer in range(*ranges[side][0]):\n\n curr_pixel = None\n\n for inner in range(*ranges[side][1]):\n if ranges[side][2] and image[outer, inner] == 0:\n curr_pixel = (inner, outer)\n break\n elif not ranges[side][2] and image[inner, outer] == 0:\n curr_pixel = (outer, inner)\n break\n\n if curr_pixel is None:\n continue\n\n while True:\n # slope infinite for first point\n prev_slope = (\n float(\"-inf\") if prev == 0\n else slope(\n convex_points[prev - 1],\n convex_points[prev],\n ranges[side][2]))\n\n # remove previous point if it yields concave segment\n if prev_slope > slope(\n convex_points[prev],\n curr_pixel,\n ranges[side][2]\n ):\n convex_points.pop(prev)\n prev -= 1\n # add point to hull if it yields convex segment\n else:\n convex_points.append(curr_pixel)\n prev += 1\n break\n\n return convex_points[1:]","def cleanOpenBranches(skeleton, skelton_copy, points, radii, length, clean = True, verbose = False):\n \n assert np.isfortran(skeleton);\n assert np.isfortran(skelton_copy);\n \n timer = tmr.Timer();\n timer_all = tmr.Timer();\n \n # find branch and end points\n deg = cpl.convolve_3d_indices(skeleton, t3d.n26, points, out_dtype = 'uint8');\n branchpoints = points[deg >= 3];\n e_pts = points[deg == 1];\n \n if verbose:\n timer.printElapsedTime('Detected %d branch and %d endpoints' % (branchpoints.shape[0], e_pts.shape[0]));\n timer.reset();\n \n #prepare temps\n #skel = skeleton.copy();\n skel_flat = np.reshape(skelton_copy, -1, order = 'A');\n strides = np.array(skelton_copy.strides);\n \n \n if verbose:\n timer.printElapsedTime('Detected %d branch and %d endpoints' % (branchpoints.shape[0], e_pts.shape[0]));\n timer.reset();\n \n label = np.arange(27);\n label = label.reshape([3,3,3]);\n label[1,1,1] = 0;\n \n critical_points = [e_pts];\n delete_points = [];\n \n for l in range(1, length + 1):\n #neighbours of end points\n e_pts_label = cpl.convolve_3d_indices(skelton_copy, label, e_pts);\n \n if verbose:\n timer.printElapsedTime('Done labeling %d / %d' % (l, length));\n timer.reset();\n \n #label zero points are non-critical short isolated branches\n e_pts_zero = e_pts_label == 0;\n #print 'zero length:', np.unravel_index(e_pts[e_pts_zero], skel.shape)\n if e_pts_zero.sum() > 0:\n keep = np.logical_not(e_pts_zero);\n for m in range(l):\n critical_points[m] = critical_points[m][keep];\n e_pts_label = e_pts_label[keep];\n e_pts = e_pts[keep];\n \n if verbose:\n timer.printElapsedTime('Ignored %d small branches' % (keep.sum()));\n timer.reset();\n \n e_pts_new = e_pts + np.sum((np.vstack(np.unravel_index(e_pts_label, label.shape)) - 1).T * strides, axis = 1)\n \n # did we hit a branch point\n delete = np.in1d(e_pts_new, branchpoints); #, assume_unique = True);\n keep = np.logical_not(delete);\n #print delete.shape, keep.shape, e_pts_new.shape\n \n #delete all path that hit a branch point\n if delete.sum() > 0:\n for m in range(l):\n delete_points.append(critical_points[m][delete]);\n #print 'deleting:', np.unravel_index(critical_points[m][delete], skel.shape)\n critical_points[m] = critical_points[m][keep];\n e_pts_new = e_pts_new[keep];\n \n if verbose:\n timer.printElapsedTime('Deleted %d points' % (delete.sum()));\n timer.reset();\n \n if l < length:\n skel_flat[e_pts] = False; # remove endpoints for new neighbour detection\n critical_points.append(e_pts_new);\n e_pts = e_pts_new;\n \n if verbose:\n timer.printElapsedTime('Cleanup iteration %d / %d done.' % (l, length));\n \n #gather all points\n if len(delete_points) > 0:\n delete_points = np.hstack(delete_points);\n delete_points = np.unique(delete_points);\n else:\n delete_points = np.zeros(0);\n \n if verbose:\n timer_all.printElapsedTime('Cleanup');\n \n if clean:\n skel_flat = np.reshape(skeleton, -1, order = 'F');\n skel_flat[delete_points] = False;\n keep_ids = np.logical_not(np.in1d(points, delete_points, assume_unique = True))\n points = points[keep_ids];\n radii = radii[keep_ids];\n return skeleton, points, radii\n \n return delete_points;","def corridor(x,z, emap, width=10, length=10, height=10, details=None, walls=\"ns\", name=\"wall\", mergeshape=None):\r\n global wallnum\r\n n = z + width / 2\r\n s = z - width / 2\r\n e = x + length / 2\r\n w = x - length / 2\r\n\r\n solid_objects = []\r\n\r\n if \"n\" in walls:\r\n # TODO: abstract out the mostly-duplicate code in these cases...\r\n nwall = SolidObject(name+str(wallnum),\r\n Size(length, height, 1),\r\n Position(x, emap.calcHeight(x, z) + height / 2, n-0.5), 0)\r\n solid_objects.append(nwall)\r\n nwallmodel = createMyCuboid(nwall.w() * 2, nwall.h() * 2, nwall.d() * 2,\r\n name=name+str(wallnum),\r\n x=nwall.x(),y=nwall.y(),z=nwall.z(),\r\n rx=0.0, ry=0.0, rz=0.0, cx=0.0, cy=0.0, cz=0.0)\r\n if mergeshape:\r\n mergeshape.add(nwallmodel)\r\n else:\r\n nwall.setmodel(nwallmodel, details)\r\n\r\n\r\n wallnum += 1\r\n\r\n if \"s\" in walls:\r\n swall = SolidObject(name+str(wallnum), Size(length, height, 1), Position(x, emap.calcHeight(x, z)+height / 2, s+0.5), 0)\r\n solid_objects.append(swall)\r\n swallmodel = createMyCuboid(swall.w()*2, swall.h()*2, swall.d()*2,\r\n name=name+str(wallnum),\r\n x=swall.x(), y=swall.y(), z=swall.z(),\r\n rx=0.0, ry=0.0, rz=0.0, cx=0.0,cy=0.0, cz=0.0)\r\n if mergeshape:\r\n mergeshape.add(swallmodel)\r\n else:\r\n swall.setmodel(swallmodel, details)\r\n\r\n wallnum += 1\r\n\r\n if \"e\" in walls:\r\n ewall = SolidObject(name+str(wallnum), Size(1, height, width), Position(e-0.5, emap.calcHeight(x, z)+height / 2, z), 0)\r\n solid_objects.append(ewall)\r\n ewallmodel = createMyCuboid(ewall.w()*2, ewall.h()*2, ewall.d()*2,\r\n name=name+str(wallnum),\r\n x=ewall.x(), y=ewall.y(), z=ewall.z(),\r\n rx=0.0, ry=0.0, rz=0.0, cx=0.0, cy=0.0, cz=0.0)\r\n if mergeshape:\r\n mergeshape.add(ewallmodel)\r\n else:\r\n ewall.setmodel(ewallmodel, details)\r\n\r\n wallnum += 1\r\n\r\n if \"w\" in walls:\r\n wwall = SolidObject(name+str(wallnum), Size(1, height, width), Position(w+0.5, emap.calcHeight(x, z)+height / 2, z), 0)\r\n solid_objects.append(wwall)\r\n wwallmodel = createMyCuboid(wwall.w()*2, wwall.h()*2, wwall.d()*2,\r\n name=name+str(wallnum),\r\n x=wwall.x(), y=wwall.y(), z=wwall.z(),\r\n rx=0.0, ry=0.0, rz=0.0, cx=0.0, cy=0.0, cz=0.0)\r\n if mergeshape:\r\n mergeshape.add(wwallmodel)\r\n else:\r\n wwall.setmodel(wwallmodel, details)\r\n wallnum += 1\r\n\r\n if \"o\" not in walls:\r\n ceiling = SolidObject(name+str(wallnum), Size(length, 1, width), Position(x, emap.calcHeight(x, z)+height+0.5, z), 0)\r\n solid_objects.append(ceiling)\r\n ceilingmodel = createMyCuboid(ceiling.w()*2, ceiling.h()*2, ceiling.d()*2,\r\n name=name+str(wallnum),\r\n x=ceiling.x(), y=ceiling.y(), z=ceiling.z(),\r\n rx=0.0, ry=0.0, rz=0.0, cx=0.0, cy=0.0, cz=0.0)\r\n if mergeshape:\r\n mergeshape.add(ceilingmodel)\r\n else:\r\n ceiling.setmodel(ceilingmodel, details)\r\n\r\n wallnum += 1\r\n\r\n return solid_objects","def circlePrimitive(self):\n\n def drawWireframe(self):\n\n # Draw line\n glFT.glBegin(OpenMayaRender.MGL_LINE_STRIP)\n\n # Get Color\n # self.getColor(\"edge\")\n\n def_circle = 100\n for idx in range(def_circle + 1):\n\n theta = 2 * 3.141592 * idx / def_circle\n x = self.shape_size * math.cos(theta)\n z = self.shape_size * math.sin(theta)\n\n point = OpenMaya.MVector(x, 0.0, z)\n point = self.setUpAxis(point)\n point = self.addOffsetRotation(point)\n point = self.addOffsetPosition(point)\n self.getBoundingBoxSize(point)\n\n glFT.glVertex3f(point.x, point.y, point.z)\n\n glFT.glEnd()\n \n def drawShaded(self):\n\n # Draw quad\n glFT.glBegin(OpenMayaRender.MGL_POLYGON)\n\n # Get Color\n # self.getColor(\"polygon\")\n\n def_circle = 100\n for idx in range(def_circle + 1):\n\n theta = 2 * 3.141592 * idx / def_circle\n x = self.shape_size * math.cos(theta)\n z = self.shape_size * math.sin(theta)\n\n point = OpenMaya.MVector(x, 0.0, z)\n point = self.setUpAxis(point)\n point = self.addOffsetRotation(point)\n point = self.addOffsetPosition(point)\n self.getBoundingBoxSize(point)\n\n glFT.glVertex3f(point.x, point.y, point.z)\n\n glFT.glEnd()\n\n glFT.glNewList(self.vList_id, OpenMayaRender.MGL_COMPILE)\n\n # Draw lines\n if self.draw_type == 0 or self.draw_type == 2:\n drawWireframe(self)\n \n # Draww Polygons\n if self.draw_type == 1 or self.draw_type == 2:\n drawShaded(self)\n\n glFT.glEndList()","def geoshapes(c = False, r = False, t = False):\n if c == True:\n circle = plt.Circle((0,0), radius = 3, fill = None, edgecolor = 'y')\n plt.gca().add_patch(circle)\n elif r == True:\n rectangle = plt.Rectangle((0, 0), 5, 5, fill = None, edgecolor='r')\n plt.gca().add_patch(rectangle)\n elif t == True:\n points = [[0,0], [0,3], [3,3]]\n triangle = plt.Polygon(points, fill = None, edgecolor = 'r')\n plt.gca().add_patch(triangle)\n else:\n print('Error: please input a True value for either c, r , or t')","def checkForCircle(self, points, tangents):\n if len(points)<10:\n return False, 0\n\n if all(points[0]==points[-1]): # last exactly equals the first.\n # Ignore last point for this check\n points = points[:-1]\n tangents = tangents[:-1]\n #print 'Removed last ', points\n xmin,ymin, w, h = computeBox( points)\n diag2=(w*w+h*h)\n \n diag = sqrt(diag2)*0.5\n norms = numpy.sqrt(numpy.sum( tangents**2, 1 ))\n\n angles = numpy.arctan2( tangents[:,1], tangents[:,0] ) \n #debug( 'angle = ', repr(angles))\n N = len(angles)\n \n deltas = points[1:] - points[:-1] \n deltasD = numpy.concatenate([ [D(points[0],points[-1])/diag], numpy.sqrt(numpy.sum( deltas**2, 1 )) / diag] )\n\n # locate and avoid the point when swicthing\n # from -pi to +pi. The point is around the minimum\n imin = numpy.argmin(angles)\n debug(' imin ',imin)\n angles = numpy.roll(angles, -imin)\n deltasD = numpy.roll(deltasD, -imin)\n n=int(N*0.1)\n # avoid fluctuations by removing points around the min\n angles=angles[n:-n]\n deltasD=deltasD[n:-n]\n deltasD = deltasD.cumsum()\n N = len(angles)\n\n # smooth angles to avoid artificial bumps\n angles = smoothArray(angles, n=max(int(N*0.03),2) )\n\n deltaA = angles[1:] - angles[:-1]\n deltasDD = (deltasD[1:] -deltasD[:-1])\n deltasDD[numpy.where(deltasDD==0.)] = 1e-5*deltasD[0]\n dAdD = abs(deltaA/deltasDD)\n belowT, count = True,0\n for v in dAdD:\n if v>6 and belowT:\n count+=1\n belowT = False\n belowT= (v<6)\n\n self.temp = (deltasD,angles, tangents, dAdD )\n fracStraight = numpy.sum(deltasDD[numpy.where(dAdD<0.3)])/(deltasD[-1]-deltasD[0])\n curveLength = deltasD[-1]/3.14\n #print \"SSS \",count , fracStraight\n if curveLength> 1.4 or fracStraight>0.4 or count > 6:\n isCircle =False\n else: \n isCircle= (count < 4 and fracStraight<=0.3) or \\\n (fracStraight<=0.1 and count<5)\n\n if not isCircle:\n return False, 0\n \n # It's a circle !\n radius = points - numpy.array([xmin+w*0.5,ymin+h*0.5])\n radius_n = numpy.sqrt(numpy.sum( radius**2, 1 )) # normalize\n\n mini = numpy.argmin(radius_n) \n rmin = radius_n[mini]\n maxi = numpy.argmax(radius_n) \n rmax = radius_n[maxi]\n # void points around maxi and mini to make sure the 2nd max is found\n # on the \"other\" side\n n = len(radius_n)\n radius_n[maxi]=0 \n radius_n[mini]=0 \n for i in range(1,n/8+1):\n radius_n[(maxi+i)%n]=0\n radius_n[(maxi-i)%n]=0\n radius_n[(mini+i)%n]=0\n radius_n[(mini-i)%n]=0\n radius_n_2 = [ r for r in radius_n if r>0]\n rmax_2 = max(radius_n_2)\n rmin_2 = min(radius_n_2) # not good !!\n anglemax = numpy.arccos( radius[maxi][0]/rmax)*numpy.sign(radius[maxi][1])\n return True, (xmin+w*0.5,ymin+h*0.5, 0.5*(rmin+rmin_2), 0.5*(rmax+rmax_2), anglemax)","def HollowCylinder(self,center=(0,0,0),inner_radius=1.0,outer_radius=2.,\n element_type='hex',isotropic=True,nrad=5,ncirc=10, nlong=20,length=10):\n\n if element_type != \"hex\":\n raise NotImplementedError('Generating {} mesh of cylinder is not supported yet'.format(element_type))\n\n if not isinstance(center,tuple):\n raise ValueError(\"The center for the base of the cylinder should be given in a tuple with three elements (x,y,z)\")\n\n self.__reset__()\n\n nlong = int(nlong)\n if nlong==0:\n nlong = 1\n\n mesh = Mesh()\n mesh.HollowCircle(center=(center[0],center[1]), inner_radius=inner_radius,\n outer_radius=outer_radius, element_type=\"quad\",\n isotropic=isotropic, nrad=nrad, ncirc=ncirc)\n\n self.Extrude(base_mesh=mesh, length=length, nlong=nlong)\n self.points += center[2]","def __init__(self, point, angle, width=1, color=colors.WHITE, correct=True):\n if correct:\n self.angle = angle\n self.point = point\n else:\n self._angle = angle\n self._point = point\n self.width = width\n self.color = color","def createCone( basePoint=(0,-1,0), tipPoint=(0,1,0), radius = 1.0, colour=(0.6,0.6,0.6), samples = 20 ):\r\n \r\n basePoint = PyUtils.toPoint3d(basePoint)\r\n tipPoint = PyUtils.toPoint3d(tipPoint)\r\n baseToTipVector = Vector3d(basePoint,tipPoint)\r\n if baseToTipVector.isZeroVector() :\r\n raise ValueError( 'Invalid points for cylinder: base and tip are equal!' )\r\n baseToTipUnitVector = baseToTipVector.unit()\r\n xUnitVector = baseToTipUnitVector.crossProductWith( Vector3d(0,0,1) )\r\n if xUnitVector.length() < 0.5 :\r\n xUnitVector = baseToTipUnitVector.crossProductWith( Vector3d(0,-1,0) )\r\n xUnitVector.toUnit()\r\n yUnitVector = baseToTipUnitVector.crossProductWith( Vector3d(-1,0,0) )\r\n if yUnitVector.length() < 0.5 :\r\n yUnitVector = baseToTipUnitVector.crossProductWith( Vector3d(0,1,0) )\r\n yUnitVector.toUnit()\r\n\r\n vertices = []\r\n for i in range(samples):\r\n theta = i * 2 * math.pi / float(samples)\r\n vertices.append( basePoint + xUnitVector * math.cos(theta) * radius + yUnitVector * math.sin(theta) * radius )\r\n for i in range(samples):\r\n theta = i * 2 * math.pi / float(samples)\r\n vertices.append( basePoint + xUnitVector * math.cos(theta) * radius + yUnitVector * math.sin(theta) * radius )\r\n vertices.append( tipPoint )\r\n \r\n faces = [ range(0,samples) ]\r\n for i in range(0,samples) :\r\n base = samples\r\n size = samples\r\n faces.append( (base+i, base+(i+1)%size, 2*samples ) )\r\n \r\n return create( vertices, faces, colour )","def _cal_meaningful_corners(self):\n corners = np.where(self._free_of_clash)\n corners = np.array(corners, dtype=int)\n corners = corners.transpose()\n return corners","def drawShapes(self):\n self.draw_polygon(self.poly3.get_points() , color = \"#000\")\n self.draw_polygon(self.poly2.get_points() , color = \"#000\")\n self.draw_polygon(self.poly1.get_points() , color = \"#000\")\n self.draw_rect(0, 0, self.width, self.height, color= \"#000\")\n \"\"\"These statements are used to determine if a point is inside any of the\n 3 polygons and if so changes the point's color\"\"\"\n if (self.poly2.point_inside_polygon(self.p1) or self.poly1.point_inside_polygon(self.p1)\n or self.poly3.point_inside_polygon(self.p1)):\n color = \"#0F0\"\n else:\n color = \"#F00\"\n self.fill_oval(self.p1.x, self.p1.y, 7, 7, color)\n\n if (self.poly2.point_inside_polygon(self.p2) or self.poly1.point_inside_polygon(self.p2)\n or self.poly3.point_inside_polygon(self.p2)):\n color = \"#0F0\"\n else:\n color = \"#F00\"\n self.fill_oval(self.p2.x, self.p2.y, 7, 7, color)\n if (self.poly2.point_inside_polygon(self.p3) or self.poly1.point_inside_polygon(self.p3)\n or self.poly3.point_inside_polygon(self.p3)):\n color = \"#0F0\"\n else:\n color = \"#F00\"\n self.fill_oval(self.p3.x, self.p3.y, 7, 7, color)","def bolthole(location, diameter, clamp_length, nuthole_size, nuthole_depth):\n bolthole = (\n cq.Workplane()\n .bolt(\n bolt_size = diameter,\n head_size = 2 * diameter,\n head_length = 2 * diameter,\n head_shape = \"cylindrical\", \n head_angle = 90,\n clamp_length = clamp_length,\n nut_size = nuthole_size,\n nut_length = nuthole_depth\n )\n .val()\n .located(location * cq.Location(cq.Vector(0, 0, - clamp_length / 2)))\n )\n # show_object(bolthole) # Debug helper.\n return bolthole","def crpolygon(self, x, y, r, n, t0=0, cls=None, style=None):\n t0 = 2 * math.pi * t0 / 360.0\n dt = 2 * math.pi / n\n pts = []\n for idx in xrange(n + 1):\n dx = x + r * math.cos(t0)\n dy = y + r * math.sin(t0)\n t0 += dt\n pts.append('M' if idx == 0 else 'Z' if idx == n else 'L')\n pts.append('%s %s' % (dx, dy))\n self.path(pts, cls=cls, style=style)","def crpolygon(self, x, y, r, n, t0=0, cls=None, style=None):\n t0 = 2 * math.pi * t0 / 360.0\n dt = 2 * math.pi / n\n pts = []\n for idx in xrange(n + 1):\n dx = x + r * math.cos(t0)\n dy = y + r * math.sin(t0)\n t0 += dt\n pts.append('M' if idx == 0 else 'Z' if idx == n else 'L')\n pts.append('%s %s' % (dx, dy))\n self.path(pts, cls=cls, style=style)","def fill_polygon(self, sides, x0, y0, r, color, rotate=0):\n # Determine side coordinates\n coords = []\n theta = radians(rotate)\n n = sides + 1\n for s in range(n):\n t = 2.0 * pi * s / sides + theta\n coords.append([int(r * cos(t) + x0), int(r * sin(t) + y0)])\n # Starting point\n x1, y1 = coords[0]\n # Minimum Maximum X dict\n xdict = {y1: [x1, x1]}\n # Iterate through coordinates\n for row in coords[1:]:\n x2, y2 = row\n xprev, yprev = x2, y2\n # Calculate perimeter\n # Check for horizontal side\n if y1 == y2:\n if x1 > x2:\n x1, x2 = x2, x1\n if y1 in xdict:\n xdict[y1] = [min(x1, xdict[y1][0]), max(x2, xdict[y1][1])]\n else:\n xdict[y1] = [x1, x2]\n x1, y1 = xprev, yprev\n continue\n # Non horizontal side\n # Changes in x, y\n dx = x2 - x1\n dy = y2 - y1\n # Determine how steep the line is\n is_steep = abs(dy) > abs(dx)\n # Rotate line\n if is_steep:\n x1, y1 = y1, x1\n x2, y2 = y2, x2\n # Swap start and end points if necessary\n if x1 > x2:\n x1, x2 = x2, x1\n y1, y2 = y2, y1\n # Recalculate differentials\n dx = x2 - x1\n dy = y2 - y1\n # Calculate error\n error = dx >> 1\n ystep = 1 if y1 < y2 else -1\n y = y1\n # Calcualte minimum and maximum x values\n for x in range(x1, x2 + 1):\n if is_steep:\n if x in xdict:\n xdict[x] = [min(y, xdict[x][0]), max(y, xdict[x][1])]\n else:\n xdict[x] = [y, y]\n else:\n if y in xdict:\n xdict[y] = [min(x, xdict[y][0]), max(x, xdict[y][1])]\n else:\n xdict[y] = [x, x]\n error -= abs(dy)\n if error < 0:\n y += ystep\n error += dx\n x1, y1 = xprev, yprev\n # Fill polygon\n for y, x in xdict.items():\n self.hline(x[0], y, x[1] - x[0] + 2, color)","def stokes_right_circular():\n return np.array([1, 0, 0, 1])","def is_ccw(geometry, **kwargs):\n return lib.is_ccw(geometry, **kwargs)","def tail_joiner(self):\n\n # Fusing Right Horizontal Tail:\n shape_in_r = Fused(shape_in=self.stabilizer_h.solid, tool=self.stabilizer_vright.solid)\n shape_out_r = Fused(shape_in=shape_in_r, tool=self.connector_right)\n\n # Fusing Left Horizontal Tail:\n shape_in_l = Fused(shape_in=self.stabilizer_h.ht_mirror, tool=self.stabilizer_vleft.solid)\n shape_out_l = Fused(shape_in=shape_in_l, tool=self.connector_left)\n\n shape_out = Fused(shape_in=shape_out_r, tool=shape_out_l)\n\n return shape_out","def make_tight_box(self, tightness: float = 0.33) -> None:\r\n\r\n # Default to the plant's original box\r\n x1 = self.box[0]\r\n y1 = self.box[1]\r\n x2 = self.box[2]\r\n y2 = self.box[3]\r\n\r\n ## Find y coordinates\r\n # Initialize variables and sort pixels by x coordinate\r\n width = self.box[2] - self.box[0]\r\n cents = sorted(self.cluster, key = lambda u: u[1])\r\n clust = []\r\n curr = cents[0][1]\r\n last = 0\r\n\r\n # Split the pixels by x coordinate\r\n for p in range(len(cents)):\r\n if cents[p][1] != curr:\r\n clust.append(cents[last: p])\r\n curr = cents[p][1]\r\n last = p\r\n \r\n # Get the topmost y value which is <tightness> green\r\n for hor in clust:\r\n if len(hor) / width > tightness:\r\n y1 = hor[0][1]\r\n break\r\n\r\n # Get the bottommost y value which is <tightness> green\r\n for hor in clust[::-1]:\r\n if len(hor) / width > tightness:\r\n y2 = hor[0][1]\r\n break\r\n\r\n ## Find x coordinates\r\n # Initialize variables and sort pixels by y coordinate\r\n height = self.box[3] - self.box[1]\r\n cents = sorted(self.cluster, key = lambda u: u[0])\r\n clust = []\r\n curr = cents[0][0]\r\n last = 0\r\n\r\n # Split the pixels by y coordinate\r\n for p in range(len(cents)):\r\n if cents[p][0] != curr:\r\n clust.append(cents[last: p])\r\n curr = cents[p][0]\r\n last = p\r\n\r\n # Get the leftmost x value which is <tightness> green\r\n for ver in clust:\r\n if len(ver) / height > tightness:\r\n x1 = ver[0][0]\r\n break\r\n\r\n # Get the rightmost x value which is <tightness> green\r\n for ver in clust[::-1]:\r\n if len(ver) / height > tightness:\r\n x2 = ver[0][0]\r\n break\r\n\r\n # Default to original x values if no better estimate was found\r\n if x1 == x2:\r\n x1 = self.box[0]\r\n x2 = self.box[2]\r\n\r\n # Default to original y values if no better estimate was found\r\n if y1 == y2:\r\n y1 = self.box[1]\r\n y2 = self.box[3]\r\n\r\n self.tight_box = (x1, y1, x2, y2)","def create_wall_shape(self):\n self.shape_walls = arcade.ShapeElementList()\n self.shape_walls.center_x = 0\n self.shape_walls.center_y = 0\n self.shape_walls.angle = 0\n\n point_list = []\n color_list = []\n \n # create the walls into a single shape\n walls = self.game.walls\n for wall in walls:\n points = self.get_entity_dimensions(wall)\n point_list.append(points[0])\n point_list.append(points[1])\n point_list.append(points[2])\n point_list.append(points[3])\n \n # as we have 4 points\n for i in range(4):\n color_list.append(COLOUR_MAP[wall.base_colour])\n \n self.shape_walls.append(\n arcade.create_rectangles_filled_with_colors(point_list, color_list)\n )","def build_lens_icosahedron(kabamland, vtx, rad, diameter_ratio, thickness_ratio, half_EPD, blockers=True, blocker_thickness_ratio=1.0/1000, light_confinement=False, focal_length=1.0, lens_system_name=None):\n # Get the list of lens meshes from the appropriate lens system as well as the lens material'''\n scale_rad = rad*diameter_ratio #max_radius->rad of the lens assembly\n lenses = lenssystem.get_lens_mesh_list(lens_system_name, scale_rad)\n lensmat = lenssystem.get_lens_material(lens_system_name)\n face = None\n for lns in lenses:\n #lns = mh.rotate(lns,make_rotation_matrix(ph,ax))\n if not face:\n face = Solid(lns, lensmat, kabamland.detector_material)\n else:\n face += Solid(lns, lensmat, kabamland.detector_material)\n\n if light_confinement:\n shield = mh.rotate(cylindrical_shell(rad*(1 - 0.001), rad, focal_length,32), make_rotation_matrix(np.pi/2.0, (1,0,0)))\n baffle = Solid(shield, lensmat, kabamland.detector_material, black_surface, 0xff0000)\n\n if blockers:\n blocker_thickness = 2*rad*blocker_thickness_ratio\n if half_EPD < rad:\n c1 = lenssystem.get_lens_sys(lens_system_name).c1*lenssystem.get_scale_factor(lens_system_name,scale_rad)\n offset = [0,0,c1-np.sqrt(c1*c1-rad*rad)]\n anulus_blocker = mh.shift(mh.rotate(cylindrical_shell(half_EPD, rad, blocker_thickness, 32), make_rotation_matrix(np.pi/2.0, (1,0,0))),offset)\n face += Solid(anulus_blocker, lensmat, kabamland.detector_material, black_surface, 0xff0000)\n phi, axs = rot_axis([0,0,1],vtx)\n for vx,ph,ax in zip(vtx,-phi,axs):\n kabamland.add_solid(face, rotation=make_rotation_matrix(ph,ax), displacement = -vx)\n if light_confinement:\n kabamland.add_solid(baffle, rotation=make_rotation_matrix(ph,ax), displacement = -normalize(vx)*(np.linalg.norm(vx)+focal_length/2.0))","def flattener(image, pts, w, h):\n temp_rect = np.zeros((4,2), dtype = \"float32\")\n \n s = np.sum(pts, axis = 2)\n\n tl = pts[np.argmin(s)]\n br = pts[np.argmax(s)]\n\n diff = np.diff(pts, axis = -1)\n tr = pts[np.argmin(diff)]\n bl = pts[np.argmax(diff)]\n\n if w <= 0.8 * h: # If card is vertically oriented\n temp_rect[0] = tl\n temp_rect[1] = tr\n temp_rect[2] = br\n temp_rect[3] = bl\n\n if w >= 1.2 * h: # If card is horizontally oriented\n temp_rect[0] = bl\n temp_rect[1] = tl\n temp_rect[2] = tr\n temp_rect[3] = br\n\n if w > 0.8 * h and w < 1.2 * h: #If card is diamond oriented\n # If furthest left point is higher than furthest right point,\n # card is tilted to the left.\n if pts[1][0][1] <= pts[3][0][1]:\n # If card is titled to the left, approxPolyDP returns points\n # in this order: top right, top left, bottom left, bottom right\n temp_rect[0] = pts[1][0] # Top left\n temp_rect[1] = pts[0][0] # Top right\n temp_rect[2] = pts[3][0] # Bottom right\n temp_rect[3] = pts[2][0] # Bottom left\n\n # If furthest left point is lower than furthest right point,\n # card is tilted to the right\n if pts[1][0][1] > pts[3][0][1]:\n # If card is titled to the right, approxPolyDP returns points\n # in this order: top left, bottom left, bottom right, top right\n temp_rect[0] = pts[0][0] # Top left\n temp_rect[1] = pts[3][0] # Top right\n temp_rect[2] = pts[2][0] # Bottom right\n temp_rect[3] = pts[1][0] # Bottom left\n \n # Create destination array, calculate perspective transform matrix,\n # and warp card image\n dst = np.array([[0, 0], [MAXWIDTH - 1, 0], [MAXWIDTH - 1, MAXHEIGHT - 1], [0, MAXHEIGHT - 1]], np.float32)\n M = cv2.getPerspectiveTransform(temp_rect, dst)\n warp = cv2.warpPerspective(image, M, (MAXWIDTH, MAXHEIGHT))\n\n return warp","def is_ccw(points):\n points = np.asanyarray(points, dtype=np.float64)\n\n if (len(points.shape) != 2 or\n points.shape[1] != 2):\n raise ValueError('CCW is only defined for 2D')\n xd = np.diff(points[:, 0])\n yd = np.column_stack((\n points[:, 1],\n points[:, 1])).reshape(-1)[1:-1].reshape((-1, 2)).sum(axis=1)\n area = np.sum(xd * yd) * .5\n ccw = area < 0\n\n return ccw","def create_ring(self):\n\t\tself.north_coords = numpy.add(self.center, self.north)\n\t\tself.northeast_coords = numpy.add(self.center, self.northeast)\n\t\tself.east_coords = numpy.add(self.center, self.east)\n\t\tself.southeast_coords = numpy.add(self.center, self.southeast)\n\t\tself.south_coords = numpy.add(self.center, self.south)\n\t\tself.southwest_coords = numpy.add(self.center, self.southwest)\n\t\tself.west_coords = numpy.add(self.center, self.west)\n\t\tself.northwest_coords = numpy.add(self.center, self.northwest)","def isValidPcbShape(g):\n return g.GetShape() != pcbnew.S_SEGMENT or g.GetLength() > 0","def draw_arc_filled(center_x, center_y,\n width, height,\n color,\n start_angle, end_angle,\n tilt_angle=0):\n num_segments = 128\n GL.glEnable(GL.GL_BLEND)\n GL.glBlendFunc(GL.GL_SRC_ALPHA, GL.GL_ONE_MINUS_SRC_ALPHA)\n GL.glEnable(GL.GL_LINE_SMOOTH)\n GL.glHint(GL.GL_LINE_SMOOTH_HINT, GL.GL_NICEST)\n GL.glHint(GL.GL_POLYGON_SMOOTH_HINT, GL.GL_NICEST)\n\n GL.glLoadIdentity()\n GL.glTranslatef(center_x, center_y, 0)\n GL.glRotatef(tilt_angle, 0, 0, 1)\n\n # Set color\n if len(color) == 4:\n GL.glColor4ub(color[0], color[1], color[2], color[3])\n elif len(color) == 3:\n GL.glColor4ub(color[0], color[1], color[2], 255)\n\n GL.glBegin(GL.GL_TRIANGLE_FAN)\n\n start_segment = int(start_angle / 360 * num_segments)\n end_segment = int(end_angle / 360 * num_segments)\n GL.glVertex3f(0, 0, 0.5)\n\n for segment in range(start_segment, end_segment + 1):\n theta = 2.0 * 3.1415926 * segment / num_segments\n\n x = width * math.cos(theta)\n y = height * math.sin(theta)\n\n GL.glVertex3f(x, y, 0.5)\n\n GL.glEnd()\n GL.glLoadIdentity()","def concave_hull(hull:list, points:list, max_iterations:int=None, min_length_fraction:float=0, min_angle:float=90)->list:\n tweet.info(\"Creating concave hull; minimum side length {}% of average, minimum_angle {}\".format(min_length_fraction * 100, min_angle))\n test_points = set(points)\n ignore_points = []\n avg_sqr_distance = 0\n for k in range(0, len(hull)-1):\n avg_sqr_distance += point_sqr_distance(hull[k], hull[k+1])\n test_points.remove(hull[k])\n avg_sqr_distance /= len(hull) - 1\n min_sqr_length = avg_sqr_distance * (min_length_fraction ** 2) # since we get sqr_length, we square the fraction\n min_cosine = math.cos(math.radians(min_angle))\n \n while (max_iterations is None or max_iterations > 0) and test_points:\n selection, edge = select_longest_edge(hull, ignore_points, min_sqr_length)\n tweet.info(\"Considering edge {}; {} points left\".format(edge, len(test_points)))\n if selection is None:\n break\n selected_point = select_candidate_point(edge, test_points, hull, min_cosine)\n if selected_point is None:\n # This edge has no more candidate points, so we ignore it in the next pass\n ignore_points.append(edge[0])\n tweet.debug(\"No candidate point found.\")\n continue\n tweet.debug(\"Found point {}, inserting new edge.\".format(selected_point))\n if not max_iterations is None:\n max_iterations -= 1\n # We add the point into the concave hull\n hull.insert(selection + 1, selected_point)\n test_points.remove(selected_point)\n return hull","def draw_boundary() -> None:\n # Upper edge\n print(rpipes.terminal.move_xy(0, 0), WBorder.HORIZONTAL * (rpipes.terminal.width - 1))\n\n # Left and Right edges\n for row in range(rpipes.terminal.height - 2):\n print(\n WBorder.VERTICAL,\n rpipes.terminal.move_right(rpipes.terminal.width - 4),\n WBorder.VERTICAL,\n )\n\n # Bottom edge\n print(\n rpipes.terminal.move_xy(0, rpipes.terminal.height - 2),\n WBorder.HORIZONTAL * (rpipes.terminal.width - 1),\n )\n\n # Top left corner\n print(rpipes.terminal.move_xy(0, 0) + WBorder.DOWN_AND_RIGHT)\n\n # Top right corner\n print(rpipes.terminal.move_xy(rpipes.terminal.width - 1, 0) + WBorder.DOWN_AND_LEFT)\n\n # Bottom left corner\n print(rpipes.terminal.move_xy(0, rpipes.terminal.height - 2) + WBorder.UP_AND_RIGHT)\n\n # Bottom right corner\n print(\n rpipes.terminal.move_xy(rpipes.terminal.width - 1, rpipes.terminal.height - 2)\n + WBorder.UP_AND_LEFT\n )","def make_path(self, loop):\n path=Path(closed=True)\n for c in range(0,len(loop)):\n connection=loop[c]\n nextConnection = loop[(c+1)%len(loop)]\n lastConnection = loop[(c-1)%len(loop)]\n if self.dontFill(connection, nextConnection, lastConnection):\n return False\n cp = self.corner_pos(connection, nextConnection, lastConnection)\n corner_offset = cp[0]\n corner_dir = cp[1]\n # catch case when it is the end of a single rod\n if type(corner_offset) is list:\n endpoints = corner_offset\n corner_offset = endpoints[0]\n else:\n endpoints = False\n if connection.other.radius is not None and ( corner_offset.length() < connection.other.radius or corner_dir >0):\n # catch case when it is the end of a single rod\n if endpoints:\n para=(connection.this.pos-connection.other.pos).normalize()\n d = math.sqrt(connection.other.radius**2 - corner_offset.length()**2)\n path.add_point(PSharp(connection.other.pos + corner_offset + d*para))\n path.add_point(PArc(connection.other.pos, radius=connection.other.radius, direction='cw'))\n path.add_point(PSharp(connection.other.pos - corner_offset+d*para))\n else:\n path.add_point(PAroundcurve(connection.other.pos + corner_offset, centre=connection.other.pos, radius=connection.other.radius, direction='cw'))\n\n elif self.get_intRadius(connection, connection.other) is not None:\n # path.add_point(PIncurve(connection.other.pos + corner_offset, radius=self.get_intRadius(connection, connection.other)))\n # path.add_point(PIncurve(connection.other.pos - corner_offset, radius=self.get_intRadius(connection, connection.other)))\n # path.add_point(PIncurve(connection.other.pos - corner_offset, radius=self.get_intRadius(connection, connection.other)))\n path.add_point(PIncurve(connection.other.pos + corner_offset, radius=self.get_intRadius(connection, connection.other)))\n else:\n cornerpos = self.corner_pos(connection, nextConnection, lastConnection)\n if type(cornerpos) is list:\n path.add_point(PSharp(connection.other.pos + cornerpos[0]))\n path.add_point(PSharp(connection.other.pos + cornerpos[1]))\n else:\n path.add_point(PSharp(connection.other.pos + cornerpos))#self.corner_pos(connection, nextConnection, lastConnection)))\n # path.add_point(PSharp(connection.other.pos - cornerpos))#self.corner_pos(connection, nextConnection, lastConnection)))\n if connection.other.holeRad is not None:\n if type(connection.other.holeRad) is int or type(connection.other.holeRad) is float:\n self.otherpaths.append(Circle(connection.other.pos, rad=connection.other.holeRad, side='in'))\n else:\n t=copy.deepcopy(connection.other.holeRad)\n t.translate(connection.other.pos)\n self.otherpaths.append(t)\n return path","def toShapely(ring, geometryList):\n outline = []\n for idxA, idxB in zip(ring, ring[1:] + ring[:1]):\n shape = geometryList[idxA].GetShape()\n if shape in [STROKE_T.S_ARC, STROKE_T.S_CIRCLE]:\n outline += approximateArc(geometryList[idxA],\n commonEndPoint(geometryList[idxA], geometryList[idxB]))\n elif shape in [STROKE_T.S_CURVE]:\n outline += approximateBezier(geometryList[idxA],\n commonEndPoint(geometryList[idxA], geometryList[idxB]))\n elif shape in [STROKE_T.S_RECT]:\n assert idxA == idxB\n outline += geometryList[idxA].GetRectCorners()\n elif shape in [STROKE_T.S_POLYGON]:\n # Polygons are always closed, so they should appear as stand-alone\n assert len(ring) in [1, 2]\n return shapePolyToShapely(geometryList[idxA].GetPolyShape())\n elif shape in [STROKE_T.S_SEGMENT]:\n outline.append(commonEndPoint(geometryList[idxA], geometryList[idxB]))\n else:\n raise RuntimeError(f\"Unsupported shape {shape} in outline\")\n return Polygon(outline)","def check_boundary(self,x):\n b_cells = np.zeros(self.n_c)\n b_cells[self.n_C:] = 1\n vBC = b_cells[self.tris]\n considered_triangles = vBC.sum(axis=1) == 2\n add_extra = ((self.Angles*(1-vBC)>np.pi/2).T*considered_triangles.T).T\n if add_extra.any():\n I,J = np.nonzero(add_extra)\n for k,i in enumerate(I):\n j = J[k]\n xs = x[self.tris[i]]\n re = xs[np.mod(j-1,3)] - xs[np.mod(j+1,3)]\n re = re/np.linalg.norm(re)\n re = np.array([re[1],-re[0]])\n rpe = xs[j]\n x_new = 2*np.dot(xs[np.mod(j-1,3)]-rpe,re)*re + rpe\n x = np.vstack((x,x_new))\n self.n_c = x.shape[0]\n self._triangulate(x)\n self.assign_vertices()\n\n C = get_C_boundary(self.n_c,self.CV_matrix)\n #\n # #Remove extra cells\n # keep_mask = C[self.n_C:, :self.n_C].sum(axis=1)>0 #I'm assuming this is the same thing. This removes all boundary centroids that are not connected to at least one real centroid.\n # if keep_mask.any():\n # c_keep = np.nonzero(keep_mask)[0]\n # x = np.concatenate((x[:self.n_C],x[c_keep + self.n_C]))\n # self.n_c = x.shape[0]\n # self._triangulate(x)\n # self.assign_vertices()\n #\n\n #Remove all boundary particles not connected to exactly two other boundary particles\n remove_mask = C[self.n_C:, self.n_C:].sum(axis=1)!=2\n if remove_mask.any():\n c_keep = np.nonzero(~remove_mask)[0]\n x = np.concatenate((x[:self.n_C],x[c_keep + self.n_C]))\n self.n_c = x.shape[0]\n self._triangulate(x)\n self.assign_vertices()\n self.Angles = tri_angles(x, self.tris)\n #\n # remove_mask = C[self.n_C:, self.n_C:].sum(axis=1)==0\n # if remove_mask.any():\n # c_keep = np.nonzero(~remove_mask)[0]\n # x = np.concatenate((x[:self.n_C],x[c_keep + self.n_C]))\n # self.n_c = x.shape[0]\n # self._triangulate(x)\n # self.assign_vertices()\n # self.Angles = tri_angles(x, self.tris)\n\n\n return x","def _proc_polygon(self, tokens, filled):\n\n pts = [(p[\"x\"], p[\"y\"]) for p in tokens[\"points\"]]\n component = Polygon(pen=self.pen, points=pts, filled=filled)\n\n return component","def Cool_per_Grain(grain_size, grain_type, ZZ, fdist, ntot, xe, temp):\n import numpy as np\n import math\n import compute_charge_dist as fz\n \n tau = grain_size * fz.AAtocm * fz.kb * temp / fz.echarge**2\n \n # Loop over species!\n Cool_spec = 0\n for partner in [\"electron\", \"hydrogen\", \"carbon\"]:\n \n Cool_Zall = 0\n # Loop over charge\n for zi in range(len(ZZ)):\n \n if partner == \"electron\":\n nu = -1*ZZ[zi]\n stick_coef = fz.get_stickCoef(ZZ[zi], grain_size, grain_type)\n charge_frac = xe\n mass = fz.me\n \n elif partner == \"hydrogen\":\n nu = ZZ[zi]\n stick_coef = 1.0\n charge_frac = xe\n mass = fz.mH\n \n elif partner == \"carbon\":\n nu = ZZ[zi]\n stick_coef = 1.0\n # Maximum fraction of ionized Carbon is 1e-4*ntot.\n charge_frac = min(1.0e-4, xe)\n mass = fz.mC\n \n Cooltilde = 1.0\n \n if nu < 0:\n Cooltilde = fz.Jtilde_neg(tau, nu)\n elif nu == 0:\n Cooltilde = fz.Jtilde_0(tau, nu)\n else:\n Cooltilde = fz.Jtilde_pos(tau, nu)\n \n #print(zi)\n Cool_Zhere = fdist[zi]*Cooltilde*fz.kb*temp\n Cool_Zall += Cool_Zhere\n \n #print(\"Collisional Partner = \", partner)\n Cool_spec += ntot*charge_frac*stick_coef*np.sqrt(8.0*fz.kb*temp/(np.pi*mass))*Cool_Zall\n \n Cool_tot = math.pi * (grain_size*AAtocm)**2 * Cool_spec\n \n return Cool_tot","def roof_cc(lenght, width, overhang=1, wall_height=3, roof_height=4):\n a = min(0.1 * lenght, 0.1 * width, 0.4 * (wall_height + 0.5 * roof_height))\n\n area = (lenght + overhang)*(width + overhang)\n area_3 = 8*a**2\n area_1 = (lenght - 2)*(width - 4*a)\n area_2 = area - area_3 - area_1\n return area, area_1, area_2, area_3","def create_rink():\n\n # RINK\n coords = OFFSET, OFFSET, OFFSET+22*SCALE, OFFSET+22*SCALE\n canvas.create_arc(coords, start=90, extent=90, fill=WHITE, outline=\"\")\n coords = OFFSET, HEIGHT-OFFSET-22*SCALE, OFFSET+22*SCALE, HEIGHT-OFFSET\n canvas.create_arc(coords, start=180, extent=90, fill=WHITE, outline=WHITE)\n coords = WIDTH-OFFSET-22*SCALE, HEIGHT-OFFSET-22*SCALE, WIDTH-OFFSET, HEIGHT-OFFSET\n canvas.create_arc(coords, start=270, extent=90, fill=WHITE, outline=WHITE)\n coords = WIDTH-OFFSET-22*SCALE, OFFSET, WIDTH-OFFSET, OFFSET+22*SCALE\n canvas.create_arc(coords, start=0, extent=90, fill=WHITE, outline=WHITE)\n coords = OFFSET+11*SCALE, OFFSET, WIDTH-OFFSET-11*SCALE, OFFSET, WIDTH-OFFSET-11*SCALE, HEIGHT-OFFSET, OFFSET+11*SCALE, HEIGHT-OFFSET\n canvas.create_polygon(coords, fill=WHITE, outline=WHITE)\n coords = OFFSET, OFFSET+11*SCALE, WIDTH-OFFSET, OFFSET+11*SCALE, WIDTH-OFFSET, HEIGHT-OFFSET-11*SCALE, OFFSET, HEIGHT-OFFSET-11*SCALE\n canvas.create_polygon(coords, fill=WHITE, outline=WHITE)\n\n # CENTER CIRCLE\n coords = WIDTH/2-15*SCALE, HEIGHT/2-15*SCALE, WIDTH/2+15*SCALE, HEIGHT/2+15*SCALE\n canvas.create_oval(coords, outline=BLUE, width=2, fill=WHITE)\n\n # HALF CENTER CIRCLE\n coords = WIDTH/2-10*SCALE, HEIGHT-OFFSET-10*SCALE, WIDTH/2+10*SCALE, HEIGHT-OFFSET+10*SCALE\n canvas.create_arc(coords, outline=RED, width=2, start=0, extent=180)\n\n # GOAL AREA\n # - Left\n # - - Crease\n coords = OFFSET+5*SCALE, HEIGHT/2-6*SCALE, OFFSET+17*SCALE, HEIGHT/2+6*SCALE\n canvas.create_arc(coords, fill=LIGHT_BLUE, start=318, extent=84, outline=\"\")\n canvas.create_arc(coords, outline=RED, start=318, extent=84, style=ARC)\n coords = OFFSET+11*SCALE, HEIGHT/2-4*SCALE, OFFSET+15.5*SCALE, HEIGHT/2-4*SCALE, OFFSET+15.5*SCALE, HEIGHT/2+4*SCALE, OFFSET+11*SCALE, HEIGHT/2+4*SCALE\n canvas.create_polygon(coords, fill=LIGHT_BLUE, outline=\"\")\n coords = OFFSET+11*SCALE, HEIGHT/2-4*SCALE, OFFSET+15.2*SCALE+1, HEIGHT/2-4*SCALE\n canvas.create_line(coords, fill=RED)\n coords = OFFSET+15.2*SCALE+1, HEIGHT/2+4*SCALE, OFFSET+11*SCALE, HEIGHT/2+4*SCALE\n canvas.create_line(coords, fill=RED)\n # - - Restricted Area\n coords = OFFSET, HEIGHT/2-14*SCALE, OFFSET+11*SCALE, HEIGHT/2-9*SCALE\n canvas.create_line(coords, fill=RED)\n coords = OFFSET, HEIGHT/2+14*SCALE, OFFSET+11*SCALE, HEIGHT/2+9*SCALE\n canvas.create_line(coords, fill=RED)\n # - - Goal\n coords = OFFSET+8*SCALE, HEIGHT/2-3*SCALE, OFFSET+11*SCALE, HEIGHT/2-3*SCALE, OFFSET+11*SCALE, HEIGHT/2+3*SCALE, OFFSET+8*SCALE, HEIGHT/2+3*SCALE\n canvas.create_polygon(coords, fill=GRAY, outline=RED)\n # - Right\n # - - Crease\n coords = WIDTH-(OFFSET+5*SCALE), HEIGHT/2-6*SCALE, WIDTH-(OFFSET+17*SCALE), HEIGHT/2+6*SCALE\n canvas.create_arc(coords, fill=LIGHT_BLUE, start=138, extent=84, outline=\"\")\n canvas.create_arc(coords, outline=RED, start=138, extent=84, style=ARC)\n coords = WIDTH-(OFFSET+11*SCALE), HEIGHT/2-4*SCALE, WIDTH-(OFFSET+15.5*SCALE), HEIGHT/2-4*SCALE, WIDTH-(OFFSET+15.5*SCALE), HEIGHT/2+4*SCALE, WIDTH-(OFFSET+11*SCALE), HEIGHT/2+4*SCALE\n canvas.create_polygon(coords, fill=LIGHT_BLUE, outline=\"\")\n coords = WIDTH-(OFFSET+11*SCALE), HEIGHT/2-4*SCALE, WIDTH-(OFFSET+15.2*SCALE+1), HEIGHT/2-4*SCALE\n canvas.create_line(coords, fill=RED)\n coords = WIDTH-(OFFSET+15.2*SCALE+1), HEIGHT/2+4*SCALE, WIDTH-(OFFSET+11*SCALE), HEIGHT/2+4*SCALE\n canvas.create_line(coords, fill=RED)\n # - - Restricted Area\n coords = WIDTH-OFFSET, HEIGHT/2-14*SCALE, WIDTH-OFFSET-11*SCALE, HEIGHT/2-9*SCALE\n canvas.create_line(coords, fill=RED)\n coords = WIDTH-OFFSET, HEIGHT/2+14*SCALE, WIDTH-OFFSET-11*SCALE, HEIGHT/2+9*SCALE\n canvas.create_line(coords, fill=RED)\n # - - Goal\n coords = WIDTH-(OFFSET+8*SCALE), HEIGHT/2-3*SCALE, WIDTH-(OFFSET+11*SCALE), HEIGHT/2-3*SCALE, WIDTH-(OFFSET+11*SCALE), HEIGHT/2+3*SCALE, WIDTH-(OFFSET+8*SCALE), HEIGHT/2+3*SCALE\n canvas.create_polygon(coords, fill=GRAY, outline=RED)\n\n # LINES\n # - Left Baseline\n coords = OFFSET+11*SCALE, OFFSET, OFFSET+11*SCALE, HEIGHT-OFFSET\n canvas.create_line(coords, fill=RED, width=1.5)\n # - Right Baseline\n coords = WIDTH-OFFSET-11*SCALE, OFFSET, WIDTH-OFFSET-11*SCALE, HEIGHT-OFFSET\n canvas.create_line(coords, fill=RED, width=1.5)\n # - Left Blueline\n coords = OFFSET+70*SCALE, OFFSET, OFFSET+70*SCALE, HEIGHT-OFFSET\n canvas.create_line(coords, fill=BLUE, width=7)\n # - Right Blueline\n coords = WIDTH-(OFFSET+70*SCALE), OFFSET, WIDTH-(OFFSET+70*SCALE), HEIGHT-OFFSET\n canvas.create_line(coords, fill=BLUE, width=7)\n # - Redline\n coords = WIDTH/2, OFFSET, WIDTH/2, HEIGHT-OFFSET\n canvas.create_line(coords, fill=RED, width=7)\n coords = WIDTH/2, OFFSET, WIDTH/2, HEIGHT-OFFSET\n canvas.create_line(coords, fill=WHITE, width=5, dash=(9,9))\n\n # RINK OUTLINE\n coords = OFFSET, OFFSET, OFFSET+22*SCALE, OFFSET+22*SCALE\n canvas.create_arc(coords, start=90, extent=90, outline=BLACK, style=ARC, width=2)\n coords = OFFSET, HEIGHT-OFFSET-22*SCALE, OFFSET+22*SCALE, HEIGHT-OFFSET\n canvas.create_arc(coords, start=180, extent=90, outline=BLACK, style=ARC, width=2)\n coords = WIDTH-OFFSET-22*SCALE, HEIGHT-OFFSET-22*SCALE, WIDTH-OFFSET, HEIGHT-OFFSET\n canvas.create_arc(coords, start=270, extent=90, outline=BLACK, style=ARC, width=2)\n coords = WIDTH-OFFSET-22*SCALE, OFFSET, WIDTH-OFFSET, OFFSET+22*SCALE\n canvas.create_arc(coords, start=0, extent=90, outline=BLACK, style=ARC, width=2)\n coords = OFFSET+11*SCALE, OFFSET, WIDTH-OFFSET-11*SCALE, OFFSET\n canvas.create_line(coords, fill=BLACK, width=2)\n coords = WIDTH-OFFSET, OFFSET+11*SCALE, WIDTH-OFFSET, HEIGHT-OFFSET-11*SCALE\n canvas.create_line(coords, fill=BLACK, width=2)\n coords = WIDTH-OFFSET-11*SCALE, HEIGHT-OFFSET, OFFSET+11*SCALE, HEIGHT-OFFSET\n canvas.create_line(coords, fill=BLACK, width=2)\n coords = OFFSET, OFFSET+11*SCALE, OFFSET, HEIGHT-OFFSET-11*SCALE\n canvas.create_line(coords, fill=BLACK, width=2)\n\n\n # CENTER DOT\n coords = WIDTH/2-1*SCALE-1, HEIGHT/2-1*SCALE-1, WIDTH/2+1*SCALE+1, HEIGHT/2+1*SCALE+1\n canvas.create_oval(coords, outline=WHITE, fill=BLUE)\n\n # FACEOFF\n # - Top Left\n # - - Ticks\n coords = OFFSET+29.5*SCALE, HEIGHT/2-39*SCALE, OFFSET+29.5*SCALE, HEIGHT/2-5*SCALE\n canvas.create_line(coords, fill=RED, width=2)\n coords = OFFSET+32.5*SCALE, HEIGHT/2-39*SCALE, OFFSET+32.5*SCALE, HEIGHT/2-5*SCALE\n canvas.create_line(coords, fill=RED, width=2)\n # - - Circles\n coords = OFFSET+16*SCALE, HEIGHT/2-37*SCALE, OFFSET+46*SCALE, HEIGHT/2-7*SCALE\n canvas.create_oval(coords, outline=RED, width=2, fill=WHITE)\n coords = OFFSET+30*SCALE, HEIGHT/2-23*SCALE, OFFSET+32*SCALE, HEIGHT/2-21*SCALE\n canvas.create_oval(coords, fill=RED, outline=\"\")\n # - - Cross\n coords = OFFSET+25*SCALE, HEIGHT/2-22.8*SCALE, OFFSET+29*SCALE, HEIGHT/2-22.8*SCALE, OFFSET+29*SCALE, HEIGHT/2-25.8*SCALE\n canvas.create_line(coords, fill=RED, width=2)\n coords = OFFSET+25*SCALE, HEIGHT/2-21.2*SCALE, OFFSET+29*SCALE, HEIGHT/2-21.2*SCALE, OFFSET+29*SCALE, HEIGHT/2-18.2*SCALE\n canvas.create_line(coords, fill=RED, width=2)\n coords = OFFSET+37*SCALE, HEIGHT/2-22.8*SCALE, OFFSET+33*SCALE, HEIGHT/2-22.8*SCALE, OFFSET+33*SCALE, HEIGHT/2-25.8*SCALE\n canvas.create_line(coords, fill=RED, width=2)\n coords = OFFSET+37*SCALE, HEIGHT/2-21.2*SCALE, OFFSET+33*SCALE, HEIGHT/2-21.2*SCALE, OFFSET+33*SCALE, HEIGHT/2-18.2*SCALE\n canvas.create_line(coords, fill=RED, width=2)\n # - Bottom Left\n # - - Ticks\n coords = OFFSET+29.5*SCALE, HEIGHT/2+39*SCALE, OFFSET+29.5*SCALE, HEIGHT/2+5*SCALE\n canvas.create_line(coords, fill=RED, width=2)\n coords = OFFSET+32.5*SCALE, HEIGHT/2+39*SCALE, OFFSET+32.5*SCALE, HEIGHT/2+5*SCALE\n canvas.create_line(coords, fill=RED, width=2)\n # - - Circles\n coords = OFFSET+16*SCALE, HEIGHT/2+37*SCALE, OFFSET+46*SCALE, HEIGHT/2+7*SCALE\n canvas.create_oval(coords, outline=RED, width=2, fill=WHITE)\n coords = OFFSET+30*SCALE, HEIGHT/2+23*SCALE, OFFSET+32*SCALE, HEIGHT/2+21*SCALE\n canvas.create_oval(coords, fill=RED, outline=\"\")\n # - - Cross\n coords = OFFSET+25*SCALE, HEIGHT/2+22.8*SCALE, OFFSET+29*SCALE, HEIGHT/2+22.8*SCALE, OFFSET+29*SCALE, HEIGHT/2+25.8*SCALE\n canvas.create_line(coords, fill=RED, width=2)\n coords = OFFSET+25*SCALE, HEIGHT/2+21.2*SCALE, OFFSET+29*SCALE, HEIGHT/2+21.2*SCALE, OFFSET+29*SCALE, HEIGHT/2+18.2*SCALE\n canvas.create_line(coords, fill=RED, width=2)\n coords = OFFSET+37*SCALE, HEIGHT/2+22.8*SCALE, OFFSET+33*SCALE, HEIGHT/2+22.8*SCALE, OFFSET+33*SCALE, HEIGHT/2+25.8*SCALE\n canvas.create_line(coords, fill=RED, width=2)\n coords = OFFSET+37*SCALE, HEIGHT/2+21.2*SCALE, OFFSET+33*SCALE, HEIGHT/2+21.2*SCALE, OFFSET+33*SCALE, HEIGHT/2+18.2*SCALE\n canvas.create_line(coords, fill=RED, width=2)\n # - Top Right\n # - - Ticks\n coords = WIDTH-(OFFSET+29.5*SCALE), HEIGHT/2-39*SCALE, WIDTH-(OFFSET+29.5*SCALE), HEIGHT/2-5*SCALE\n canvas.create_line(coords, fill=RED, width=2)\n coords = WIDTH-(OFFSET+32.5*SCALE), HEIGHT/2-39*SCALE, WIDTH-(OFFSET+32.5*SCALE), HEIGHT/2-5*SCALE\n canvas.create_line(coords, fill=RED, width=2)\n # - - Circles\n coords = WIDTH-(OFFSET+16*SCALE), HEIGHT/2-37*SCALE, WIDTH-(OFFSET+46*SCALE), HEIGHT/2-7*SCALE\n canvas.create_oval(coords, outline=RED, width=2, fill=WHITE)\n coords = WIDTH-(OFFSET+30*SCALE), HEIGHT/2-23*SCALE, WIDTH-(OFFSET+32*SCALE), HEIGHT/2-21*SCALE\n canvas.create_oval(coords, fill=RED, outline=\"\")\n # - - Cross\n coords = WIDTH-(OFFSET+25*SCALE), HEIGHT/2-22.8*SCALE, WIDTH-(OFFSET+29*SCALE), HEIGHT/2-22.8*SCALE, WIDTH-(OFFSET+29*SCALE), HEIGHT/2-25.8*SCALE\n canvas.create_line(coords, fill=RED, width=2)\n coords = WIDTH-(OFFSET+25*SCALE), HEIGHT/2-21.2*SCALE, WIDTH-(OFFSET+29*SCALE), HEIGHT/2-21.2*SCALE, WIDTH-(OFFSET+29*SCALE), HEIGHT/2-18.2*SCALE\n canvas.create_line(coords, fill=RED, width=2)\n coords = WIDTH-(OFFSET+37*SCALE), HEIGHT/2-22.8*SCALE, WIDTH-(OFFSET+33*SCALE), HEIGHT/2-22.8*SCALE, WIDTH-(OFFSET+33*SCALE), HEIGHT/2-25.8*SCALE\n canvas.create_line(coords, fill=RED, width=2)\n coords = WIDTH-(OFFSET+37*SCALE), HEIGHT/2-21.2*SCALE, WIDTH-(OFFSET+33*SCALE), HEIGHT/2-21.2*SCALE, WIDTH-(OFFSET+33*SCALE), HEIGHT/2-18.2*SCALE\n canvas.create_line(coords, fill=RED, width=2)\n # - Bottom Right\n # - - Ticks\n coords = WIDTH-(OFFSET+29.5*SCALE), HEIGHT/2+39*SCALE, WIDTH-(OFFSET+29.5*SCALE), HEIGHT/2+5*SCALE\n canvas.create_line(coords, fill=RED, width=2)\n coords = WIDTH-(OFFSET+32.5*SCALE), HEIGHT/2+39*SCALE, WIDTH-(OFFSET+32.5*SCALE), HEIGHT/2+5*SCALE\n canvas.create_line(coords, fill=RED, width=2)\n # - - Circles\n coords = WIDTH-(OFFSET+16*SCALE), HEIGHT/2+37*SCALE, WIDTH-(OFFSET+46*SCALE), HEIGHT/2+7*SCALE\n canvas.create_oval(coords, outline=RED, width=2, fill=WHITE)\n coords = WIDTH-(OFFSET+30*SCALE), HEIGHT/2+23*SCALE, WIDTH-(OFFSET+32*SCALE), HEIGHT/2+21*SCALE\n canvas.create_oval(coords, fill=RED, outline=\"\")\n # - - Cross\n coords = WIDTH-(OFFSET+25*SCALE), HEIGHT/2+22.8*SCALE, WIDTH-(OFFSET+29*SCALE), HEIGHT/2+22.8*SCALE, WIDTH-(OFFSET+29*SCALE), HEIGHT/2+25.8*SCALE\n canvas.create_line(coords, fill=RED, width=2)\n coords = WIDTH-(OFFSET+25*SCALE), HEIGHT/2+21.2*SCALE, WIDTH-(OFFSET+29*SCALE), HEIGHT/2+21.2*SCALE, WIDTH-(OFFSET+29*SCALE), HEIGHT/2+18.2*SCALE\n canvas.create_line(coords, fill=RED, width=2)\n coords = WIDTH-(OFFSET+37*SCALE), HEIGHT/2+22.8*SCALE, WIDTH-(OFFSET+33*SCALE), HEIGHT/2+22.8*SCALE, WIDTH-(OFFSET+33*SCALE), HEIGHT/2+25.8*SCALE\n canvas.create_line(coords, fill=RED, width=2)\n coords = WIDTH-(OFFSET+37*SCALE), HEIGHT/2+21.2*SCALE, WIDTH-(OFFSET+33*SCALE), HEIGHT/2+21.2*SCALE, WIDTH-(OFFSET+33*SCALE), HEIGHT/2+18.2*SCALE\n canvas.create_line(coords, fill=RED, width=2)\n\n # NEUTRAL ZONE FACEOFF\n # - Top Left\n coords = WIDTH/2-21*SCALE, HEIGHT/2-23*SCALE, WIDTH/2-19*SCALE, HEIGHT/2-21*SCALE\n canvas.create_oval(coords, outline=\"\", fill=RED)\n # - Bottom Left\n coords = WIDTH/2-21*SCALE, HEIGHT/2+23*SCALE, WIDTH/2-19*SCALE, HEIGHT/2+21*SCALE\n canvas.create_oval(coords, outline=\"\", fill=RED)\n # - Top Right\n coords = WIDTH/2+21*SCALE, HEIGHT/2-23*SCALE, WIDTH/2+19*SCALE, HEIGHT/2-21*SCALE\n canvas.create_oval(coords, outline=\"\", fill=RED)\n # - Bottom Right\n coords = WIDTH/2+21*SCALE, HEIGHT/2+23*SCALE, WIDTH/2+19*SCALE, HEIGHT/2+21*SCALE\n canvas.create_oval(coords, outline=\"\", fill=RED)\n\n\n canvas.grid(row=1, columnspan=5)","def ring(radius = 10, width = 0.5, angle_resolution = 2.5, layer = 0):\n D = Device(name = 'ring')\n inner_radius = radius - width/2\n outer_radius = radius + width/2\n n = int(np.round(360/angle_resolution))\n t = np.linspace(0, 360, n+1) * pi/180\n inner_points_x = (inner_radius*cos(t)).tolist()\n inner_points_y = (inner_radius*sin(t)).tolist()\n outer_points_x = (outer_radius*cos(t)).tolist()\n outer_points_y = (outer_radius*sin(t)).tolist()\n xpts = inner_points_x + outer_points_x[::-1]\n ypts = inner_points_y + outer_points_y[::-1]\n D.add_polygon(points = (xpts, ypts), layer = layer)\n return D","def create_surface(self):\n oval = graphics.Oval(graphics.Point(5,0), graphics.Point(300, -10))\n oval.setFill(\"gray\")\n return oval","def test_random_polygon(self):\n p = g.trimesh.path.polygons.random_polygon()\n assert p.area > 0.0\n assert p.is_valid","def boundary_polygon(self, time):\n ti = np.where(time == self.times)[0][0]\n com_x, com_y = self.center_of_mass(time)\n # If at least one point along perimeter of the mask rectangle is unmasked, find_boundaries() works.\n # But if all perimeter points are masked, find_boundaries() does not find the object.\n # Therefore, pad the mask with zeroes first and run find_boundaries on the padded array.\n padded_mask = np.pad(self.masks[ti], 1, 'constant', constant_values=0)\n chull = convex_hull_image(padded_mask)\n boundary_image = find_boundaries(chull, mode='inner', background=0)\n # Now remove the padding.\n boundary_image = boundary_image[1:-1, 1:-1]\n boundary_x = self.x[ti].ravel()[boundary_image.ravel()]\n boundary_y = self.y[ti].ravel()[boundary_image.ravel()]\n r = np.sqrt((boundary_x - com_x) ** 2 + (boundary_y - com_y) ** 2)\n theta = np.arctan2((boundary_y - com_y), (boundary_x - com_x)) * 180.0 / np.pi + 360\n polar_coords = np.array([(r[x], theta[x]) for x in range(r.size)], dtype=[('r', 'f4'), ('theta', 'f4')])\n coord_order = np.argsort(polar_coords, order=['theta', 'r'])\n ordered_coords = np.vstack([boundary_x[coord_order], boundary_y[coord_order]])\n return ordered_coords","def optimal_polygon(y, w=0.5, debug=False):\n # Make sure that we use numpy array\n y = np.array(y)\n x = np.arange(len(y))\n\n # Initialization\n y = np.round(y, 6)\n p_plus = (x[0], y[0] + w)\n l_plus = (x[0], y[0] + w)\n r_plus = (x[1], y[1] + w)\n s_plus = {(x[0], y[0] + w): (x[1], y[1] + w)}\n t_plus = {(x[1], y[1] + w): (x[0], y[0] + w)}\n p_minus = (x[0], y[0] - w)\n l_minus = (x[0], y[0] - w)\n r_minus = (x[1], y[1] - w)\n s_minus = {(x[0], y[0] - w): (x[1], y[1] - w)}\n t_minus = {(x[1], y[1] - w): (x[0], y[0] - w)}\n q = []\n i = 2\n\n while i < len(y):\n # Updating CH_plus (convex hull) and CH_minus\n p = (x[i - 1], y[i - 1] + w)\n p_i_plus = (x[i], y[i] + w)\n while (p != p_plus) and _angle(p_i_plus, p, t_plus[p], '+') > np.pi:\n p = t_plus[p]\n s_plus[p] = p_i_plus\n t_plus[p_i_plus] = p\n\n p = (x[i - 1], y[i - 1] - w)\n p_i_minus = (x[i], y[i] - w)\n while (p != p_minus) and _angle(p_i_minus, p, t_minus[p], '-') > np.pi:\n p = t_minus[p]\n s_minus[p] = p_i_minus\n t_minus[p_i_minus] = p\n\n # Check if CH_plus and CH_minus intersect\n if _angle(p_i_plus, l_plus, r_minus, '+') < np.pi:\n q.append((_intersect(l_plus, r_minus, p_plus, p_minus), l_plus, r_minus, p_plus, p_minus))\n p_minus = r_minus\n p_plus = _intersect(l_plus, r_minus, (x[i - 1], y[i - 1] + w), p_i_plus)\n s_plus[p_plus] = p_i_plus\n t_plus[p_i_plus] = p_plus\n r_plus = p_i_plus\n r_minus = p_i_minus\n l_plus = p_plus\n l_minus = p_minus\n while _angle(l_minus, r_plus, s_minus[l_minus], '-') < np.pi:\n l_minus = s_minus[l_minus]\n elif _angle(p_i_minus, l_minus, r_plus, '-') < np.pi:\n q.append((_intersect(l_minus, r_plus, p_minus, p_plus), l_minus, r_plus, p_minus, p_plus))\n p_plus = r_plus\n p_minus = _intersect(l_minus, r_plus, (x[i - 1], y[i - 1] - w), p_i_minus)\n s_minus[p_minus] = p_i_minus\n t_minus[p_i_minus] = p_minus\n r_minus = p_i_minus\n r_plus = p_i_plus\n l_minus = p_minus\n l_plus = p_plus\n while _angle(l_plus, r_minus, s_plus[l_plus], '+') < np.pi:\n l_plus = s_plus[l_plus]\n else:\n # Updating the two seperating and supporting lines\n if _angle(p_i_plus, l_minus, r_plus, '+') < np.pi:\n r_plus = p_i_plus\n while _angle(p_i_plus, l_minus, s_minus[l_minus], '+') < np.pi:\n l_minus = s_minus[l_minus]\n\n if _angle(p_i_minus, l_plus, r_minus, '-') < np.pi:\n r_minus = p_i_minus\n while _angle(p_i_minus, l_plus, s_plus[l_plus], '-') < np.pi:\n l_plus = s_plus[l_plus]\n i += 1\n\n # Add last change point\n a = _intersect(l_plus, r_minus, p_plus, p_minus)\n b = _intersect(l_minus, r_plus, p_minus, p_plus)\n p = ((a[0] + b[0]) / 2, (a[1] + b[1]) / 2)\n q.append((p, r_minus, r_plus, p_minus, p_plus))\n\n end_a = _intersect(p, r_plus, p_i_minus, p_i_plus)\n end_b = _intersect(p, r_minus, p_i_minus, p_i_plus)\n end = ((end_a[0] + end_b[0]) / 2, (end_a[1] + end_b[1]) / 2)\n q.append((end, (None, None), (None, None), p_i_minus, p_i_plus))\n\n if debug:\n return np.array(q)\n else:\n return np.array([o[0] for o in q])","def validate_clockwise_points(points):\n\n if len(points) != 8:\n raise Exception(\"Points list not valid.\" + str(len(points)))\n\n point = [\n [int(points[0]), int(points[1])],\n [int(points[2]), int(points[3])],\n [int(points[4]), int(points[5])],\n [int(points[6]), int(points[7])]\n ]\n edge = [\n (point[1][0] - point[0][0]) * (point[1][1] + point[0][1]),\n (point[2][0] - point[1][0]) * (point[2][1] + point[1][1]),\n (point[3][0] - point[2][0]) * (point[3][1] + point[2][1]),\n (point[0][0] - point[3][0]) * (point[0][1] + point[3][1])\n ]\n\n summatory = edge[0] + edge[1] + edge[2] + edge[3];\n if summatory > 0:\n raise Exception(\n \"Points are not clockwise. The coordinates of bounding quadrilaterals have to be given in clockwise order. Regarding the correct interpretation of 'clockwise' remember that the image coordinate system used is the standard one, with the image origin at the upper left, the X axis extending to the right and Y axis extending downwards.\")","def test_str_solid_angle(self):\n xknx = XKNX()\n sensor = Sensor(\n xknx, \"TestSensor\", group_address_state=\"1/2/3\", value_type=\"solid_angle\"\n )\n sensor.sensor_value.payload = DPTArray(\n (\n 0xC5,\n 0xC6,\n 0xE5,\n 0x47,\n )\n )\n\n self.assertEqual(sensor.resolve_state(), -6364.65966796875)\n self.assertEqual(sensor.unit_of_measurement(), \"sr\")\n self.assertEqual(sensor.ha_device_class(), None)","def unitQuad_Edge(lens, N=3):\n template = [ np.array([0,0]), np.array([lens[0], 0]), None, None ] #Template from which to generate other Quad Vertex Lists\n leftDegenerate = template.copy() #Left Limit of quad if you were to rotate edge 3 CCW about the origin until you no longer can\n rightDegenerate = template.copy() #Right Limit of quad if you were to rotate edge 2 CW about point 1 until you no longer can,\n # or alternatively, how far edge 3 can rotate CW until the quad is degenerate\n try:\n leftDegenerate[3] = np.array( circleIntersection(leftDegenerate[0], lens[3], leftDegenerate[1], lens[1]+lens[2]) )\n leftDegenerate[2] = ( lens[1] / (lens[2]+lens[1]) ) * (leftDegenerate[3]-leftDegenerate[1]) + leftDegenerate[1]\n except: \n leftDegenerate[3] = np.array([-lens[3],0])\n leftDegenerate[2] = np.array( circleIntersection(leftDegenerate[3], lens[2], leftDegenerate[1], lens[1]) )\n\n try:\n rightDegenerate[2] = np.array( circleIntersection(rightDegenerate[0], lens[2]+lens[3], rightDegenerate[1], lens[1]) )\n rightDegenerate[3] = ( lens[3] / (lens[3]+lens[2]) ) * rightDegenerate[2]\n except:\n rightDegenerate[2] = np.array([lens[0]+lens[1], 0])\n rightDegenerate[3] = np.array( circleIntersection(rightDegenerate[0], lens[3], rightDegenerate[2], lens[2]))\n \n rightOfOrigin = np.array([1,0]) #Theta = 0 on the Unit Circle\n thetaMin = angle_between(leftDegenerate[3], rightOfOrigin) #Angle of \n thetaMax = angle_between(rightDegenerate[3], rightOfOrigin)\n pitch = (thetaMax - thetaMin) / (N-1)\n\n result = []\n result.append(leftDegenerate) \n for i in range(1, N-1):\n result.append(template.copy())\n result[i][3] = lens[3]*unitCircPt(i*pitch+thetaMin)\n result[i][2] = np.array(circleIntersection( result[i][3], lens[2], result[i][1], lens[1]))\n result.append(rightDegenerate) \n\n return listify(result)","def external_shape(self):\n return ScaledShape(shape_in=self.tail_joiner, reference_point=Point(0, 0, 0), factor=1, hidden=True)","def is_solid(self, world=None):\n return self.solid","def bound_green_object(self, img):\n\n self.x = self.y = self.w = self.h = 0\n\n # Apply the threshold to get the green parts\n masked_img = self.threshold(img)\n\n # Get contours\n img_gray = cv2.cvtColor(masked_img, cv2.COLOR_BGR2GRAY)\n _, contours, _ = cv2.findContours(img_gray, cv2.RETR_LIST, cv2.CHAIN_APPROX_SIMPLE)\n if len(contours) > 0:\n # Find the largest contour\n areas = [cv2.contourArea(c) for c in contours]\n max_index = np.argmax(areas)\n max_contour = contours[max_index]\n\n self.perimeter_size = cv2.arcLength(max_contour, True)\n\n if self.perimeter_size < MIN_PERIMETER:\n return img\n\n # Draw rectangle bounding box on image\n self.x, self.y, self.w, self.h = cv2.boundingRect(max_contour)\n\n # if wider than long, ignore\n if float(self.h) / self.w < 1:\n self.x = self.y = self.w = self.h = 0\n return img\n\n cv2.rectangle(img, (self.x, self.y), (self.x + self.w, self.y + self.h), color=(0, 255, 0), thickness=2)\n\n # get center\n M = cv2.moments(max_contour)\n if M['m00'] > 0:\n cx = int(M['m10']/M['m00'])\n cy = int(M['m01']/M['m00'])\n # draw a circle on the center\n cv2.circle(img, (cx, cy), 20, (0,0,255), -1)\n # calc ang error\n self.ang_error = cx - 320\n\n return img","def settle_falilng_shape(self):\n if self.falling_shape:\n self._settle_shape(self.falling_shape)\n self.falling_shape = None\n self.new_shape()","def polygon(t, length, n):\n for i in range(n):\n t.fd(length)\n t.lt(360/n)","def walls_cc(lenght, width, wall_height=3, roof_height=4):\n a = min(0.1*lenght, 0.1*width, 0.4*(wall_height+0.5*roof_height))\n trian = 0.5*width*roof_height\n trian_5 = 0.5*a*a*(wall_height/roof_height)\n # trian_4 = trian - 2*trian_5\n\n area = (lenght + width)*2*wall_height + 2*trian\n area_5 = 8*a*wall_height + 4*trian_5\n area_4 = area - area_5\n\n return area, area_4, area_5","def bend_s(\n size: Float2 = (10.0, 2.0),\n nb_points: int = 99,\n with_cladding_box: bool = True,\n cross_section: CrossSectionFactory = strip,\n **kwargs\n) -> Component:\n dx, dy = size\n x = cross_section(**kwargs)\n width = x.info[\"width\"]\n layer = x.info[\"layer\"]\n\n c = Component()\n\n bend = bezier(\n width=width,\n control_points=[(0, 0), (dx / 2, 0), (dx / 2, dy), (dx, dy)],\n npoints=nb_points,\n layer=layer,\n )\n\n bend_ref = c << bend\n c.add_ports(bend_ref.ports)\n c.copy_child_info(bend)\n c.info[\"start_angle\"] = bend.info[\"start_angle\"]\n c.info[\"end_angle\"] = bend.info[\"end_angle\"]\n c.info[\"length\"] = bend.info[\"length\"]\n c.info[\"min_bend_radius\"] = bend.info[\"min_bend_radius\"]\n\n if with_cladding_box and x.info[\"layers_cladding\"]:\n layers_cladding = x.info[\"layers_cladding\"]\n cladding_offset = x.info[\"cladding_offset\"]\n points = get_padding_points(\n component=c,\n default=0,\n bottom=cladding_offset,\n top=cladding_offset,\n )\n for layer in layers_cladding or []:\n c.add_polygon(points, layer=layer)\n\n auto_rename_ports(c)\n return c","def stairs(x, y, length, blueness):\n color = (0, 0.5*blueness, blueness)\n if length>3:\n penup()\n goto(x, y)\n pendown()\n fillcolor(color)\n begin_fill()\n square(length)\n end_fill()\n stairs(x, y+length, length/2, blueness/1.25)\n stairs(x+length, y, length/2, blueness/1.25)","def sector_mask(shape,centre,radius,angle_range):\n\n x,y = np.ogrid[:shape[0],:shape[1]]\n cx,cy = centre\n tmin,tmax = np.deg2rad(angle_range)\n\n # ensure stop angle > start angle\n if tmax < tmin:\n tmax += 2*np.pi\n\n # convert cartesian --> polar coordinates\n r2 = (x-cx)*(x-cx) + (y-cy)*(y-cy)\n theta = np.arctan2(x-cx,y-cy) - tmin\n\n # wrap angles between 0 and 2*pi\n theta %= (2*np.pi)\n\n # circular mask\n circmask = r2 <= radius*radius\n\n # angular mask\n anglemask = theta <= (tmax-tmin)\n\n return circmask*anglemask","def sector_mask(shape,centre,radius,angle_range):\n\n x,y = np.ogrid[:shape[0],:shape[1]]\n cx,cy = centre\n tmin,tmax = np.deg2rad(angle_range)\n\n # ensure stop angle > start angle\n if tmax < tmin:\n tmax += 2*np.pi\n\n # convert cartesian --> polar coordinates\n r2 = (x-cx)*(x-cx) + (y-cy)*(y-cy)\n theta = np.arctan2(x-cx,y-cy) - tmin\n\n # wrap angles between 0 and 2*pi\n theta %= (2*np.pi)\n\n # circular mask\n circmask = r2 <= radius*radius\n\n # angular mask\n anglemask = theta <= (tmax-tmin)\n\n return circmask*anglemask","def sector_mask(shape,centre,radius,angle_range):\n\n x,y = np.ogrid[:shape[0],:shape[1]]\n cx,cy = centre\n tmin,tmax = np.deg2rad(angle_range)\n\n # ensure stop angle > start angle\n if tmax < tmin:\n tmax += 2*np.pi\n\n # convert cartesian --> polar coordinates\n r2 = (x-cx)*(x-cx) + (y-cy)*(y-cy)\n theta = np.arctan2(x-cx,y-cy) - tmin\n\n # wrap angles between 0 and 2*pi\n theta %= (2*np.pi)\n\n # circular mask\n circmask = r2 <= radius*radius\n\n # angular mask\n anglemask = theta <= (tmax-tmin)\n\n return circmask*anglemask","def stokes_left_circular():\n return np.array([1, 0, 0, -1])","def _check_curve(layer: ogr.Layer) -> None:\n # Check if the feature geometry is polygonal:\n feature_defn = layer.GetLayerDefn()\n layer.ResetReading()\n feature = layer.GetNextFeature()\n while feature is not None:\n geom = feature.GetGeometryRef()\n name_wkt = geom.ExportToWkt()\n\n # Approximate a curvature by a polygon geometry:\n if 'curv' in name_wkt.lower():\n linear_geom = geom.GetLinearGeometry()\n new_feature = ogr.Feature(feature_defn)\n new_feature.SetGeometryDirectly(linear_geom)\n layer.CreateFeature(new_feature)\n layer.DeleteFeature(feature.GetFID())\n\n feature = layer.GetNextFeature()","def XCAFDoc_ShapeTool_IsSimpleShape(*args):\n return _XCAFDoc.XCAFDoc_ShapeTool_IsSimpleShape(*args)","def is_ring(self): # -> bool:\n ...","def c_shape(self,image,i,j):\r\n\r\n if ((i <= 280 + self.padding) and (j >= 200 - self.padding) and (i >= 230 - self.padding) and (j <= 230 + self.padding)) and not ((i <= 270 - self.padding) and (j >= 210 + self.padding) and (i >= 240 + self.padding) and (j <= 230 + self.padding)):\r\n image[self.maximum_size-i,j,:]=0,0,0\r\n self.image_p[i,j,:]=2","def watershed(mask, img, plotImage = False, kernelSize = None):\n imgCopy = img.copy()\n maskCopy = np.array(mask.copy(), dtype=np.uint8)\n \n if kernelSize is None:\n kernelSize = 2\n\n # Finding sure foreground area\n #dist_transform = cv2.distanceTransform(mask, cv2.DIST_L2, 5)\n #ret, sure_fg = cv2.threshold(dist_transform,0.3*dist_transform.max(),255,0) #change the second argument to change the sensitivity \n maskClosed = skimage.morphology.closing(np.array(maskCopy, dtype=np.uint8))\n maskClosed = skimage.morphology.closing(np.array(maskClosed, dtype=np.uint8))\n kernel = np.ones((kernelSize,kernelSize), np.uint8)\n # maskCopy = img_as_bool(maskCopy)\n sure_fg = cv2.erode(maskClosed, kernel, iterations = 2) ###\n sure_fg = skimage.morphology.closing(np.array(sure_fg, dtype=np.uint8))\n # kernel = np.ones((2,2), np.uint8)\n # sure_fg = binary_closing(sure_fg, kernel)\n \n # sure background area\n #kernel = np.ones((5, 5), np.uint8)\n #sure_bg = cv2.dilate(mask, kernel, iterations = 1)\n sure_fg_bool = 1 - img_as_bool(sure_fg)\n # sure_bg = np.uint8(1 - morphology.medial_axis(sure_fg_bool)) ### \n sure_bg = np.uint8(1 - morphology.skeletonize(sure_fg_bool))\n sure_bg[0, :] = 1\n sure_bg[-1, :] = 1\n sure_bg[:, 0] = 1\n sure_bg[:, -1] = 1\n \n # Finding unknown region\n sure_fg = np.uint8(sure_fg)\n unknown = cv2.subtract(sure_bg, sure_fg)\n \n if plotImage:\n plt.figure()\n plt.imshow(sure_fg)\n plt.title(\"Inner Marker\")\n plt.figure()\n plt.imshow(sure_bg)\n plt.title(\"Outer Marker\")\n plt.figure()\n plt.imshow(unknown)\n plt.title(\"Unknown\")\n \n # Marker labelling\n ret, markers = cv2.connectedComponents(sure_fg)\n\n # Add one to all labels so that sure background is not 0, but 1\n markers = markers+1\n\n # Now, mark the region of unknown with zero\n markers[unknown==1] = 0\n \n if plotImage:\n plt.figure()\n plt.imshow(markers, cmap='jet')\n plt.title(\"Markers\")\n \n # Do watershed\n markers = cv2.watershed(imgCopy, markers)\n \n imgCopy[markers == -1] = [0, 255 ,0]\n\n if plotImage:\n plt.figure()\n plt.imshow(markers,cmap='jet')\n plt.title(\"Mask\")\n plt.figure()\n plt.imshow(img)\n plt.title(\"Original Image\")\n plt.figure()\n plt.imshow(imgCopy)\n plt.title(\"Marked Image\")\n plt.show()\n\n return markers","def sector_mask(shape, centre, radius, angle_range):\n\n x,y = np.ogrid[:shape[0],:shape[1]]\n cx,cy = centre\n tmin,tmax = np.deg2rad(angle_range)\n\n # ensure stop angle > start angle\n if tmax < tmin:\n tmax += 2*np.pi\n\n # convert cartesian --> polar coordinates\n r2 = (x-cx)*(x-cx) + (y-cy)*(y-cy)\n theta = np.arctan2(x-cx, y-cy) - tmin\n\n # wrap angles between 0 and 2*pi\n theta %= (2*np.pi)\n\n # circular mask\n circmask = r2 <= radius*radius\n\n # angular mask\n anglemask = theta <= (tmax-tmin)\n\n return circmask*anglemask","def draw_housing():\n tess.pensize(3)\n tess.color(\"black\", \"darkgrey\")\n tess.begin_fill()\n tess.forward(80)\n tess.left(90)\n tess.forward(200)\n tess.circle(40, 180)\n tess.forward(200)\n tess.left(90)\n tess.end_fill()","def is_ring(geometry, **kwargs):\n return lib.is_ring(geometry, **kwargs)","def C(width = 1, size = (10, 20), layer = 0):\n D = Device(name = 'C')\n w = width/2\n s1, s2 = size\n points = [(-w, -w), (s1, -w), (s1, w), (w, w), (w, s2-w),\n (s1, s2-w), (s1, s2+w), (-w, s2+w), (-w, -w)]\n D.add_polygon(points, layer = layer)\n D.add_port(name = 1, midpoint = (s1, s2), width = width, orientation = 0)\n D.add_port(name = 2, midpoint = (s1, 0), width = width, orientation = 0)\n return D"],"string":"[\n \"def add_cable_ring(self, env, info={}, cable_idx=0):\\n def rad_to_deg(rad):\\n return (rad * 180.0) / np.pi\\n\\n def get_discretized_rotations(num_rotations):\\n # counter-clockwise\\n theta = i * (2 * np.pi) / num_rotations\\n return (theta, rad_to_deg(theta))\\n\\n # Bead properties.\\n num_parts = self.num_parts\\n radius = self.radius\\n color = self.colors[cable_idx] + [1]\\n\\n # The `ring_radius` (not the bead radius!) has to be tuned somewhat.\\n # Try to make sure the beads don't have notable gaps between them.\\n ring_radius = info['ring_radius']\\n beads = []\\n bead_positions_l = []\\n\\n # Add beaded cable. Here, `position` is the circle center.\\n position = np.float32(info['center_position'])\\n part_shape = p.createCollisionShape(p.GEOM_BOX, halfExtents=[radius]*3)\\n part_visual = p.createVisualShape(p.GEOM_SPHERE, radius=radius*1.5)\\n\\n # Iterate through parts and create constraints as needed.\\n for i in range(num_parts):\\n angle_rad, _ = get_discretized_rotations(num_parts)\\n px = ring_radius * np.cos(angle_rad)\\n py = ring_radius * np.sin(angle_rad)\\n #print(f'pos: {px:0.2f}, {py:0.2f}, angle: {angle_rad:0.2f}, {angle_deg:0.1f}')\\n bead_position = np.float32([position[0] + px, position[1] + py, 0.01])\\n part_id = p.createMultiBody(0.1, part_shape, part_visual,\\n basePosition=bead_position)\\n p.changeVisualShape(part_id, -1, rgbaColor=color)\\n\\n if i > 0:\\n parent_frame = bead_position - bead_positions_l[-1]\\n constraint_id = p.createConstraint(\\n parentBodyUniqueId=beads[-1],\\n parentLinkIndex=-1,\\n childBodyUniqueId=part_id,\\n childLinkIndex=-1,\\n jointType=p.JOINT_POINT2POINT,\\n jointAxis=(0, 0, 0),\\n parentFramePosition=parent_frame,\\n childFramePosition=(0, 0, 0))\\n p.changeConstraint(constraint_id, maxForce=100)\\n\\n # Make a constraint with i=0. Careful with `parent_frame`!\\n if i == num_parts - 1:\\n parent_frame = bead_positions_l[0] - bead_position\\n constraint_id = p.createConstraint(\\n parentBodyUniqueId=part_id,\\n parentLinkIndex=-1,\\n childBodyUniqueId=beads[0],\\n childLinkIndex=-1,\\n jointType=p.JOINT_POINT2POINT,\\n jointAxis=(0, 0, 0),\\n parentFramePosition=parent_frame,\\n childFramePosition=(0, 0, 0))\\n p.changeConstraint(constraint_id, maxForce=100)\\n\\n # Track beads.\\n beads.append(part_id)\\n bead_positions_l.append(bead_position)\\n\\n # The usual for tracking IDs. Four things to add.\\n self.cable_bead_IDs.append(part_id)\\n self._IDs[part_id] = f'cable_part_{str(part_id).zfill(2)}'\\n env.objects.append(part_id)\\n self.object_points[part_id] = np.float32((0, 0, 0)).reshape(3, 1)\\n\\n if 'cable-ring' in self._name:\\n # For targets, we can assume the starting position gives us\\n # that. Later, apply a random force on the ring to perturb it.\\n true_position = (bead_position[0], bead_position[1], 0)\\n self.goal['places'][part_id] = (true_position, (0, 0, 0, 1.))\\n symmetry = 0\\n self.goal['steps'][0][part_id] = (symmetry, [part_id])\\n\\n # Make the true positions visible if desired.\\n if info['targets_visible']:\\n sq_pose = ((true_position[0], true_position[1], 0.002), (0,0,0,1))\\n sq_template = 'assets/square/square-template-allsides-green.urdf'\\n replace = {'DIM': (0.003,), 'HALF': (0.003 / 2,)}\\n urdf = self.fill_template(sq_template, replace)\\n env.add_object(urdf, sq_pose, fixed=True)\\n os.remove(urdf)\\n else:\\n print(f'Warning, env {self._name} will not have goals.')\",\n \"def generate_solid(self):\\n ext = os.path.splitext(self.filename)[1][1:]\\n if ext == 'stl':\\n shaft_compound = read_stl_file(self.filename)\\n elif ext == 'iges':\\n iges_reader = IGESControl_Reader()\\n iges_reader.ReadFile(self.filename)\\n iges_reader.TransferRoots()\\n shaft_compound = iges_reader.Shape()\\n else:\\n raise Exception('The shaft file is not in iges/stl formats')\\n sewer = BRepBuilderAPI_Sewing(1e-2)\\n sewer.Add(shaft_compound)\\n sewer.Perform()\\n result_sewed_shaft = sewer.SewedShape()\\n shaft_solid_maker = BRepBuilderAPI_MakeSolid()\\n shaft_solid_maker.Add(OCC.Core.TopoDS.topods_Shell(result_sewed_shaft))\\n if not shaft_solid_maker.IsDone():\\n raise RuntimeError('Unsuccessful assembling of solid shaft')\\n shaft_solid = shaft_solid_maker.Solid()\\n return shaft_solid\",\n \"def test_drawSolid(self):\\n\\n image_name = filename(sys._getframe().f_code.co_name)\\n result_file, reference_file = get_path(image_name)\\n\\n ''' This function is to create an empty image with a specific dimension\\n with white background, and black/white colored '''\\n\\n image, canvas = get_image('RGB', (640, 480), 'white')\\n\\n '''\\n for different representations of colors see\\n \\\"https://pillow.readthedocs.io/en/3.0.x/reference/ImageColor.html#color-names\\\"\\n '''\\n drawSolid(canvas, regularPolygon(3, np.array([160, 120]), 50), 'red')\\n drawSolid(canvas, regularPolygon(4, np.array([480, 120]), 90), 'blue')\\n drawSolid(canvas, regularPolygon(5, np.array([420, 360]), 60), 'green')\\n drawSolid(canvas, regularPolygon(6, np.array([160, 360]), 80), 'black')\\n drawSolid(canvas, regularPolygon(7, np.array([320, 160]), 70), 'brown')\\n\\n \\\"\\\"\\\" saving the file and closing it \\\"\\\"\\\"\\n image.save(result_file)\\n image.close()\\n\\n \\\"\\\"\\\" validate the resultant file against the reference images\\\"\\\"\\\"\\n\\n validate(reference_file, result_file)\",\n \"def __bcc_left_diagonals(self) -> cq.cq.Workplane:\\n # In a cuboid ABCDA1B1C1D1 this is the angle C1AD\\n #angle_C1AD = 90 - degrees(acos(2**-.5))\\n angle_C1AD = 90 - degrees(acos(0.5))\\n angle_CAD = 90 - degrees(acos(sqrt(2/3)))\\n pseudo_unit_cell_size = sqrt(2/3)*self.unit_cell_size\\n corner_points = np.array(\\n [(0, 0),\\n (self.bcc_unit_cell_size, 0),\\n (self.bcc_unit_cell_size, self.unit_cell_size),\\n (0, self.unit_cell_size)]\\n )\\n result = (\\n cq.Workplane(\\\"XY\\\")\\n .pushPoints(corner_points)\\n .eachpointAdaptive(\\n create_bcc_diagonal_strut,\\n callback_extra_args = [\\n {\\\"unit_cell_size\\\": pseudo_unit_cell_size,\\n \\\"radius\\\": self.strut_radius,\\n \\\"angle_x\\\": - angle_CAD,\\n \\\"angle_y\\\": angle_C1AD},\\n {\\\"unit_cell_size\\\": 0.5 * pseudo_unit_cell_size,\\n \\\"radius\\\": self.strut_radius,\\n \\\"angle_x\\\": - angle_CAD,\\n \\\"angle_y\\\": - angle_C1AD},\\n {\\\"unit_cell_size\\\": 0.5 * pseudo_unit_cell_size,\\n \\\"radius\\\": self.strut_radius,\\n \\\"angle_x\\\": angle_CAD,\\n \\\"angle_y\\\": - angle_C1AD},\\n {\\\"unit_cell_size\\\": pseudo_unit_cell_size,\\n \\\"radius\\\": self.strut_radius,\\n \\\"angle_x\\\": angle_CAD,\\n \\\"angle_y\\\": angle_C1AD}\\n ],\\n useLocalCoords = True\\n )\\n )\\n return result\",\n \"def _create_main_shape(self):\\n\\n a, b = gc( self.size/2,\\n self._ZERO_DEGREES - self.angle,\\n self._180_DEGREES + self.angle)\\n self.wafer_points = zip(a,b)\\n self.wafer_polygon = gdspy.Polygon(self.wafer_points, self.WAFER_LAYER)\\n self.cell.add(self.wafer_polygon)\",\n \"def make_circle_fill():\\n num_points = 40\\n batch = pyglet.graphics.Batch()\\n rad = math.pi * 2 / num_points # getting 360 / n in radians\\n index = list(itertools.chain.from_iterable( (0, x-1, x) for x in range(2, num_points+1) ))\\n index += [0, 1, num_points] # end of fan\\n vertices = [0, 0] # adding center of fan\\n for i in range(1, num_points + 1):\\n angle = rad * i\\n vertices += [math.cos(angle), math.sin(angle)]\\n vertices += [1, 0] # adding end of fan\\n circle = pyglet.graphics.vertex_list_indexed(num_points+2, index, ('v2f', vertices))\\n return circle\",\n \"def boundaries_and_initialize():\\n greenLower = (29, 86, 6) # define the lower and upper boundaries of the \\\"green\\\"\\n greenUpper = (64, 255, 255)\\n pts = [((200,300),(255,255,255), 0)]\\n blanks = []\\n linecolor = (0,0,0)\\n counter = 1\\n radius = 11\\n return greenLower, greenUpper, pts, linecolor, counter, blanks, radius\",\n \"def poly_enclose(points, color, inc=1.2, rad=0.3, lw=2):\\n points = np.log(points)\\n hull = ConvexHull(points)\\n\\n cent = np.mean(points, 0)\\n pts = []\\n for pt in points[hull.simplices]:\\n pts.append(pt[0].tolist())\\n pts.append(pt[1].tolist())\\n \\n pts.sort(key=lambda p: np.arctan2(p[1] - cent[1],\\n p[0] - cent[0]))\\n pts = pts[0::2] # Deleting duplicates\\n pts.insert(len(pts), pts[0])\\n \\n \\n verts = inc*(np.array(pts)- cent) + cent\\n verts2 = np.zeros((3*verts.shape[0]-2,2))\\n verts2[0::3] = verts\\n verts2[1::3,:] = (1-rad)*verts[0:-1,:] + rad*verts[1:,:]\\n verts2[2::3,:] = rad*verts[0:-1,:] + (1-rad)*verts[1:,:]\\n verts2[0:-1] = verts2[1:]\\n verts2[-1] = verts2[0]\\n\\n\\n \\n codes = [Path.MOVETO, Path.LINETO, Path.CURVE3,]\\n for j in range(len(pts)-2):\\n codes.extend([Path.CURVE3, Path.LINETO, Path.CURVE3,])\\n codes.append(Path.CURVE3)\\n \\n \\n path = Path(verts2, codes)\\n patch = patches.PathPatch(path, facecolor=color, lw=0, alpha=0.2)\\n edge = patches.PathPatch(path, edgecolor=color, facecolor='none', lw=lw)\\n patch._path._vertices = np.exp(patch._path._vertices)\\n return patch, edge\",\n \"def make_flower(shape, x, y, c1, c2, l, s):\\n shape.penup()\\n shape.speed(20)\\n shape.setpos(x, y)\\n shape.color(c2, c1)\\n shape.begin_fill()\\n shape.pendown()\\n for side in range(6):\\n shape.left(60)\\n shape.forward(s) # s stands for short side\\n shape.right(60)\\n shape.forward(l) # l stands for long side\\n shape.right(60)\\n shape.forward(s)\\n shape.right(60)\\n shape.forward(s)\\n shape.right(60)\\n shape.forward(l)\\n shape.right(60)\\n shape.forward(s)\\n shape.right(60)\\n shape.end_fill()\\n shape.pendown()\\n\\n shape.color(\\\"green\\\")\\n shape.right(90)\\n shape.penup()\\n shape.forward(10)\\n shape.pendown()\\n shape.forward(110)\\n shape.left(90)\\n\\n\\n\\n # ...\",\n \"def test_clip_points_by_polygons_with_holes_real(self):\\n\\n # Read real polygon with holes\\n filename = '%s/%s' % (TESTDATA, 'donut.shp')\\n L = read_layer(filename)\\n\\n # --------------------------------------------\\n # Pick one polygon that has 2 inner rings\\n P = L.get_geometry(as_geometry_objects=True)[1]\\n\\n outer_ring = P.outer_ring\\n inner_ring0 = P.inner_rings[0]\\n inner_ring1 = P.inner_rings[1]\\n\\n # Make some test points\\n points_in_bbox = generate_random_points_in_bbox(outer_ring, 1000)\\n points_in_inner_ring0 = populate_polygon(inner_ring0, 2, seed=13)\\n points_in_inner_ring1 = populate_polygon(inner_ring1, 2, seed=17)\\n points = numpy.concatenate((points_in_bbox,\\n points_in_inner_ring0,\\n points_in_inner_ring1))\\n\\n # Clip\\n indices = inside_polygon(points, P.outer_ring, holes=P.inner_rings)\\n\\n # Sanity\\n for point in points[indices, :]:\\n # Must be inside outer ring\\n assert is_inside_polygon(point, outer_ring)\\n\\n # But not in any of the inner rings\\n assert not is_inside_polygon(point, inner_ring0)\\n assert not is_inside_polygon(point, inner_ring1)\\n\\n # ---------------------------------------------------------\\n # Pick a polygon that has 1 inner ring (nice visualisation)\\n P = L.get_geometry(as_geometry_objects=True)[9]\\n\\n outer_ring = P.outer_ring\\n inner_ring = P.inner_rings[0]\\n\\n # Make some test points\\n points = generate_random_points_in_bbox(outer_ring, 500)\\n\\n # Clip\\n indices = inside_polygon(points, P.outer_ring, holes=P.inner_rings)\\n\\n # Sanity\\n for point in points[indices, :]:\\n # Must be inside outer ring\\n assert is_inside_polygon(point, outer_ring)\\n\\n # But not in the inner ring\\n assert not is_inside_polygon(point, inner_ring)\\n\\n # Store for visual check (nice one!)\\n # Uncomment os.remove if you want see the layers\\n pol = Vector(geometry=[P])\\n tmp_filename = unique_filename(suffix='.shp')\\n pol.write_to_file(tmp_filename)\\n #print 'Polygon with holes written to %s' % tmp_filename\\n os.remove(tmp_filename)\\n\\n pts = Vector(geometry=points[indices, :])\\n tmp_filename = unique_filename(suffix='.shp')\\n pts.write_to_file(tmp_filename)\\n #print 'Clipped points written to %s' % tmp_filename\\n os.remove(tmp_filename)\",\n \"def RemovePolygonHoles_management(in_fc, threshold=0.0):\\n desc = arcpy.Describe(in_fc)\\n if desc.dataType != \\\"FeatureClass\\\" and desc.dataType != \\\"ShapeFile\\\":\\n print(\\\"Invalid data type. The input is supposed to be a Polygon FeatureClass or Shapefile.\\\")\\n return\\n else:\\n if desc.shapeType != \\\"Polygon\\\":\\n print(\\\"The input is supposed to be a Polygon FeatureClass or Shapefile.\\\")\\n return\\n if threshold < 0.0:\\n threshold = 0.0\\n with arcpy.da.UpdateCursor(in_fc, [\\\"SHAPE@\\\"]) as updateCursor:\\n for updateRow in updateCursor:\\n shape = updateRow[0]\\n new_shape = arcpy.Array()\\n for part in shape:\\n new_part = arcpy.Array()\\n if threshold > 0:\\n # find None point in shape part\\n # in arcpy module, a None point is used to seperate exterior and interior vertices\\n null_point_index = []\\n for i in range(len(part)):\\n if part[i] is None:\\n null_point_index.append(i)\\n # if interior vertices exist, create polygons and compare polygon shape area to given threshold\\n # if larger, keep vertices, else, dismiss them\\n if len(null_point_index) > 0:\\n for k in range(0, null_point_index[0]):\\n new_part.add(part[k])\\n for i in range(len(null_point_index)):\\n pointArray = arcpy.Array()\\n # determine if the None point is the last one\\n if i+1 < len(null_point_index):\\n for j in range(null_point_index[i] + 1, null_point_index[i+1]):\\n pointArray.add(part[j])\\n else:\\n for j in range(null_point_index[i] + 1, len(part)):\\n pointArray.add(part[j])\\n # create a polygon to check shape area against the given threshold\\n inner_poly = arcpy.Polygon(pointArray)\\n # if larger than threshold, then add to the new part Array\\n if inner_poly.area > threshold:\\n if i+1 < len(null_point_index):\\n for k in range(null_point_index[i], null_point_index[i+1]):\\n new_part.add(part[k])\\n else:\\n for k in range(null_point_index[i], len(part)):\\n new_part.add(part[k])\\n new_shape.add(new_part)\\n # if interior does not exist, add the whole part\\n else:\\n new_shape.add(part)\\n else:\\n # get the first None point index\\n first_null_point_index = 0\\n for i in range(len(part)):\\n if part[i] is None:\\n first_null_point_index = i\\n break\\n if first_null_point_index == 0:\\n new_shape.add(part)\\n else:\\n for j in range(first_null_point_index):\\n new_part.add(part[j])\\n new_shape.add(new_part)\\n if len(new_shape) > 0:\\n new_poly = arcpy.Polygon(new_shape)\\n updateRow[0] = new_poly\\n updateCursor.updateRow(updateRow)\",\n \"def make_shape_ccw(self):\\n\\n if not(self.closed):\\n return\\n\\n # Optimization for closed shapes\\n # Start value for the first sum\\n\\n if self.isDirectionOfGeosCCW(self.geos):\\n self.reverse()\\n logger.debug(self.tr(\\\"Had to reverse the shape to be CW\\\"))\\n self.cw = True\",\n \"def createCylinder( basePoint=(0,-1,0), tipPoint=(0,1,0), radius = 1.0, colour=(0.6,0.6,0.6), samples = 20 ):\\r\\n \\r\\n basePoint = PyUtils.toPoint3d(basePoint)\\r\\n tipPoint = PyUtils.toPoint3d(tipPoint)\\r\\n baseToTipVector = Vector3d(basePoint,tipPoint)\\r\\n if baseToTipVector.isZeroVector() :\\r\\n raise ValueError( 'Invalid points for cylinder: base and tip are equal!' )\\r\\n baseToTipUnitVector = baseToTipVector.unit()\\r\\n xUnitVector = baseToTipUnitVector.crossProductWith( Vector3d(0,0,1) )\\r\\n if xUnitVector.length() < 0.5 :\\r\\n xUnitVector = baseToTipUnitVector.crossProductWith( Vector3d(0,-1,0) )\\r\\n xUnitVector.toUnit()\\r\\n yUnitVector = baseToTipUnitVector.crossProductWith( Vector3d(-1,0,0) )\\r\\n if yUnitVector.length() < 0.5 :\\r\\n yUnitVector = baseToTipUnitVector.crossProductWith( Vector3d(0,1,0) )\\r\\n yUnitVector.toUnit()\\r\\n\\r\\n vertices = []\\r\\n for i in range(samples):\\r\\n theta = i * 2 * math.pi / float(samples)\\r\\n vertices.append( basePoint + xUnitVector * math.cos(theta) * radius + yUnitVector * math.sin(theta) * radius )\\r\\n for i in range(samples):\\r\\n theta = i * 2 * math.pi / float(samples)\\r\\n vertices.append( tipPoint + xUnitVector * math.cos(theta) * radius + yUnitVector * math.sin(theta) * radius )\\r\\n for i in range(samples):\\r\\n theta = i * 2 * math.pi / float(samples)\\r\\n vertices.append( basePoint + xUnitVector * math.cos(theta) * radius + yUnitVector * math.sin(theta) * radius )\\r\\n vertices.append( tipPoint + xUnitVector * math.cos(theta) * radius + yUnitVector * math.sin(theta) * radius )\\r\\n \\r\\n faces = [ range(0,samples), range(samples,2*samples) ]\\r\\n for i in range(0,2*samples,2) :\\r\\n base = 2*samples\\r\\n size = 2*samples\\r\\n faces.append( (base+i, base+i+1, base+(i+3)%size, base+(i+2)%size ) )\\r\\n \\r\\n return create( vertices, faces, colour )\",\n \"def __bcc_diagonals(self) -> cq.cq.Workplane:\\n # In a cuboid ABCDA1B1C1D1 this is the angle C1AD\\n #angle_C1AD = 90 - degrees(acos(2**-.5))\\n angle_C1AD = 90 - degrees(acos(0.5))\\n angle_CAD = 90 - degrees(acos(sqrt(2/3)))\\n pseudo_unit_cell_size = sqrt(2/3)*self.unit_cell_size\\n corner_points = np.array(\\n [(0, 0),\\n (self.bcc_unit_cell_size, 0),\\n (self.bcc_unit_cell_size, self.unit_cell_size),\\n (0, self.unit_cell_size)]\\n )\\n result = (\\n cq.Workplane(\\\"XY\\\")\\n .pushPoints(corner_points)\\n .eachpointAdaptive(\\n create_bcc_diagonal_strut,\\n callback_extra_args = [\\n {\\\"unit_cell_size\\\": pseudo_unit_cell_size,\\n \\\"radius\\\": self.strut_radius,\\n \\\"angle_x\\\": - angle_CAD,\\n \\\"angle_y\\\": angle_C1AD},\\n {\\\"unit_cell_size\\\": pseudo_unit_cell_size,\\n \\\"radius\\\": self.strut_radius,\\n \\\"angle_x\\\": - angle_CAD,\\n \\\"angle_y\\\": - angle_C1AD},\\n {\\\"unit_cell_size\\\": pseudo_unit_cell_size,\\n \\\"radius\\\": self.strut_radius,\\n \\\"angle_x\\\": angle_CAD,\\n \\\"angle_y\\\": - angle_C1AD},\\n {\\\"unit_cell_size\\\": pseudo_unit_cell_size,\\n \\\"radius\\\": self.strut_radius,\\n \\\"angle_x\\\": angle_CAD,\\n \\\"angle_y\\\": angle_C1AD}\\n ],\\n useLocalCoords = True\\n )\\n )\\n return result\",\n \"def __bcc_top_diagonals(self) -> cq.cq.Workplane:\\n # In a cuboid ABCDA1B1C1D1 this is the angle C1AD\\n #angle_C1AD = 90 - degrees(acos(2**-.5))\\n angle_C1AD = 90 - degrees(acos(0.5))\\n angle_CAD = 90 - degrees(acos(sqrt(2/3)))\\n pseudo_unit_cell_size = sqrt(2/3)*self.unit_cell_size\\n corner_points = np.array(\\n [(0, 0),\\n (self.bcc_unit_cell_size, 0),\\n (self.bcc_unit_cell_size, self.unit_cell_size),\\n (0, self.unit_cell_size)]\\n )\\n result = (\\n cq.Workplane(\\\"XY\\\")\\n .pushPoints(corner_points)\\n .eachpointAdaptive(\\n create_bcc_diagonal_strut,\\n callback_extra_args = [\\n {\\\"unit_cell_size\\\": 0.5 * pseudo_unit_cell_size,\\n \\\"radius\\\": self.strut_radius,\\n \\\"angle_x\\\": - angle_CAD,\\n \\\"angle_y\\\": angle_C1AD},\\n {\\\"unit_cell_size\\\": pseudo_unit_cell_size,\\n \\\"radius\\\": self.strut_radius,\\n \\\"angle_x\\\": - angle_CAD,\\n \\\"angle_y\\\": - angle_C1AD},\\n {\\\"unit_cell_size\\\": pseudo_unit_cell_size,\\n \\\"radius\\\": self.strut_radius,\\n \\\"angle_x\\\": angle_CAD,\\n \\\"angle_y\\\": - angle_C1AD},\\n {\\\"unit_cell_size\\\": 0.5 * pseudo_unit_cell_size,\\n \\\"radius\\\": self.strut_radius,\\n \\\"angle_x\\\": angle_CAD,\\n \\\"angle_y\\\": angle_C1AD}\\n ],\\n useLocalCoords = True\\n )\\n )\\n return result\",\n \"def tail_shaft_circle(self):\\n _profile = Circle(position=self.stabilizer_vright.position, radius=(self.critical_thickness / 2.0) * 1.5)\\n _extrude = ExtrudedSolid(island=_profile, distance=self.stabilizer_h.root_chord)\\n return _profile, _extrude\",\n \"def test_clip_points_by_polygons_with_holes0(self):\\n\\n # Define an outer ring\\n outer_ring = numpy.array([[106.79, -6.233],\\n [106.80, -6.24],\\n [106.78, -6.23],\\n [106.77, -6.21],\\n [106.79, -6.233]])\\n\\n # Define inner rings\\n inner_rings = [numpy.array([[106.77827, -6.2252],\\n [106.77775, -6.22378],\\n [106.78, -6.22311],\\n [106.78017, -6.22530],\\n [106.77827, -6.2252]])[::-1],\\n numpy.array([[106.78652, -6.23215],\\n [106.78642, -6.23075],\\n [106.78746, -6.23143],\\n [106.78831, -6.23307],\\n [106.78652, -6.23215]])[::-1]]\\n\\n v = Vector(geometry=[Polygon(outer_ring=outer_ring,\\n inner_rings=inner_rings)])\\n assert v.is_polygon_data\\n\\n # Write it to file\\n tmp_filename = unique_filename(suffix='.shp')\\n v.write_to_file(tmp_filename)\\n\\n # Read polygon it back\\n L = read_layer(tmp_filename)\\n P = L.get_geometry(as_geometry_objects=True)[0]\\n\\n outer_ring = P.outer_ring\\n inner_ring0 = P.inner_rings[0]\\n inner_ring1 = P.inner_rings[1]\\n\\n # Make some test points\\n points = generate_random_points_in_bbox(outer_ring, 1000, seed=13)\\n\\n # Clip to outer ring, excluding holes\\n indices = inside_polygon(points, P.outer_ring, holes=P.inner_rings)\\n\\n # Sanity\\n for point in points[indices, :]:\\n # Must be inside outer ring\\n assert is_inside_polygon(point, outer_ring)\\n\\n # But not in any of the inner rings\\n assert not is_inside_polygon(point, inner_ring0)\\n assert not is_inside_polygon(point, inner_ring1)\\n\\n if False:\\n # Store for visual check\\n pol = Vector(geometry=[P])\\n tmp_filename = unique_filename(suffix='.shp')\\n pol.write_to_file(tmp_filename)\\n print 'Polygon with holes written to %s' % tmp_filename\\n\\n pts = Vector(geometry=points[indices, :])\\n tmp_filename = unique_filename(suffix='.shp')\\n pts.write_to_file(tmp_filename)\\n print 'Clipped points written to %s' % tmp_filename\",\n \"def _createpoly(self):\\n return self.cv.create_polygon((0, 0, 0, 0, 0, 0), fill=\\\"\\\", outline=\\\"\\\")\",\n \"def test_polygons_with_inner_rings(self):\\n\\n # Define two (closed) outer rings - clock wise direction\\n outer_rings = [numpy.array([[106.79, -6.233],\\n [106.80, -6.24],\\n [106.78, -6.23],\\n [106.77, -6.21],\\n [106.79, -6.233]]),\\n numpy.array([[106.76, -6.23],\\n [106.72, -6.23],\\n [106.72, -6.22],\\n [106.72, -6.21],\\n [106.76, -6.23]])]\\n\\n tmp_filename = unique_filename(suffix='.shp')\\n\\n # Do outer rings first (use default geometry type polygon)\\n v_ref = Vector(geometry=outer_rings)\\n assert v_ref.is_polygon_data\\n\\n v_ref.write_to_file(tmp_filename)\\n v_file = read_layer(tmp_filename)\\n assert v_file == v_ref\\n assert v_file.is_polygon_data\\n\\n # Do it again but with (closed) inner rings as well\\n\\n # Define inner rings (counter clock wise)\\n inner_rings = [\\n # 2 rings for feature 0\\n [numpy.array([[106.77827, -6.2252],\\n [106.77775, -6.22378],\\n [106.78, -6.22311],\\n [106.78017, -6.22530],\\n [106.77827, -6.2252]])[::-1],\\n numpy.array([[106.78652, -6.23215],\\n [106.78642, -6.23075],\\n [106.78746, -6.23143],\\n [106.78831, -6.23307],\\n [106.78652, -6.23215]])[::-1]],\\n # 1 ring for feature 1\\n [numpy.array([[106.73709, -6.22752],\\n [106.73911, -6.22585],\\n [106.74265, -6.22814],\\n [106.73971, -6.22926],\\n [106.73709, -6.22752]])[::-1]]]\\n\\n polygons = []\\n for i, outer_ring in enumerate(outer_rings):\\n p = Polygon(outer_ring=outer_ring, inner_rings=inner_rings[i])\\n polygons.append(p)\\n\\n v_ref = Vector(geometry=polygons)\\n assert v_ref.is_polygon_data\\n data_bbox = v_ref.get_bounding_box()\\n\\n # Check data from Vector object\\n geometry = v_ref.get_geometry(as_geometry_objects=True)\\n for i, g in enumerate(geometry):\\n assert numpy.allclose(g.outer_ring, outer_rings[i])\\n if i == 0:\\n assert len(g.inner_rings) == 2\\n else:\\n assert len(g.inner_rings) == 1\\n\\n for j, ring in enumerate(inner_rings[i]):\\n assert numpy.allclose(ring, g.inner_rings[j])\\n\\n # Write to file and read again\\n v_ref.write_to_file(tmp_filename)\\n #print 'With inner rings, written to ', tmp_filename\\n v_file = read_layer(tmp_filename)\\n assert v_file == v_ref\\n assert v_file.is_polygon_data\\n assert numpy.allclose(v_file.get_bounding_box(), data_bbox,\\n rtol=1.0e-12, atol=1.0e-12)\\n\\n # Check data from file\\n geometry = v_file.get_geometry(as_geometry_objects=True)\\n for i, g in enumerate(geometry):\\n assert numpy.allclose(g.outer_ring, outer_rings[i])\\n if i == 0:\\n assert len(g.inner_rings) == 2\\n else:\\n assert len(g.inner_rings) == 1\\n\\n for j, ring in enumerate(inner_rings[i]):\\n assert numpy.allclose(ring, g.inner_rings[j])\",\n \"def test_creation(self):\\n\\n assert self.test_shape.solid is not None\\n assert self.test_shape.volume() > 1000\",\n \"def test_creation(self):\\n\\n assert self.test_shape.solid is not None\\n assert self.test_shape.volume() > 1000\",\n \"def CheckClearance(self, via, area, clearance):\\r\\n p1 = via.GetPosition()\\r\\n corners = area.GetNumCorners()\\r\\n # Calculate minimum distance from corners\\r\\n # TODO: remove?\\r\\n for i in range(corners):\\r\\n corner = area.GetCornerPosition(i)\\r\\n p2 = corner.getWxPoint()\\r\\n the_distance = norm(p2 - p1) # sqrt((p2.x - p1.x) ** 2 + (p2.y - p1.y) ** 2)\\r\\n\\r\\n if the_distance < clearance:\\r\\n return False\\r\\n\\r\\n for i in range(corners):\\r\\n corner1 = area.GetCornerPosition(i)\\r\\n corner2 = area.GetCornerPosition((i + 1) % corners)\\r\\n pc1 = corner1.getWxPoint()\\r\\n pc2 = corner2.getWxPoint()\\r\\n the_distance, _ = pnt2line(p1, pc1, pc2)\\r\\n\\r\\n if the_distance <= clearance:\\r\\n return False\\r\\n\\r\\n for edge in self.board_edges:\\r\\n if edge.ShowShape() == 'Line':\\r\\n the_distance, _ = pnt2line(p1, edge.GetStart(), edge.GetEnd())\\r\\n if the_distance <= clearance + via.GetWidth() / 2:\\r\\n return False\\r\\n if edge.ShowShape() == 'Arc':\\r\\n # distance from center of Arc and with angle within Arc angle should be outside Arc radius +- clearance + via Width/2\\r\\n center = edge.GetPosition()\\r\\n start = edge.GetStart()\\r\\n end = edge.GetEnd()\\r\\n radius = norm(center - end)\\r\\n dist = norm(p1 - center)\\r\\n if radius - (self.clearance + via.GetWidth() / 2) < dist < radius + (\\r\\n self.clearance + via.GetWidth() / 2):\\r\\n # via is in range need to check the angle\\r\\n start_angle = math.atan2((start - center).y, (start - center).x)\\r\\n end_angle = math.atan2((end - center).y, (end - center).x)\\r\\n if end_angle < start_angle:\\r\\n end_angle += 2 * math.pi\\r\\n point_angle = math.atan2((p1 - center).y, (p1 - center).x)\\r\\n if start_angle <= point_angle <= end_angle:\\r\\n return False\\r\\n\\r\\n return True\",\n \"def solid(self):\\r\\n return not not self.prototype.solid\",\n \"def __fill_lip_solid(self, outer, inner):\\n inner[0].reverse()\\n inner[1].reverse()\\n outer_curve = zip(outer[0], outer[1])\\n inner_curve = zip(inner[0], inner[1])\\n points = []\\n for point in outer_curve:\\n points.append(np.array(point, dtype=np.int32))\\n for point in inner_curve:\\n points.append(np.array(point, dtype=np.int32))\\n points = np.array(points, dtype=np.int32)\\n self.red_l = int(self.red_l)\\n self.green_l = int(self.green_l)\\n self.blue_l = int(self.blue_l)\\n cv2.fillPoly(self.image, [points], (self.red_l, self.green_l, self.blue_l))\",\n \"def checkRing(self, verbose = 0):\\n angleSum = self.tfs.ANGLE.sum()\\n if self.verbose: print (\\\"check\\\")\\n print (\\\"---------------------------------- \\\\n Checking, if ring is closed: \\\\n\\\", \\\"angleSum = \\\", angleSum)\\n twoPi = 2*pi\\n \\n if angleSum != twoPi:\\n fudge = 2*pi - angleSum\\n print (\\\" ** Ring not closed - offset of: \\\", fudge)\",\n \"def ring_is_clockwise(ring):\\n total = 0\\n for (pt1, pt2) in pairwise(ring):\\n total += (pt2[0] - pt1[0]) * (pt2[1] + pt1[1])\\n return total >= 0\",\n \"def grating_coupler_circular(\\n taper_angle: float = 30.0,\\n taper_length: float = 10.0,\\n length: float = 30.0,\\n period: float = 1.0,\\n fill_factor: float = 0.7,\\n n_periods: int = 30,\\n bias_gap: float = 0,\\n port: Coordinate = (0.0, 0.0),\\n layer_slab: Optional[LayerSpec] = None,\\n layer_cladding: LayerSpec = \\\"WGCLAD\\\",\\n gaps: Optional[Floats] = None,\\n widths: Optional[Floats] = None,\\n direction: str = \\\"EAST\\\",\\n polarization: str = \\\"te\\\",\\n wavelength: float = 1.55,\\n fiber_marker_width: float = 11.0,\\n fiber_marker_layer: Optional[LayerSpec] = \\\"TE\\\",\\n cladding_offset: float = 2.0,\\n cross_section: CrossSectionSpec = \\\"strip\\\",\\n **kwargs,\\n) -> Component:\\n x = gf.get_cross_section(cross_section, **kwargs)\\n layer = x.layer\\n wg_width = x.width\\n\\n widths = widths or n_periods * [period * fill_factor]\\n gaps = gaps or n_periods * [period * (1 - fill_factor)]\\n\\n gaps = np.array(gaps) + bias_gap\\n widths = np.array(widths) - bias_gap\\n teeth_list = list(zip(gaps, widths))\\n\\n layer = gf.get_layer(layer)\\n layer_slab = gf.get_layer(layer_slab)\\n layer_cladding = gf.get_layer(layer_cladding)\\n\\n c = pc.GratingCoupler(\\n gf.call_if_func(\\n strip,\\n cladding_offset=cladding_offset,\\n wg_width=wg_width,\\n layer=layer,\\n layer_cladding=layer_cladding,\\n ),\\n theta=np.deg2rad(taper_angle),\\n length=length,\\n taper_length=taper_length,\\n period=period,\\n dutycycle=fill_factor,\\n ridge=bool(layer_slab),\\n ridge_layers=layer_slab,\\n teeth_list=teeth_list,\\n port=port,\\n direction=direction,\\n )\\n\\n c = gf.read.from_picwriter(c)\\n c.info[\\\"polarization\\\"] = polarization\\n c.info[\\\"wavelength\\\"] = wavelength\\n c.ports[\\\"o1\\\"].cross_section = x\\n\\n fiber_xoffset = np.round(c.center[0] + taper_length / 2, 3)\\n\\n if fiber_marker_layer:\\n circle = gf.components.circle(\\n radius=fiber_marker_width / 2, layer=fiber_marker_layer\\n )\\n circle_ref = c.add_ref(circle)\\n circle_ref.movex(fiber_xoffset)\\n\\n c.add_port(\\n name=f\\\"vertical_{polarization.lower()}\\\",\\n center=[fiber_xoffset, 0],\\n width=fiber_marker_width,\\n orientation=0,\\n layer=fiber_marker_layer,\\n )\\n if x.add_bbox:\\n c = x.add_bbox(c)\\n if x.add_pins:\\n c = x.add_pins(c)\\n return c\",\n \"def test_conv_full(self):\\n\\n points = np.array([[1, 4], [2, 1], [3, 2], [3, 3], [3, 5], [4, 2], [5, 1], [5, 3]]) # example of points \\n \\n cv_hull = convex_hull.convex_hull(points) # convex hull returned by the function \\n\\n right_conv_hull = np.array([[2, 1], [5, 1], [5, 3], [3, 5], [1, 4], [2, 1] ]) # right convex hull\\n self.assertTrue((right_conv_hull == cv_hull).all())\",\n \"def __init__(self, points,\\n fill=False,\\n point_mode=0,\\n point_size=[0.01, 0.01],\\n point_radius=0.01,\\n point_width=1,\\n point_fill=False,\\n side_width=1,\\n color=None,\\n point_color=colors.WHITE,\\n side_color=colors.WHITE,\\n area_color=colors.WHITE,\\n cross_point_color=colors.WHITE,\\n cross_point_radius=0.01,\\n cross_point_mode=0,\\n cross_point_width=1,\\n cross_point_size=[0.1, 0.1],\\n point_show=True,\\n side_show=True,\\n area_show=False):\\n self.points = points\\n\\n self.point_mode = point_mode\\n self.point_size = point_size\\n self.point_width = point_width\\n self.point_radius = point_radius\\n self.point_color = point_color or color\\n self.point_show = point_show\\n self.point_fill = point_fill\\n\\n self.side_width = side_width\\n self.side_color = side_color or color\\n self.side_show = side_show\\n\\n self.area_color = area_color or color\\n self.area_show = area_show or fill\\n\\n self.cross_point_color = cross_point_color\\n self.cross_point_radius = cross_point_radius\\n self.cross_point_mode = cross_point_mode\\n self.cross_point_width = cross_point_width\\n self.cross_point_size = cross_point_size\",\n \"def test_rocket():\\n ring = [(0,0), (10, 0), (15,5), (10,9), (1,7), (6,4), (0,0)]\\n conv = ToPointsAndSegments()\\n conv.add_polygon([ring])\\n skel = calc_skel(conv, output=True, pause=True)\\n print \\\"DONE\\\"\",\n \"def check_win(self):\\n\\n # Sets rings initially to False\\n black_ring = False\\n white_ring = False\\n\\n # Gets board\\n board = self._game_board.get_board_area()\\n\\n # Iterate through stone-holding points\\n for i in range(1, 19):\\n for j in range(1, 19):\\n # Get the surroundings of each point\\n surround = {board[i+1][j], board[i-1][j], board[i+1][j+1], board[i+1][j-1], board[i-1][j],\\n board[i-1][j-1], board[i-1][j+1], board[i][j-1]}\\n\\n # If the point is empty and surrounded by \\\"B\\\", there's a black ring\\n if board[i][j] == \\\" \\\" and surround == {\\\"B\\\"}:\\n black_ring = True\\n\\n # If the point is empty and surrounded by \\\"W\\\", there's a white ring\\n if board[i][j] == \\\" \\\" and surround == {\\\"W\\\"}:\\n white_ring = True\\n\\n if not black_ring:\\n return \\\"WHITE_WON\\\"\\n\\n if not white_ring:\\n return \\\"BLACK_WON\\\"\\n\\n return \\\"UNFINISHED\\\"\",\n \"def special_corner() -> None:\\r\\n if example[1, 1] == 0: # NW\\r\\n if conflict_space[0, 0] == conflict_space[0, 2] and conflict_space[2, 0] == conflict_space[0, 0] \\\\\\r\\n and conflict_space[0, 0] != 0:\\r\\n example[0, 0] = 0\\r\\n safeboard[0, 0] = 0\\r\\n progress_handler(False, True)\\r\\n \\r\\n if example[1, shape-2] == 0: # NE\\r\\n if conflict_space[0, shape-1] == conflict_space[0, shape-3] and \\\\\\r\\n conflict_space[2, shape-1] == conflict_space[0, shape-1] and conflict_space[0, shape-1] != 0:\\r\\n example[0, shape-1] = 0\\r\\n safeboard[0, shape-1] = 0\\r\\n progress_handler(False, True)\\r\\n \\r\\n if example[shape-2, shape-2] == 0: # SE\\r\\n if conflict_space[shape-1, shape-1] == conflict_space[shape-1, shape-3] and \\\\\\r\\n conflict_space[shape-1, shape-1] == conflict_space[shape-3, shape-1] \\\\\\r\\n and conflict_space[shape-1, shape-1] != 0:\\r\\n example[shape-1, shape-1] = 0\\r\\n safeboard[shape-1, shape-1] = 0\\r\\n progress_handler(False, True)\\r\\n \\r\\n if example[shape-2, 1] == 0: # SW\\r\\n if conflict_space[shape-1, 0] == conflict_space[shape-1, 2] and \\\\\\r\\n conflict_space[shape-1, 0] == conflict_space[shape-3, 0] and conflict_space[shape-1, 0] != 0:\\r\\n example[shape-1, 0] = 0\\r\\n safeboard[shape-1, 0] = 0\\r\\n progress_handler(False, True)\\r\\n if progress_handler(True, False):\\r\\n conflict_check()\",\n \"def proc_filled_polygon(self, tokens):\\n\\n return self._proc_polygon(tokens, filled=True)\",\n \"def test_cyclohexane(self):\\n self._test_shape(\\n image_size=(1000, 1000),\\n expected_corners=np.array([\\n [[400, 400]],\\n [[487, 350]],\\n [[574, 400]],\\n [[574, 500]],\\n [[487, 550]],\\n [[400, 500]]\\n ]),\\n drawer=lambda image: image.add_regular_hexagon(\\n 100, start_coord=(400, 400)\\n )\\n )\",\n \"def bc_is_solid(bc):\\n solid = BCProp(int(bc_solid[bc.xlb]),\\n int(bc_solid[bc.xrb]),\\n int(bc_solid[bc.ylb]),\\n int(bc_solid[bc.yrb]))\\n return solid\",\n \"def draw_filled_polygon(\\n self, points: Iterable[Vec3], properties: Properties\\n ) -> None:\\n raise NotImplementedError\",\n \"def add_cable(self, env, size_range, info={}, cable_idx=0,\\n direction='z', max_force=100):\\n num_parts = self.num_parts\\n radius = self.radius\\n length = self.length\\n color = self.colors[cable_idx] + [1]\\n color_end = U.COLORS['yellow'] + [1]\\n\\n # Add beaded cable.\\n distance = length / num_parts\\n position, _ = self.random_pose(env, size_range)\\n position = np.float32(position)\\n part_shape = p.createCollisionShape(p.GEOM_BOX, halfExtents=[radius]*3)\\n part_visual = p.createVisualShape(p.GEOM_SPHERE, radius=radius*1.5)\\n\\n # Iterate through parts and create constraints as needed.\\n for i in range(num_parts):\\n if direction == 'x':\\n position[0] += distance\\n parent_frame = (distance, 0, 0)\\n elif direction == 'y':\\n position[1] += distance\\n parent_frame = (0, distance, 0)\\n else:\\n position[2] += distance\\n parent_frame = (0, 0, distance)\\n\\n part_id = p.createMultiBody(0.1, part_shape, part_visual,\\n basePosition=position)\\n if i > 0:\\n constraint_id = p.createConstraint(\\n parentBodyUniqueId=env.objects[-1],\\n parentLinkIndex=-1,\\n childBodyUniqueId=part_id,\\n childLinkIndex=-1,\\n jointType=p.JOINT_POINT2POINT,\\n jointAxis=(0, 0, 0),\\n parentFramePosition=parent_frame,\\n childFramePosition=(0, 0, 0))\\n p.changeConstraint(constraint_id, maxForce=max_force)\\n\\n if (i > 0) and (i < num_parts - 1):\\n p.changeVisualShape(part_id, -1, rgbaColor=color)\\n elif i == num_parts - 1:\\n p.changeVisualShape(part_id, -1, rgbaColor=color_end)\\n\\n # The usual for tracking IDs. Four things to add.\\n self.cable_bead_IDs.append(part_id)\\n self._IDs[part_id] = f'cable_part_{str(part_id).zfill(2)}'\\n env.objects.append(part_id)\\n self.object_points[part_id] = np.float32((0, 0, 0)).reshape(3, 1)\\n\\n # Get target placing positions for each cable bead, if applicable.\\n if self._name == 'cable-shape' or self._name == 'cable-shape-notarget' or \\\\\\n self._name == 'cable-line-notarget':\\n # ----------------------------------------------------------- #\\n # Here, zone_pose = square_pose, unlike Ravens cable, where the\\n # zone_pose is shifted so that its center matches the straight\\n # line segment center. For `true_position`, we use `zone_pose`\\n # but apply the correct offset to deal with the sides. Note\\n # that `length` is the size of a fully smoothed cable, BUT we\\n # made a rectangle with each side <= length.\\n # ----------------------------------------------------------- #\\n lx = info['lengthx']\\n ly = info['lengthy']\\n r = radius\\n\\n if info['nb_sides'] == 1:\\n # Here it's just a straight line on the 'lx' side.\\n x_coord = lx / 2 - (distance * i)\\n y_coord = 0\\n true_position = (x_coord - r, y_coord, 0)\\n\\n elif info['nb_sides'] == 2:\\n # Start from lx side, go 'left' to the pivot point, then on\\n # the ly side, go 'upwards' but offset by `i`. For radius\\n # offset, I just got this by tuning. XD\\n if i < info['cutoff']:\\n x_coord = lx / 2 - (distance * i)\\n y_coord = -ly / 2\\n true_position = (x_coord - r, y_coord, 0)\\n else:\\n x_coord = -lx / 2\\n y_coord = -ly / 2 + (distance * (i - info['cutoff']))\\n true_position = (x_coord, y_coord + r, 0)\\n\\n elif info['nb_sides'] == 3:\\n # Start from positive lx, positive ly, go down to first\\n # pivot. Then go left to the second pivot, then up again.\\n # For v1, division by two is because we assume BOTH of the\\n # 'ly edges' were divided by two.\\n v1 = (self.num_parts - info['cutoff']) / 2\\n v2 = self.num_parts - v1\\n if i < v1:\\n x_coord = lx / 2\\n y_coord = ly / 2 - (distance * i)\\n true_position = (x_coord, y_coord - r, 0)\\n elif i < v2:\\n x_coord = lx / 2 - (distance * (i - v1))\\n y_coord = -ly / 2\\n true_position = (x_coord - r, y_coord, 0)\\n else:\\n x_coord = -lx / 2\\n y_coord = -ly / 2 + (distance * (i - v2))\\n true_position = (x_coord, y_coord + r, 0)\\n\\n elif info['nb_sides'] == 4:\\n # I think this is similar to the 2-side case: we start in\\n # the same direction and go counter-clockwise.\\n v1 = info['cutoff'] / 2\\n v2 = num_parts / 2\\n v3 = (num_parts + info['cutoff']) / 2\\n if i < v1:\\n x_coord = lx / 2 - (distance * i)\\n y_coord = -ly / 2\\n true_position = (x_coord, y_coord, 0)\\n elif i < v2:\\n x_coord = -lx / 2\\n y_coord = -ly / 2 + (distance * (i - v1))\\n true_position = (x_coord, y_coord, 0)\\n elif i < v3:\\n x_coord = -lx / 2 + (distance * (i - v2))\\n y_coord = ly / 2\\n true_position = (x_coord, y_coord, 0)\\n else:\\n x_coord = lx / 2\\n y_coord = ly / 2 - (distance * (i - v3))\\n true_position = (x_coord, y_coord, 0)\\n\\n # Map true_position onto the workspace from zone_pose.\\n true_position = self.apply(self.zone_pose, true_position)\\n\\n # See `cable.py`: just get the places and steps set.\\n self.goal['places'][part_id] = (true_position, (0, 0, 0, 1.))\\n symmetry = 0\\n self.goal['steps'][0][part_id] = (symmetry, [part_id])\\n\\n # Debugging target zones.\\n if self.target_debug_markers:\\n sq_pose = ((true_position[0], true_position[1], 0.002), (0,0,0,1))\\n sq_template = 'assets/square/square-template-allsides-blue.urdf'\\n replace = {'DIM': (0.003,), 'HALF': (0.003 / 2,)}\\n urdf = self.fill_template(sq_template, replace)\\n env.add_object(urdf, sq_pose, fixed=True)\\n os.remove(urdf)\\n else:\\n print(f'Warning, env {self._name} will not have goals.')\",\n \"def _convex_hull_side(image, start, end):\\n\\n convex_points = [start]\\n\\n x_start, y_start = start\\n x_end, y_end = end\\n\\n side = (x_start <= x_end, y_start <= y_end)\\n\\n\\n ranges = {\\n (True, True): [\\n [x_start + 1, x_end + 1],\\n [y_start, y_end + 1],\\n False\\n ],\\n (False, True): [\\n [y_start + 1, y_end + 1],\\n [x_start, x_end - 1, -1],\\n True\\n ],\\n (False, False): [\\n [x_start - 1, x_end - 1, -1],\\n [y_start, y_end - 1, -1],\\n False\\n ],\\n (True, False): [\\n [y_start - 1, y_end - 1, -1],\\n [x_start, x_end + 1],\\n True\\n ]\\n }\\n\\n prev = 0\\n\\n for outer in range(*ranges[side][0]):\\n\\n curr_pixel = None\\n\\n for inner in range(*ranges[side][1]):\\n if ranges[side][2] and image[outer, inner] == 0:\\n curr_pixel = (inner, outer)\\n break\\n elif not ranges[side][2] and image[inner, outer] == 0:\\n curr_pixel = (outer, inner)\\n break\\n\\n if curr_pixel is None:\\n continue\\n\\n while True:\\n # slope infinite for first point\\n prev_slope = (\\n float(\\\"-inf\\\") if prev == 0\\n else slope(\\n convex_points[prev - 1],\\n convex_points[prev],\\n ranges[side][2]))\\n\\n # remove previous point if it yields concave segment\\n if prev_slope > slope(\\n convex_points[prev],\\n curr_pixel,\\n ranges[side][2]\\n ):\\n convex_points.pop(prev)\\n prev -= 1\\n # add point to hull if it yields convex segment\\n else:\\n convex_points.append(curr_pixel)\\n prev += 1\\n break\\n\\n return convex_points[1:]\",\n \"def cleanOpenBranches(skeleton, skelton_copy, points, radii, length, clean = True, verbose = False):\\n \\n assert np.isfortran(skeleton);\\n assert np.isfortran(skelton_copy);\\n \\n timer = tmr.Timer();\\n timer_all = tmr.Timer();\\n \\n # find branch and end points\\n deg = cpl.convolve_3d_indices(skeleton, t3d.n26, points, out_dtype = 'uint8');\\n branchpoints = points[deg >= 3];\\n e_pts = points[deg == 1];\\n \\n if verbose:\\n timer.printElapsedTime('Detected %d branch and %d endpoints' % (branchpoints.shape[0], e_pts.shape[0]));\\n timer.reset();\\n \\n #prepare temps\\n #skel = skeleton.copy();\\n skel_flat = np.reshape(skelton_copy, -1, order = 'A');\\n strides = np.array(skelton_copy.strides);\\n \\n \\n if verbose:\\n timer.printElapsedTime('Detected %d branch and %d endpoints' % (branchpoints.shape[0], e_pts.shape[0]));\\n timer.reset();\\n \\n label = np.arange(27);\\n label = label.reshape([3,3,3]);\\n label[1,1,1] = 0;\\n \\n critical_points = [e_pts];\\n delete_points = [];\\n \\n for l in range(1, length + 1):\\n #neighbours of end points\\n e_pts_label = cpl.convolve_3d_indices(skelton_copy, label, e_pts);\\n \\n if verbose:\\n timer.printElapsedTime('Done labeling %d / %d' % (l, length));\\n timer.reset();\\n \\n #label zero points are non-critical short isolated branches\\n e_pts_zero = e_pts_label == 0;\\n #print 'zero length:', np.unravel_index(e_pts[e_pts_zero], skel.shape)\\n if e_pts_zero.sum() > 0:\\n keep = np.logical_not(e_pts_zero);\\n for m in range(l):\\n critical_points[m] = critical_points[m][keep];\\n e_pts_label = e_pts_label[keep];\\n e_pts = e_pts[keep];\\n \\n if verbose:\\n timer.printElapsedTime('Ignored %d small branches' % (keep.sum()));\\n timer.reset();\\n \\n e_pts_new = e_pts + np.sum((np.vstack(np.unravel_index(e_pts_label, label.shape)) - 1).T * strides, axis = 1)\\n \\n # did we hit a branch point\\n delete = np.in1d(e_pts_new, branchpoints); #, assume_unique = True);\\n keep = np.logical_not(delete);\\n #print delete.shape, keep.shape, e_pts_new.shape\\n \\n #delete all path that hit a branch point\\n if delete.sum() > 0:\\n for m in range(l):\\n delete_points.append(critical_points[m][delete]);\\n #print 'deleting:', np.unravel_index(critical_points[m][delete], skel.shape)\\n critical_points[m] = critical_points[m][keep];\\n e_pts_new = e_pts_new[keep];\\n \\n if verbose:\\n timer.printElapsedTime('Deleted %d points' % (delete.sum()));\\n timer.reset();\\n \\n if l < length:\\n skel_flat[e_pts] = False; # remove endpoints for new neighbour detection\\n critical_points.append(e_pts_new);\\n e_pts = e_pts_new;\\n \\n if verbose:\\n timer.printElapsedTime('Cleanup iteration %d / %d done.' % (l, length));\\n \\n #gather all points\\n if len(delete_points) > 0:\\n delete_points = np.hstack(delete_points);\\n delete_points = np.unique(delete_points);\\n else:\\n delete_points = np.zeros(0);\\n \\n if verbose:\\n timer_all.printElapsedTime('Cleanup');\\n \\n if clean:\\n skel_flat = np.reshape(skeleton, -1, order = 'F');\\n skel_flat[delete_points] = False;\\n keep_ids = np.logical_not(np.in1d(points, delete_points, assume_unique = True))\\n points = points[keep_ids];\\n radii = radii[keep_ids];\\n return skeleton, points, radii\\n \\n return delete_points;\",\n \"def corridor(x,z, emap, width=10, length=10, height=10, details=None, walls=\\\"ns\\\", name=\\\"wall\\\", mergeshape=None):\\r\\n global wallnum\\r\\n n = z + width / 2\\r\\n s = z - width / 2\\r\\n e = x + length / 2\\r\\n w = x - length / 2\\r\\n\\r\\n solid_objects = []\\r\\n\\r\\n if \\\"n\\\" in walls:\\r\\n # TODO: abstract out the mostly-duplicate code in these cases...\\r\\n nwall = SolidObject(name+str(wallnum),\\r\\n Size(length, height, 1),\\r\\n Position(x, emap.calcHeight(x, z) + height / 2, n-0.5), 0)\\r\\n solid_objects.append(nwall)\\r\\n nwallmodel = createMyCuboid(nwall.w() * 2, nwall.h() * 2, nwall.d() * 2,\\r\\n name=name+str(wallnum),\\r\\n x=nwall.x(),y=nwall.y(),z=nwall.z(),\\r\\n rx=0.0, ry=0.0, rz=0.0, cx=0.0, cy=0.0, cz=0.0)\\r\\n if mergeshape:\\r\\n mergeshape.add(nwallmodel)\\r\\n else:\\r\\n nwall.setmodel(nwallmodel, details)\\r\\n\\r\\n\\r\\n wallnum += 1\\r\\n\\r\\n if \\\"s\\\" in walls:\\r\\n swall = SolidObject(name+str(wallnum), Size(length, height, 1), Position(x, emap.calcHeight(x, z)+height / 2, s+0.5), 0)\\r\\n solid_objects.append(swall)\\r\\n swallmodel = createMyCuboid(swall.w()*2, swall.h()*2, swall.d()*2,\\r\\n name=name+str(wallnum),\\r\\n x=swall.x(), y=swall.y(), z=swall.z(),\\r\\n rx=0.0, ry=0.0, rz=0.0, cx=0.0,cy=0.0, cz=0.0)\\r\\n if mergeshape:\\r\\n mergeshape.add(swallmodel)\\r\\n else:\\r\\n swall.setmodel(swallmodel, details)\\r\\n\\r\\n wallnum += 1\\r\\n\\r\\n if \\\"e\\\" in walls:\\r\\n ewall = SolidObject(name+str(wallnum), Size(1, height, width), Position(e-0.5, emap.calcHeight(x, z)+height / 2, z), 0)\\r\\n solid_objects.append(ewall)\\r\\n ewallmodel = createMyCuboid(ewall.w()*2, ewall.h()*2, ewall.d()*2,\\r\\n name=name+str(wallnum),\\r\\n x=ewall.x(), y=ewall.y(), z=ewall.z(),\\r\\n rx=0.0, ry=0.0, rz=0.0, cx=0.0, cy=0.0, cz=0.0)\\r\\n if mergeshape:\\r\\n mergeshape.add(ewallmodel)\\r\\n else:\\r\\n ewall.setmodel(ewallmodel, details)\\r\\n\\r\\n wallnum += 1\\r\\n\\r\\n if \\\"w\\\" in walls:\\r\\n wwall = SolidObject(name+str(wallnum), Size(1, height, width), Position(w+0.5, emap.calcHeight(x, z)+height / 2, z), 0)\\r\\n solid_objects.append(wwall)\\r\\n wwallmodel = createMyCuboid(wwall.w()*2, wwall.h()*2, wwall.d()*2,\\r\\n name=name+str(wallnum),\\r\\n x=wwall.x(), y=wwall.y(), z=wwall.z(),\\r\\n rx=0.0, ry=0.0, rz=0.0, cx=0.0, cy=0.0, cz=0.0)\\r\\n if mergeshape:\\r\\n mergeshape.add(wwallmodel)\\r\\n else:\\r\\n wwall.setmodel(wwallmodel, details)\\r\\n wallnum += 1\\r\\n\\r\\n if \\\"o\\\" not in walls:\\r\\n ceiling = SolidObject(name+str(wallnum), Size(length, 1, width), Position(x, emap.calcHeight(x, z)+height+0.5, z), 0)\\r\\n solid_objects.append(ceiling)\\r\\n ceilingmodel = createMyCuboid(ceiling.w()*2, ceiling.h()*2, ceiling.d()*2,\\r\\n name=name+str(wallnum),\\r\\n x=ceiling.x(), y=ceiling.y(), z=ceiling.z(),\\r\\n rx=0.0, ry=0.0, rz=0.0, cx=0.0, cy=0.0, cz=0.0)\\r\\n if mergeshape:\\r\\n mergeshape.add(ceilingmodel)\\r\\n else:\\r\\n ceiling.setmodel(ceilingmodel, details)\\r\\n\\r\\n wallnum += 1\\r\\n\\r\\n return solid_objects\",\n \"def circlePrimitive(self):\\n\\n def drawWireframe(self):\\n\\n # Draw line\\n glFT.glBegin(OpenMayaRender.MGL_LINE_STRIP)\\n\\n # Get Color\\n # self.getColor(\\\"edge\\\")\\n\\n def_circle = 100\\n for idx in range(def_circle + 1):\\n\\n theta = 2 * 3.141592 * idx / def_circle\\n x = self.shape_size * math.cos(theta)\\n z = self.shape_size * math.sin(theta)\\n\\n point = OpenMaya.MVector(x, 0.0, z)\\n point = self.setUpAxis(point)\\n point = self.addOffsetRotation(point)\\n point = self.addOffsetPosition(point)\\n self.getBoundingBoxSize(point)\\n\\n glFT.glVertex3f(point.x, point.y, point.z)\\n\\n glFT.glEnd()\\n \\n def drawShaded(self):\\n\\n # Draw quad\\n glFT.glBegin(OpenMayaRender.MGL_POLYGON)\\n\\n # Get Color\\n # self.getColor(\\\"polygon\\\")\\n\\n def_circle = 100\\n for idx in range(def_circle + 1):\\n\\n theta = 2 * 3.141592 * idx / def_circle\\n x = self.shape_size * math.cos(theta)\\n z = self.shape_size * math.sin(theta)\\n\\n point = OpenMaya.MVector(x, 0.0, z)\\n point = self.setUpAxis(point)\\n point = self.addOffsetRotation(point)\\n point = self.addOffsetPosition(point)\\n self.getBoundingBoxSize(point)\\n\\n glFT.glVertex3f(point.x, point.y, point.z)\\n\\n glFT.glEnd()\\n\\n glFT.glNewList(self.vList_id, OpenMayaRender.MGL_COMPILE)\\n\\n # Draw lines\\n if self.draw_type == 0 or self.draw_type == 2:\\n drawWireframe(self)\\n \\n # Draww Polygons\\n if self.draw_type == 1 or self.draw_type == 2:\\n drawShaded(self)\\n\\n glFT.glEndList()\",\n \"def geoshapes(c = False, r = False, t = False):\\n if c == True:\\n circle = plt.Circle((0,0), radius = 3, fill = None, edgecolor = 'y')\\n plt.gca().add_patch(circle)\\n elif r == True:\\n rectangle = plt.Rectangle((0, 0), 5, 5, fill = None, edgecolor='r')\\n plt.gca().add_patch(rectangle)\\n elif t == True:\\n points = [[0,0], [0,3], [3,3]]\\n triangle = plt.Polygon(points, fill = None, edgecolor = 'r')\\n plt.gca().add_patch(triangle)\\n else:\\n print('Error: please input a True value for either c, r , or t')\",\n \"def checkForCircle(self, points, tangents):\\n if len(points)<10:\\n return False, 0\\n\\n if all(points[0]==points[-1]): # last exactly equals the first.\\n # Ignore last point for this check\\n points = points[:-1]\\n tangents = tangents[:-1]\\n #print 'Removed last ', points\\n xmin,ymin, w, h = computeBox( points)\\n diag2=(w*w+h*h)\\n \\n diag = sqrt(diag2)*0.5\\n norms = numpy.sqrt(numpy.sum( tangents**2, 1 ))\\n\\n angles = numpy.arctan2( tangents[:,1], tangents[:,0] ) \\n #debug( 'angle = ', repr(angles))\\n N = len(angles)\\n \\n deltas = points[1:] - points[:-1] \\n deltasD = numpy.concatenate([ [D(points[0],points[-1])/diag], numpy.sqrt(numpy.sum( deltas**2, 1 )) / diag] )\\n\\n # locate and avoid the point when swicthing\\n # from -pi to +pi. The point is around the minimum\\n imin = numpy.argmin(angles)\\n debug(' imin ',imin)\\n angles = numpy.roll(angles, -imin)\\n deltasD = numpy.roll(deltasD, -imin)\\n n=int(N*0.1)\\n # avoid fluctuations by removing points around the min\\n angles=angles[n:-n]\\n deltasD=deltasD[n:-n]\\n deltasD = deltasD.cumsum()\\n N = len(angles)\\n\\n # smooth angles to avoid artificial bumps\\n angles = smoothArray(angles, n=max(int(N*0.03),2) )\\n\\n deltaA = angles[1:] - angles[:-1]\\n deltasDD = (deltasD[1:] -deltasD[:-1])\\n deltasDD[numpy.where(deltasDD==0.)] = 1e-5*deltasD[0]\\n dAdD = abs(deltaA/deltasDD)\\n belowT, count = True,0\\n for v in dAdD:\\n if v>6 and belowT:\\n count+=1\\n belowT = False\\n belowT= (v<6)\\n\\n self.temp = (deltasD,angles, tangents, dAdD )\\n fracStraight = numpy.sum(deltasDD[numpy.where(dAdD<0.3)])/(deltasD[-1]-deltasD[0])\\n curveLength = deltasD[-1]/3.14\\n #print \\\"SSS \\\",count , fracStraight\\n if curveLength> 1.4 or fracStraight>0.4 or count > 6:\\n isCircle =False\\n else: \\n isCircle= (count < 4 and fracStraight<=0.3) or \\\\\\n (fracStraight<=0.1 and count<5)\\n\\n if not isCircle:\\n return False, 0\\n \\n # It's a circle !\\n radius = points - numpy.array([xmin+w*0.5,ymin+h*0.5])\\n radius_n = numpy.sqrt(numpy.sum( radius**2, 1 )) # normalize\\n\\n mini = numpy.argmin(radius_n) \\n rmin = radius_n[mini]\\n maxi = numpy.argmax(radius_n) \\n rmax = radius_n[maxi]\\n # void points around maxi and mini to make sure the 2nd max is found\\n # on the \\\"other\\\" side\\n n = len(radius_n)\\n radius_n[maxi]=0 \\n radius_n[mini]=0 \\n for i in range(1,n/8+1):\\n radius_n[(maxi+i)%n]=0\\n radius_n[(maxi-i)%n]=0\\n radius_n[(mini+i)%n]=0\\n radius_n[(mini-i)%n]=0\\n radius_n_2 = [ r for r in radius_n if r>0]\\n rmax_2 = max(radius_n_2)\\n rmin_2 = min(radius_n_2) # not good !!\\n anglemax = numpy.arccos( radius[maxi][0]/rmax)*numpy.sign(radius[maxi][1])\\n return True, (xmin+w*0.5,ymin+h*0.5, 0.5*(rmin+rmin_2), 0.5*(rmax+rmax_2), anglemax)\",\n \"def HollowCylinder(self,center=(0,0,0),inner_radius=1.0,outer_radius=2.,\\n element_type='hex',isotropic=True,nrad=5,ncirc=10, nlong=20,length=10):\\n\\n if element_type != \\\"hex\\\":\\n raise NotImplementedError('Generating {} mesh of cylinder is not supported yet'.format(element_type))\\n\\n if not isinstance(center,tuple):\\n raise ValueError(\\\"The center for the base of the cylinder should be given in a tuple with three elements (x,y,z)\\\")\\n\\n self.__reset__()\\n\\n nlong = int(nlong)\\n if nlong==0:\\n nlong = 1\\n\\n mesh = Mesh()\\n mesh.HollowCircle(center=(center[0],center[1]), inner_radius=inner_radius,\\n outer_radius=outer_radius, element_type=\\\"quad\\\",\\n isotropic=isotropic, nrad=nrad, ncirc=ncirc)\\n\\n self.Extrude(base_mesh=mesh, length=length, nlong=nlong)\\n self.points += center[2]\",\n \"def __init__(self, point, angle, width=1, color=colors.WHITE, correct=True):\\n if correct:\\n self.angle = angle\\n self.point = point\\n else:\\n self._angle = angle\\n self._point = point\\n self.width = width\\n self.color = color\",\n \"def createCone( basePoint=(0,-1,0), tipPoint=(0,1,0), radius = 1.0, colour=(0.6,0.6,0.6), samples = 20 ):\\r\\n \\r\\n basePoint = PyUtils.toPoint3d(basePoint)\\r\\n tipPoint = PyUtils.toPoint3d(tipPoint)\\r\\n baseToTipVector = Vector3d(basePoint,tipPoint)\\r\\n if baseToTipVector.isZeroVector() :\\r\\n raise ValueError( 'Invalid points for cylinder: base and tip are equal!' )\\r\\n baseToTipUnitVector = baseToTipVector.unit()\\r\\n xUnitVector = baseToTipUnitVector.crossProductWith( Vector3d(0,0,1) )\\r\\n if xUnitVector.length() < 0.5 :\\r\\n xUnitVector = baseToTipUnitVector.crossProductWith( Vector3d(0,-1,0) )\\r\\n xUnitVector.toUnit()\\r\\n yUnitVector = baseToTipUnitVector.crossProductWith( Vector3d(-1,0,0) )\\r\\n if yUnitVector.length() < 0.5 :\\r\\n yUnitVector = baseToTipUnitVector.crossProductWith( Vector3d(0,1,0) )\\r\\n yUnitVector.toUnit()\\r\\n\\r\\n vertices = []\\r\\n for i in range(samples):\\r\\n theta = i * 2 * math.pi / float(samples)\\r\\n vertices.append( basePoint + xUnitVector * math.cos(theta) * radius + yUnitVector * math.sin(theta) * radius )\\r\\n for i in range(samples):\\r\\n theta = i * 2 * math.pi / float(samples)\\r\\n vertices.append( basePoint + xUnitVector * math.cos(theta) * radius + yUnitVector * math.sin(theta) * radius )\\r\\n vertices.append( tipPoint )\\r\\n \\r\\n faces = [ range(0,samples) ]\\r\\n for i in range(0,samples) :\\r\\n base = samples\\r\\n size = samples\\r\\n faces.append( (base+i, base+(i+1)%size, 2*samples ) )\\r\\n \\r\\n return create( vertices, faces, colour )\",\n \"def _cal_meaningful_corners(self):\\n corners = np.where(self._free_of_clash)\\n corners = np.array(corners, dtype=int)\\n corners = corners.transpose()\\n return corners\",\n \"def drawShapes(self):\\n self.draw_polygon(self.poly3.get_points() , color = \\\"#000\\\")\\n self.draw_polygon(self.poly2.get_points() , color = \\\"#000\\\")\\n self.draw_polygon(self.poly1.get_points() , color = \\\"#000\\\")\\n self.draw_rect(0, 0, self.width, self.height, color= \\\"#000\\\")\\n \\\"\\\"\\\"These statements are used to determine if a point is inside any of the\\n 3 polygons and if so changes the point's color\\\"\\\"\\\"\\n if (self.poly2.point_inside_polygon(self.p1) or self.poly1.point_inside_polygon(self.p1)\\n or self.poly3.point_inside_polygon(self.p1)):\\n color = \\\"#0F0\\\"\\n else:\\n color = \\\"#F00\\\"\\n self.fill_oval(self.p1.x, self.p1.y, 7, 7, color)\\n\\n if (self.poly2.point_inside_polygon(self.p2) or self.poly1.point_inside_polygon(self.p2)\\n or self.poly3.point_inside_polygon(self.p2)):\\n color = \\\"#0F0\\\"\\n else:\\n color = \\\"#F00\\\"\\n self.fill_oval(self.p2.x, self.p2.y, 7, 7, color)\\n if (self.poly2.point_inside_polygon(self.p3) or self.poly1.point_inside_polygon(self.p3)\\n or self.poly3.point_inside_polygon(self.p3)):\\n color = \\\"#0F0\\\"\\n else:\\n color = \\\"#F00\\\"\\n self.fill_oval(self.p3.x, self.p3.y, 7, 7, color)\",\n \"def bolthole(location, diameter, clamp_length, nuthole_size, nuthole_depth):\\n bolthole = (\\n cq.Workplane()\\n .bolt(\\n bolt_size = diameter,\\n head_size = 2 * diameter,\\n head_length = 2 * diameter,\\n head_shape = \\\"cylindrical\\\", \\n head_angle = 90,\\n clamp_length = clamp_length,\\n nut_size = nuthole_size,\\n nut_length = nuthole_depth\\n )\\n .val()\\n .located(location * cq.Location(cq.Vector(0, 0, - clamp_length / 2)))\\n )\\n # show_object(bolthole) # Debug helper.\\n return bolthole\",\n \"def crpolygon(self, x, y, r, n, t0=0, cls=None, style=None):\\n t0 = 2 * math.pi * t0 / 360.0\\n dt = 2 * math.pi / n\\n pts = []\\n for idx in xrange(n + 1):\\n dx = x + r * math.cos(t0)\\n dy = y + r * math.sin(t0)\\n t0 += dt\\n pts.append('M' if idx == 0 else 'Z' if idx == n else 'L')\\n pts.append('%s %s' % (dx, dy))\\n self.path(pts, cls=cls, style=style)\",\n \"def crpolygon(self, x, y, r, n, t0=0, cls=None, style=None):\\n t0 = 2 * math.pi * t0 / 360.0\\n dt = 2 * math.pi / n\\n pts = []\\n for idx in xrange(n + 1):\\n dx = x + r * math.cos(t0)\\n dy = y + r * math.sin(t0)\\n t0 += dt\\n pts.append('M' if idx == 0 else 'Z' if idx == n else 'L')\\n pts.append('%s %s' % (dx, dy))\\n self.path(pts, cls=cls, style=style)\",\n \"def fill_polygon(self, sides, x0, y0, r, color, rotate=0):\\n # Determine side coordinates\\n coords = []\\n theta = radians(rotate)\\n n = sides + 1\\n for s in range(n):\\n t = 2.0 * pi * s / sides + theta\\n coords.append([int(r * cos(t) + x0), int(r * sin(t) + y0)])\\n # Starting point\\n x1, y1 = coords[0]\\n # Minimum Maximum X dict\\n xdict = {y1: [x1, x1]}\\n # Iterate through coordinates\\n for row in coords[1:]:\\n x2, y2 = row\\n xprev, yprev = x2, y2\\n # Calculate perimeter\\n # Check for horizontal side\\n if y1 == y2:\\n if x1 > x2:\\n x1, x2 = x2, x1\\n if y1 in xdict:\\n xdict[y1] = [min(x1, xdict[y1][0]), max(x2, xdict[y1][1])]\\n else:\\n xdict[y1] = [x1, x2]\\n x1, y1 = xprev, yprev\\n continue\\n # Non horizontal side\\n # Changes in x, y\\n dx = x2 - x1\\n dy = y2 - y1\\n # Determine how steep the line is\\n is_steep = abs(dy) > abs(dx)\\n # Rotate line\\n if is_steep:\\n x1, y1 = y1, x1\\n x2, y2 = y2, x2\\n # Swap start and end points if necessary\\n if x1 > x2:\\n x1, x2 = x2, x1\\n y1, y2 = y2, y1\\n # Recalculate differentials\\n dx = x2 - x1\\n dy = y2 - y1\\n # Calculate error\\n error = dx >> 1\\n ystep = 1 if y1 < y2 else -1\\n y = y1\\n # Calcualte minimum and maximum x values\\n for x in range(x1, x2 + 1):\\n if is_steep:\\n if x in xdict:\\n xdict[x] = [min(y, xdict[x][0]), max(y, xdict[x][1])]\\n else:\\n xdict[x] = [y, y]\\n else:\\n if y in xdict:\\n xdict[y] = [min(x, xdict[y][0]), max(x, xdict[y][1])]\\n else:\\n xdict[y] = [x, x]\\n error -= abs(dy)\\n if error < 0:\\n y += ystep\\n error += dx\\n x1, y1 = xprev, yprev\\n # Fill polygon\\n for y, x in xdict.items():\\n self.hline(x[0], y, x[1] - x[0] + 2, color)\",\n \"def stokes_right_circular():\\n return np.array([1, 0, 0, 1])\",\n \"def is_ccw(geometry, **kwargs):\\n return lib.is_ccw(geometry, **kwargs)\",\n \"def tail_joiner(self):\\n\\n # Fusing Right Horizontal Tail:\\n shape_in_r = Fused(shape_in=self.stabilizer_h.solid, tool=self.stabilizer_vright.solid)\\n shape_out_r = Fused(shape_in=shape_in_r, tool=self.connector_right)\\n\\n # Fusing Left Horizontal Tail:\\n shape_in_l = Fused(shape_in=self.stabilizer_h.ht_mirror, tool=self.stabilizer_vleft.solid)\\n shape_out_l = Fused(shape_in=shape_in_l, tool=self.connector_left)\\n\\n shape_out = Fused(shape_in=shape_out_r, tool=shape_out_l)\\n\\n return shape_out\",\n \"def make_tight_box(self, tightness: float = 0.33) -> None:\\r\\n\\r\\n # Default to the plant's original box\\r\\n x1 = self.box[0]\\r\\n y1 = self.box[1]\\r\\n x2 = self.box[2]\\r\\n y2 = self.box[3]\\r\\n\\r\\n ## Find y coordinates\\r\\n # Initialize variables and sort pixels by x coordinate\\r\\n width = self.box[2] - self.box[0]\\r\\n cents = sorted(self.cluster, key = lambda u: u[1])\\r\\n clust = []\\r\\n curr = cents[0][1]\\r\\n last = 0\\r\\n\\r\\n # Split the pixels by x coordinate\\r\\n for p in range(len(cents)):\\r\\n if cents[p][1] != curr:\\r\\n clust.append(cents[last: p])\\r\\n curr = cents[p][1]\\r\\n last = p\\r\\n \\r\\n # Get the topmost y value which is <tightness> green\\r\\n for hor in clust:\\r\\n if len(hor) / width > tightness:\\r\\n y1 = hor[0][1]\\r\\n break\\r\\n\\r\\n # Get the bottommost y value which is <tightness> green\\r\\n for hor in clust[::-1]:\\r\\n if len(hor) / width > tightness:\\r\\n y2 = hor[0][1]\\r\\n break\\r\\n\\r\\n ## Find x coordinates\\r\\n # Initialize variables and sort pixels by y coordinate\\r\\n height = self.box[3] - self.box[1]\\r\\n cents = sorted(self.cluster, key = lambda u: u[0])\\r\\n clust = []\\r\\n curr = cents[0][0]\\r\\n last = 0\\r\\n\\r\\n # Split the pixels by y coordinate\\r\\n for p in range(len(cents)):\\r\\n if cents[p][0] != curr:\\r\\n clust.append(cents[last: p])\\r\\n curr = cents[p][0]\\r\\n last = p\\r\\n\\r\\n # Get the leftmost x value which is <tightness> green\\r\\n for ver in clust:\\r\\n if len(ver) / height > tightness:\\r\\n x1 = ver[0][0]\\r\\n break\\r\\n\\r\\n # Get the rightmost x value which is <tightness> green\\r\\n for ver in clust[::-1]:\\r\\n if len(ver) / height > tightness:\\r\\n x2 = ver[0][0]\\r\\n break\\r\\n\\r\\n # Default to original x values if no better estimate was found\\r\\n if x1 == x2:\\r\\n x1 = self.box[0]\\r\\n x2 = self.box[2]\\r\\n\\r\\n # Default to original y values if no better estimate was found\\r\\n if y1 == y2:\\r\\n y1 = self.box[1]\\r\\n y2 = self.box[3]\\r\\n\\r\\n self.tight_box = (x1, y1, x2, y2)\",\n \"def create_wall_shape(self):\\n self.shape_walls = arcade.ShapeElementList()\\n self.shape_walls.center_x = 0\\n self.shape_walls.center_y = 0\\n self.shape_walls.angle = 0\\n\\n point_list = []\\n color_list = []\\n \\n # create the walls into a single shape\\n walls = self.game.walls\\n for wall in walls:\\n points = self.get_entity_dimensions(wall)\\n point_list.append(points[0])\\n point_list.append(points[1])\\n point_list.append(points[2])\\n point_list.append(points[3])\\n \\n # as we have 4 points\\n for i in range(4):\\n color_list.append(COLOUR_MAP[wall.base_colour])\\n \\n self.shape_walls.append(\\n arcade.create_rectangles_filled_with_colors(point_list, color_list)\\n )\",\n \"def build_lens_icosahedron(kabamland, vtx, rad, diameter_ratio, thickness_ratio, half_EPD, blockers=True, blocker_thickness_ratio=1.0/1000, light_confinement=False, focal_length=1.0, lens_system_name=None):\\n # Get the list of lens meshes from the appropriate lens system as well as the lens material'''\\n scale_rad = rad*diameter_ratio #max_radius->rad of the lens assembly\\n lenses = lenssystem.get_lens_mesh_list(lens_system_name, scale_rad)\\n lensmat = lenssystem.get_lens_material(lens_system_name)\\n face = None\\n for lns in lenses:\\n #lns = mh.rotate(lns,make_rotation_matrix(ph,ax))\\n if not face:\\n face = Solid(lns, lensmat, kabamland.detector_material)\\n else:\\n face += Solid(lns, lensmat, kabamland.detector_material)\\n\\n if light_confinement:\\n shield = mh.rotate(cylindrical_shell(rad*(1 - 0.001), rad, focal_length,32), make_rotation_matrix(np.pi/2.0, (1,0,0)))\\n baffle = Solid(shield, lensmat, kabamland.detector_material, black_surface, 0xff0000)\\n\\n if blockers:\\n blocker_thickness = 2*rad*blocker_thickness_ratio\\n if half_EPD < rad:\\n c1 = lenssystem.get_lens_sys(lens_system_name).c1*lenssystem.get_scale_factor(lens_system_name,scale_rad)\\n offset = [0,0,c1-np.sqrt(c1*c1-rad*rad)]\\n anulus_blocker = mh.shift(mh.rotate(cylindrical_shell(half_EPD, rad, blocker_thickness, 32), make_rotation_matrix(np.pi/2.0, (1,0,0))),offset)\\n face += Solid(anulus_blocker, lensmat, kabamland.detector_material, black_surface, 0xff0000)\\n phi, axs = rot_axis([0,0,1],vtx)\\n for vx,ph,ax in zip(vtx,-phi,axs):\\n kabamland.add_solid(face, rotation=make_rotation_matrix(ph,ax), displacement = -vx)\\n if light_confinement:\\n kabamland.add_solid(baffle, rotation=make_rotation_matrix(ph,ax), displacement = -normalize(vx)*(np.linalg.norm(vx)+focal_length/2.0))\",\n \"def flattener(image, pts, w, h):\\n temp_rect = np.zeros((4,2), dtype = \\\"float32\\\")\\n \\n s = np.sum(pts, axis = 2)\\n\\n tl = pts[np.argmin(s)]\\n br = pts[np.argmax(s)]\\n\\n diff = np.diff(pts, axis = -1)\\n tr = pts[np.argmin(diff)]\\n bl = pts[np.argmax(diff)]\\n\\n if w <= 0.8 * h: # If card is vertically oriented\\n temp_rect[0] = tl\\n temp_rect[1] = tr\\n temp_rect[2] = br\\n temp_rect[3] = bl\\n\\n if w >= 1.2 * h: # If card is horizontally oriented\\n temp_rect[0] = bl\\n temp_rect[1] = tl\\n temp_rect[2] = tr\\n temp_rect[3] = br\\n\\n if w > 0.8 * h and w < 1.2 * h: #If card is diamond oriented\\n # If furthest left point is higher than furthest right point,\\n # card is tilted to the left.\\n if pts[1][0][1] <= pts[3][0][1]:\\n # If card is titled to the left, approxPolyDP returns points\\n # in this order: top right, top left, bottom left, bottom right\\n temp_rect[0] = pts[1][0] # Top left\\n temp_rect[1] = pts[0][0] # Top right\\n temp_rect[2] = pts[3][0] # Bottom right\\n temp_rect[3] = pts[2][0] # Bottom left\\n\\n # If furthest left point is lower than furthest right point,\\n # card is tilted to the right\\n if pts[1][0][1] > pts[3][0][1]:\\n # If card is titled to the right, approxPolyDP returns points\\n # in this order: top left, bottom left, bottom right, top right\\n temp_rect[0] = pts[0][0] # Top left\\n temp_rect[1] = pts[3][0] # Top right\\n temp_rect[2] = pts[2][0] # Bottom right\\n temp_rect[3] = pts[1][0] # Bottom left\\n \\n # Create destination array, calculate perspective transform matrix,\\n # and warp card image\\n dst = np.array([[0, 0], [MAXWIDTH - 1, 0], [MAXWIDTH - 1, MAXHEIGHT - 1], [0, MAXHEIGHT - 1]], np.float32)\\n M = cv2.getPerspectiveTransform(temp_rect, dst)\\n warp = cv2.warpPerspective(image, M, (MAXWIDTH, MAXHEIGHT))\\n\\n return warp\",\n \"def is_ccw(points):\\n points = np.asanyarray(points, dtype=np.float64)\\n\\n if (len(points.shape) != 2 or\\n points.shape[1] != 2):\\n raise ValueError('CCW is only defined for 2D')\\n xd = np.diff(points[:, 0])\\n yd = np.column_stack((\\n points[:, 1],\\n points[:, 1])).reshape(-1)[1:-1].reshape((-1, 2)).sum(axis=1)\\n area = np.sum(xd * yd) * .5\\n ccw = area < 0\\n\\n return ccw\",\n \"def create_ring(self):\\n\\t\\tself.north_coords = numpy.add(self.center, self.north)\\n\\t\\tself.northeast_coords = numpy.add(self.center, self.northeast)\\n\\t\\tself.east_coords = numpy.add(self.center, self.east)\\n\\t\\tself.southeast_coords = numpy.add(self.center, self.southeast)\\n\\t\\tself.south_coords = numpy.add(self.center, self.south)\\n\\t\\tself.southwest_coords = numpy.add(self.center, self.southwest)\\n\\t\\tself.west_coords = numpy.add(self.center, self.west)\\n\\t\\tself.northwest_coords = numpy.add(self.center, self.northwest)\",\n \"def isValidPcbShape(g):\\n return g.GetShape() != pcbnew.S_SEGMENT or g.GetLength() > 0\",\n \"def draw_arc_filled(center_x, center_y,\\n width, height,\\n color,\\n start_angle, end_angle,\\n tilt_angle=0):\\n num_segments = 128\\n GL.glEnable(GL.GL_BLEND)\\n GL.glBlendFunc(GL.GL_SRC_ALPHA, GL.GL_ONE_MINUS_SRC_ALPHA)\\n GL.glEnable(GL.GL_LINE_SMOOTH)\\n GL.glHint(GL.GL_LINE_SMOOTH_HINT, GL.GL_NICEST)\\n GL.glHint(GL.GL_POLYGON_SMOOTH_HINT, GL.GL_NICEST)\\n\\n GL.glLoadIdentity()\\n GL.glTranslatef(center_x, center_y, 0)\\n GL.glRotatef(tilt_angle, 0, 0, 1)\\n\\n # Set color\\n if len(color) == 4:\\n GL.glColor4ub(color[0], color[1], color[2], color[3])\\n elif len(color) == 3:\\n GL.glColor4ub(color[0], color[1], color[2], 255)\\n\\n GL.glBegin(GL.GL_TRIANGLE_FAN)\\n\\n start_segment = int(start_angle / 360 * num_segments)\\n end_segment = int(end_angle / 360 * num_segments)\\n GL.glVertex3f(0, 0, 0.5)\\n\\n for segment in range(start_segment, end_segment + 1):\\n theta = 2.0 * 3.1415926 * segment / num_segments\\n\\n x = width * math.cos(theta)\\n y = height * math.sin(theta)\\n\\n GL.glVertex3f(x, y, 0.5)\\n\\n GL.glEnd()\\n GL.glLoadIdentity()\",\n \"def concave_hull(hull:list, points:list, max_iterations:int=None, min_length_fraction:float=0, min_angle:float=90)->list:\\n tweet.info(\\\"Creating concave hull; minimum side length {}% of average, minimum_angle {}\\\".format(min_length_fraction * 100, min_angle))\\n test_points = set(points)\\n ignore_points = []\\n avg_sqr_distance = 0\\n for k in range(0, len(hull)-1):\\n avg_sqr_distance += point_sqr_distance(hull[k], hull[k+1])\\n test_points.remove(hull[k])\\n avg_sqr_distance /= len(hull) - 1\\n min_sqr_length = avg_sqr_distance * (min_length_fraction ** 2) # since we get sqr_length, we square the fraction\\n min_cosine = math.cos(math.radians(min_angle))\\n \\n while (max_iterations is None or max_iterations > 0) and test_points:\\n selection, edge = select_longest_edge(hull, ignore_points, min_sqr_length)\\n tweet.info(\\\"Considering edge {}; {} points left\\\".format(edge, len(test_points)))\\n if selection is None:\\n break\\n selected_point = select_candidate_point(edge, test_points, hull, min_cosine)\\n if selected_point is None:\\n # This edge has no more candidate points, so we ignore it in the next pass\\n ignore_points.append(edge[0])\\n tweet.debug(\\\"No candidate point found.\\\")\\n continue\\n tweet.debug(\\\"Found point {}, inserting new edge.\\\".format(selected_point))\\n if not max_iterations is None:\\n max_iterations -= 1\\n # We add the point into the concave hull\\n hull.insert(selection + 1, selected_point)\\n test_points.remove(selected_point)\\n return hull\",\n \"def draw_boundary() -> None:\\n # Upper edge\\n print(rpipes.terminal.move_xy(0, 0), WBorder.HORIZONTAL * (rpipes.terminal.width - 1))\\n\\n # Left and Right edges\\n for row in range(rpipes.terminal.height - 2):\\n print(\\n WBorder.VERTICAL,\\n rpipes.terminal.move_right(rpipes.terminal.width - 4),\\n WBorder.VERTICAL,\\n )\\n\\n # Bottom edge\\n print(\\n rpipes.terminal.move_xy(0, rpipes.terminal.height - 2),\\n WBorder.HORIZONTAL * (rpipes.terminal.width - 1),\\n )\\n\\n # Top left corner\\n print(rpipes.terminal.move_xy(0, 0) + WBorder.DOWN_AND_RIGHT)\\n\\n # Top right corner\\n print(rpipes.terminal.move_xy(rpipes.terminal.width - 1, 0) + WBorder.DOWN_AND_LEFT)\\n\\n # Bottom left corner\\n print(rpipes.terminal.move_xy(0, rpipes.terminal.height - 2) + WBorder.UP_AND_RIGHT)\\n\\n # Bottom right corner\\n print(\\n rpipes.terminal.move_xy(rpipes.terminal.width - 1, rpipes.terminal.height - 2)\\n + WBorder.UP_AND_LEFT\\n )\",\n \"def make_path(self, loop):\\n path=Path(closed=True)\\n for c in range(0,len(loop)):\\n connection=loop[c]\\n nextConnection = loop[(c+1)%len(loop)]\\n lastConnection = loop[(c-1)%len(loop)]\\n if self.dontFill(connection, nextConnection, lastConnection):\\n return False\\n cp = self.corner_pos(connection, nextConnection, lastConnection)\\n corner_offset = cp[0]\\n corner_dir = cp[1]\\n # catch case when it is the end of a single rod\\n if type(corner_offset) is list:\\n endpoints = corner_offset\\n corner_offset = endpoints[0]\\n else:\\n endpoints = False\\n if connection.other.radius is not None and ( corner_offset.length() < connection.other.radius or corner_dir >0):\\n # catch case when it is the end of a single rod\\n if endpoints:\\n para=(connection.this.pos-connection.other.pos).normalize()\\n d = math.sqrt(connection.other.radius**2 - corner_offset.length()**2)\\n path.add_point(PSharp(connection.other.pos + corner_offset + d*para))\\n path.add_point(PArc(connection.other.pos, radius=connection.other.radius, direction='cw'))\\n path.add_point(PSharp(connection.other.pos - corner_offset+d*para))\\n else:\\n path.add_point(PAroundcurve(connection.other.pos + corner_offset, centre=connection.other.pos, radius=connection.other.radius, direction='cw'))\\n\\n elif self.get_intRadius(connection, connection.other) is not None:\\n # path.add_point(PIncurve(connection.other.pos + corner_offset, radius=self.get_intRadius(connection, connection.other)))\\n # path.add_point(PIncurve(connection.other.pos - corner_offset, radius=self.get_intRadius(connection, connection.other)))\\n # path.add_point(PIncurve(connection.other.pos - corner_offset, radius=self.get_intRadius(connection, connection.other)))\\n path.add_point(PIncurve(connection.other.pos + corner_offset, radius=self.get_intRadius(connection, connection.other)))\\n else:\\n cornerpos = self.corner_pos(connection, nextConnection, lastConnection)\\n if type(cornerpos) is list:\\n path.add_point(PSharp(connection.other.pos + cornerpos[0]))\\n path.add_point(PSharp(connection.other.pos + cornerpos[1]))\\n else:\\n path.add_point(PSharp(connection.other.pos + cornerpos))#self.corner_pos(connection, nextConnection, lastConnection)))\\n # path.add_point(PSharp(connection.other.pos - cornerpos))#self.corner_pos(connection, nextConnection, lastConnection)))\\n if connection.other.holeRad is not None:\\n if type(connection.other.holeRad) is int or type(connection.other.holeRad) is float:\\n self.otherpaths.append(Circle(connection.other.pos, rad=connection.other.holeRad, side='in'))\\n else:\\n t=copy.deepcopy(connection.other.holeRad)\\n t.translate(connection.other.pos)\\n self.otherpaths.append(t)\\n return path\",\n \"def toShapely(ring, geometryList):\\n outline = []\\n for idxA, idxB in zip(ring, ring[1:] + ring[:1]):\\n shape = geometryList[idxA].GetShape()\\n if shape in [STROKE_T.S_ARC, STROKE_T.S_CIRCLE]:\\n outline += approximateArc(geometryList[idxA],\\n commonEndPoint(geometryList[idxA], geometryList[idxB]))\\n elif shape in [STROKE_T.S_CURVE]:\\n outline += approximateBezier(geometryList[idxA],\\n commonEndPoint(geometryList[idxA], geometryList[idxB]))\\n elif shape in [STROKE_T.S_RECT]:\\n assert idxA == idxB\\n outline += geometryList[idxA].GetRectCorners()\\n elif shape in [STROKE_T.S_POLYGON]:\\n # Polygons are always closed, so they should appear as stand-alone\\n assert len(ring) in [1, 2]\\n return shapePolyToShapely(geometryList[idxA].GetPolyShape())\\n elif shape in [STROKE_T.S_SEGMENT]:\\n outline.append(commonEndPoint(geometryList[idxA], geometryList[idxB]))\\n else:\\n raise RuntimeError(f\\\"Unsupported shape {shape} in outline\\\")\\n return Polygon(outline)\",\n \"def check_boundary(self,x):\\n b_cells = np.zeros(self.n_c)\\n b_cells[self.n_C:] = 1\\n vBC = b_cells[self.tris]\\n considered_triangles = vBC.sum(axis=1) == 2\\n add_extra = ((self.Angles*(1-vBC)>np.pi/2).T*considered_triangles.T).T\\n if add_extra.any():\\n I,J = np.nonzero(add_extra)\\n for k,i in enumerate(I):\\n j = J[k]\\n xs = x[self.tris[i]]\\n re = xs[np.mod(j-1,3)] - xs[np.mod(j+1,3)]\\n re = re/np.linalg.norm(re)\\n re = np.array([re[1],-re[0]])\\n rpe = xs[j]\\n x_new = 2*np.dot(xs[np.mod(j-1,3)]-rpe,re)*re + rpe\\n x = np.vstack((x,x_new))\\n self.n_c = x.shape[0]\\n self._triangulate(x)\\n self.assign_vertices()\\n\\n C = get_C_boundary(self.n_c,self.CV_matrix)\\n #\\n # #Remove extra cells\\n # keep_mask = C[self.n_C:, :self.n_C].sum(axis=1)>0 #I'm assuming this is the same thing. This removes all boundary centroids that are not connected to at least one real centroid.\\n # if keep_mask.any():\\n # c_keep = np.nonzero(keep_mask)[0]\\n # x = np.concatenate((x[:self.n_C],x[c_keep + self.n_C]))\\n # self.n_c = x.shape[0]\\n # self._triangulate(x)\\n # self.assign_vertices()\\n #\\n\\n #Remove all boundary particles not connected to exactly two other boundary particles\\n remove_mask = C[self.n_C:, self.n_C:].sum(axis=1)!=2\\n if remove_mask.any():\\n c_keep = np.nonzero(~remove_mask)[0]\\n x = np.concatenate((x[:self.n_C],x[c_keep + self.n_C]))\\n self.n_c = x.shape[0]\\n self._triangulate(x)\\n self.assign_vertices()\\n self.Angles = tri_angles(x, self.tris)\\n #\\n # remove_mask = C[self.n_C:, self.n_C:].sum(axis=1)==0\\n # if remove_mask.any():\\n # c_keep = np.nonzero(~remove_mask)[0]\\n # x = np.concatenate((x[:self.n_C],x[c_keep + self.n_C]))\\n # self.n_c = x.shape[0]\\n # self._triangulate(x)\\n # self.assign_vertices()\\n # self.Angles = tri_angles(x, self.tris)\\n\\n\\n return x\",\n \"def _proc_polygon(self, tokens, filled):\\n\\n pts = [(p[\\\"x\\\"], p[\\\"y\\\"]) for p in tokens[\\\"points\\\"]]\\n component = Polygon(pen=self.pen, points=pts, filled=filled)\\n\\n return component\",\n \"def Cool_per_Grain(grain_size, grain_type, ZZ, fdist, ntot, xe, temp):\\n import numpy as np\\n import math\\n import compute_charge_dist as fz\\n \\n tau = grain_size * fz.AAtocm * fz.kb * temp / fz.echarge**2\\n \\n # Loop over species!\\n Cool_spec = 0\\n for partner in [\\\"electron\\\", \\\"hydrogen\\\", \\\"carbon\\\"]:\\n \\n Cool_Zall = 0\\n # Loop over charge\\n for zi in range(len(ZZ)):\\n \\n if partner == \\\"electron\\\":\\n nu = -1*ZZ[zi]\\n stick_coef = fz.get_stickCoef(ZZ[zi], grain_size, grain_type)\\n charge_frac = xe\\n mass = fz.me\\n \\n elif partner == \\\"hydrogen\\\":\\n nu = ZZ[zi]\\n stick_coef = 1.0\\n charge_frac = xe\\n mass = fz.mH\\n \\n elif partner == \\\"carbon\\\":\\n nu = ZZ[zi]\\n stick_coef = 1.0\\n # Maximum fraction of ionized Carbon is 1e-4*ntot.\\n charge_frac = min(1.0e-4, xe)\\n mass = fz.mC\\n \\n Cooltilde = 1.0\\n \\n if nu < 0:\\n Cooltilde = fz.Jtilde_neg(tau, nu)\\n elif nu == 0:\\n Cooltilde = fz.Jtilde_0(tau, nu)\\n else:\\n Cooltilde = fz.Jtilde_pos(tau, nu)\\n \\n #print(zi)\\n Cool_Zhere = fdist[zi]*Cooltilde*fz.kb*temp\\n Cool_Zall += Cool_Zhere\\n \\n #print(\\\"Collisional Partner = \\\", partner)\\n Cool_spec += ntot*charge_frac*stick_coef*np.sqrt(8.0*fz.kb*temp/(np.pi*mass))*Cool_Zall\\n \\n Cool_tot = math.pi * (grain_size*AAtocm)**2 * Cool_spec\\n \\n return Cool_tot\",\n \"def roof_cc(lenght, width, overhang=1, wall_height=3, roof_height=4):\\n a = min(0.1 * lenght, 0.1 * width, 0.4 * (wall_height + 0.5 * roof_height))\\n\\n area = (lenght + overhang)*(width + overhang)\\n area_3 = 8*a**2\\n area_1 = (lenght - 2)*(width - 4*a)\\n area_2 = area - area_3 - area_1\\n return area, area_1, area_2, area_3\",\n \"def create_rink():\\n\\n # RINK\\n coords = OFFSET, OFFSET, OFFSET+22*SCALE, OFFSET+22*SCALE\\n canvas.create_arc(coords, start=90, extent=90, fill=WHITE, outline=\\\"\\\")\\n coords = OFFSET, HEIGHT-OFFSET-22*SCALE, OFFSET+22*SCALE, HEIGHT-OFFSET\\n canvas.create_arc(coords, start=180, extent=90, fill=WHITE, outline=WHITE)\\n coords = WIDTH-OFFSET-22*SCALE, HEIGHT-OFFSET-22*SCALE, WIDTH-OFFSET, HEIGHT-OFFSET\\n canvas.create_arc(coords, start=270, extent=90, fill=WHITE, outline=WHITE)\\n coords = WIDTH-OFFSET-22*SCALE, OFFSET, WIDTH-OFFSET, OFFSET+22*SCALE\\n canvas.create_arc(coords, start=0, extent=90, fill=WHITE, outline=WHITE)\\n coords = OFFSET+11*SCALE, OFFSET, WIDTH-OFFSET-11*SCALE, OFFSET, WIDTH-OFFSET-11*SCALE, HEIGHT-OFFSET, OFFSET+11*SCALE, HEIGHT-OFFSET\\n canvas.create_polygon(coords, fill=WHITE, outline=WHITE)\\n coords = OFFSET, OFFSET+11*SCALE, WIDTH-OFFSET, OFFSET+11*SCALE, WIDTH-OFFSET, HEIGHT-OFFSET-11*SCALE, OFFSET, HEIGHT-OFFSET-11*SCALE\\n canvas.create_polygon(coords, fill=WHITE, outline=WHITE)\\n\\n # CENTER CIRCLE\\n coords = WIDTH/2-15*SCALE, HEIGHT/2-15*SCALE, WIDTH/2+15*SCALE, HEIGHT/2+15*SCALE\\n canvas.create_oval(coords, outline=BLUE, width=2, fill=WHITE)\\n\\n # HALF CENTER CIRCLE\\n coords = WIDTH/2-10*SCALE, HEIGHT-OFFSET-10*SCALE, WIDTH/2+10*SCALE, HEIGHT-OFFSET+10*SCALE\\n canvas.create_arc(coords, outline=RED, width=2, start=0, extent=180)\\n\\n # GOAL AREA\\n # - Left\\n # - - Crease\\n coords = OFFSET+5*SCALE, HEIGHT/2-6*SCALE, OFFSET+17*SCALE, HEIGHT/2+6*SCALE\\n canvas.create_arc(coords, fill=LIGHT_BLUE, start=318, extent=84, outline=\\\"\\\")\\n canvas.create_arc(coords, outline=RED, start=318, extent=84, style=ARC)\\n coords = OFFSET+11*SCALE, HEIGHT/2-4*SCALE, OFFSET+15.5*SCALE, HEIGHT/2-4*SCALE, OFFSET+15.5*SCALE, HEIGHT/2+4*SCALE, OFFSET+11*SCALE, HEIGHT/2+4*SCALE\\n canvas.create_polygon(coords, fill=LIGHT_BLUE, outline=\\\"\\\")\\n coords = OFFSET+11*SCALE, HEIGHT/2-4*SCALE, OFFSET+15.2*SCALE+1, HEIGHT/2-4*SCALE\\n canvas.create_line(coords, fill=RED)\\n coords = OFFSET+15.2*SCALE+1, HEIGHT/2+4*SCALE, OFFSET+11*SCALE, HEIGHT/2+4*SCALE\\n canvas.create_line(coords, fill=RED)\\n # - - Restricted Area\\n coords = OFFSET, HEIGHT/2-14*SCALE, OFFSET+11*SCALE, HEIGHT/2-9*SCALE\\n canvas.create_line(coords, fill=RED)\\n coords = OFFSET, HEIGHT/2+14*SCALE, OFFSET+11*SCALE, HEIGHT/2+9*SCALE\\n canvas.create_line(coords, fill=RED)\\n # - - Goal\\n coords = OFFSET+8*SCALE, HEIGHT/2-3*SCALE, OFFSET+11*SCALE, HEIGHT/2-3*SCALE, OFFSET+11*SCALE, HEIGHT/2+3*SCALE, OFFSET+8*SCALE, HEIGHT/2+3*SCALE\\n canvas.create_polygon(coords, fill=GRAY, outline=RED)\\n # - Right\\n # - - Crease\\n coords = WIDTH-(OFFSET+5*SCALE), HEIGHT/2-6*SCALE, WIDTH-(OFFSET+17*SCALE), HEIGHT/2+6*SCALE\\n canvas.create_arc(coords, fill=LIGHT_BLUE, start=138, extent=84, outline=\\\"\\\")\\n canvas.create_arc(coords, outline=RED, start=138, extent=84, style=ARC)\\n coords = WIDTH-(OFFSET+11*SCALE), HEIGHT/2-4*SCALE, WIDTH-(OFFSET+15.5*SCALE), HEIGHT/2-4*SCALE, WIDTH-(OFFSET+15.5*SCALE), HEIGHT/2+4*SCALE, WIDTH-(OFFSET+11*SCALE), HEIGHT/2+4*SCALE\\n canvas.create_polygon(coords, fill=LIGHT_BLUE, outline=\\\"\\\")\\n coords = WIDTH-(OFFSET+11*SCALE), HEIGHT/2-4*SCALE, WIDTH-(OFFSET+15.2*SCALE+1), HEIGHT/2-4*SCALE\\n canvas.create_line(coords, fill=RED)\\n coords = WIDTH-(OFFSET+15.2*SCALE+1), HEIGHT/2+4*SCALE, WIDTH-(OFFSET+11*SCALE), HEIGHT/2+4*SCALE\\n canvas.create_line(coords, fill=RED)\\n # - - Restricted Area\\n coords = WIDTH-OFFSET, HEIGHT/2-14*SCALE, WIDTH-OFFSET-11*SCALE, HEIGHT/2-9*SCALE\\n canvas.create_line(coords, fill=RED)\\n coords = WIDTH-OFFSET, HEIGHT/2+14*SCALE, WIDTH-OFFSET-11*SCALE, HEIGHT/2+9*SCALE\\n canvas.create_line(coords, fill=RED)\\n # - - Goal\\n coords = WIDTH-(OFFSET+8*SCALE), HEIGHT/2-3*SCALE, WIDTH-(OFFSET+11*SCALE), HEIGHT/2-3*SCALE, WIDTH-(OFFSET+11*SCALE), HEIGHT/2+3*SCALE, WIDTH-(OFFSET+8*SCALE), HEIGHT/2+3*SCALE\\n canvas.create_polygon(coords, fill=GRAY, outline=RED)\\n\\n # LINES\\n # - Left Baseline\\n coords = OFFSET+11*SCALE, OFFSET, OFFSET+11*SCALE, HEIGHT-OFFSET\\n canvas.create_line(coords, fill=RED, width=1.5)\\n # - Right Baseline\\n coords = WIDTH-OFFSET-11*SCALE, OFFSET, WIDTH-OFFSET-11*SCALE, HEIGHT-OFFSET\\n canvas.create_line(coords, fill=RED, width=1.5)\\n # - Left Blueline\\n coords = OFFSET+70*SCALE, OFFSET, OFFSET+70*SCALE, HEIGHT-OFFSET\\n canvas.create_line(coords, fill=BLUE, width=7)\\n # - Right Blueline\\n coords = WIDTH-(OFFSET+70*SCALE), OFFSET, WIDTH-(OFFSET+70*SCALE), HEIGHT-OFFSET\\n canvas.create_line(coords, fill=BLUE, width=7)\\n # - Redline\\n coords = WIDTH/2, OFFSET, WIDTH/2, HEIGHT-OFFSET\\n canvas.create_line(coords, fill=RED, width=7)\\n coords = WIDTH/2, OFFSET, WIDTH/2, HEIGHT-OFFSET\\n canvas.create_line(coords, fill=WHITE, width=5, dash=(9,9))\\n\\n # RINK OUTLINE\\n coords = OFFSET, OFFSET, OFFSET+22*SCALE, OFFSET+22*SCALE\\n canvas.create_arc(coords, start=90, extent=90, outline=BLACK, style=ARC, width=2)\\n coords = OFFSET, HEIGHT-OFFSET-22*SCALE, OFFSET+22*SCALE, HEIGHT-OFFSET\\n canvas.create_arc(coords, start=180, extent=90, outline=BLACK, style=ARC, width=2)\\n coords = WIDTH-OFFSET-22*SCALE, HEIGHT-OFFSET-22*SCALE, WIDTH-OFFSET, HEIGHT-OFFSET\\n canvas.create_arc(coords, start=270, extent=90, outline=BLACK, style=ARC, width=2)\\n coords = WIDTH-OFFSET-22*SCALE, OFFSET, WIDTH-OFFSET, OFFSET+22*SCALE\\n canvas.create_arc(coords, start=0, extent=90, outline=BLACK, style=ARC, width=2)\\n coords = OFFSET+11*SCALE, OFFSET, WIDTH-OFFSET-11*SCALE, OFFSET\\n canvas.create_line(coords, fill=BLACK, width=2)\\n coords = WIDTH-OFFSET, OFFSET+11*SCALE, WIDTH-OFFSET, HEIGHT-OFFSET-11*SCALE\\n canvas.create_line(coords, fill=BLACK, width=2)\\n coords = WIDTH-OFFSET-11*SCALE, HEIGHT-OFFSET, OFFSET+11*SCALE, HEIGHT-OFFSET\\n canvas.create_line(coords, fill=BLACK, width=2)\\n coords = OFFSET, OFFSET+11*SCALE, OFFSET, HEIGHT-OFFSET-11*SCALE\\n canvas.create_line(coords, fill=BLACK, width=2)\\n\\n\\n # CENTER DOT\\n coords = WIDTH/2-1*SCALE-1, HEIGHT/2-1*SCALE-1, WIDTH/2+1*SCALE+1, HEIGHT/2+1*SCALE+1\\n canvas.create_oval(coords, outline=WHITE, fill=BLUE)\\n\\n # FACEOFF\\n # - Top Left\\n # - - Ticks\\n coords = OFFSET+29.5*SCALE, HEIGHT/2-39*SCALE, OFFSET+29.5*SCALE, HEIGHT/2-5*SCALE\\n canvas.create_line(coords, fill=RED, width=2)\\n coords = OFFSET+32.5*SCALE, HEIGHT/2-39*SCALE, OFFSET+32.5*SCALE, HEIGHT/2-5*SCALE\\n canvas.create_line(coords, fill=RED, width=2)\\n # - - Circles\\n coords = OFFSET+16*SCALE, HEIGHT/2-37*SCALE, OFFSET+46*SCALE, HEIGHT/2-7*SCALE\\n canvas.create_oval(coords, outline=RED, width=2, fill=WHITE)\\n coords = OFFSET+30*SCALE, HEIGHT/2-23*SCALE, OFFSET+32*SCALE, HEIGHT/2-21*SCALE\\n canvas.create_oval(coords, fill=RED, outline=\\\"\\\")\\n # - - Cross\\n coords = OFFSET+25*SCALE, HEIGHT/2-22.8*SCALE, OFFSET+29*SCALE, HEIGHT/2-22.8*SCALE, OFFSET+29*SCALE, HEIGHT/2-25.8*SCALE\\n canvas.create_line(coords, fill=RED, width=2)\\n coords = OFFSET+25*SCALE, HEIGHT/2-21.2*SCALE, OFFSET+29*SCALE, HEIGHT/2-21.2*SCALE, OFFSET+29*SCALE, HEIGHT/2-18.2*SCALE\\n canvas.create_line(coords, fill=RED, width=2)\\n coords = OFFSET+37*SCALE, HEIGHT/2-22.8*SCALE, OFFSET+33*SCALE, HEIGHT/2-22.8*SCALE, OFFSET+33*SCALE, HEIGHT/2-25.8*SCALE\\n canvas.create_line(coords, fill=RED, width=2)\\n coords = OFFSET+37*SCALE, HEIGHT/2-21.2*SCALE, OFFSET+33*SCALE, HEIGHT/2-21.2*SCALE, OFFSET+33*SCALE, HEIGHT/2-18.2*SCALE\\n canvas.create_line(coords, fill=RED, width=2)\\n # - Bottom Left\\n # - - Ticks\\n coords = OFFSET+29.5*SCALE, HEIGHT/2+39*SCALE, OFFSET+29.5*SCALE, HEIGHT/2+5*SCALE\\n canvas.create_line(coords, fill=RED, width=2)\\n coords = OFFSET+32.5*SCALE, HEIGHT/2+39*SCALE, OFFSET+32.5*SCALE, HEIGHT/2+5*SCALE\\n canvas.create_line(coords, fill=RED, width=2)\\n # - - Circles\\n coords = OFFSET+16*SCALE, HEIGHT/2+37*SCALE, OFFSET+46*SCALE, HEIGHT/2+7*SCALE\\n canvas.create_oval(coords, outline=RED, width=2, fill=WHITE)\\n coords = OFFSET+30*SCALE, HEIGHT/2+23*SCALE, OFFSET+32*SCALE, HEIGHT/2+21*SCALE\\n canvas.create_oval(coords, fill=RED, outline=\\\"\\\")\\n # - - Cross\\n coords = OFFSET+25*SCALE, HEIGHT/2+22.8*SCALE, OFFSET+29*SCALE, HEIGHT/2+22.8*SCALE, OFFSET+29*SCALE, HEIGHT/2+25.8*SCALE\\n canvas.create_line(coords, fill=RED, width=2)\\n coords = OFFSET+25*SCALE, HEIGHT/2+21.2*SCALE, OFFSET+29*SCALE, HEIGHT/2+21.2*SCALE, OFFSET+29*SCALE, HEIGHT/2+18.2*SCALE\\n canvas.create_line(coords, fill=RED, width=2)\\n coords = OFFSET+37*SCALE, HEIGHT/2+22.8*SCALE, OFFSET+33*SCALE, HEIGHT/2+22.8*SCALE, OFFSET+33*SCALE, HEIGHT/2+25.8*SCALE\\n canvas.create_line(coords, fill=RED, width=2)\\n coords = OFFSET+37*SCALE, HEIGHT/2+21.2*SCALE, OFFSET+33*SCALE, HEIGHT/2+21.2*SCALE, OFFSET+33*SCALE, HEIGHT/2+18.2*SCALE\\n canvas.create_line(coords, fill=RED, width=2)\\n # - Top Right\\n # - - Ticks\\n coords = WIDTH-(OFFSET+29.5*SCALE), HEIGHT/2-39*SCALE, WIDTH-(OFFSET+29.5*SCALE), HEIGHT/2-5*SCALE\\n canvas.create_line(coords, fill=RED, width=2)\\n coords = WIDTH-(OFFSET+32.5*SCALE), HEIGHT/2-39*SCALE, WIDTH-(OFFSET+32.5*SCALE), HEIGHT/2-5*SCALE\\n canvas.create_line(coords, fill=RED, width=2)\\n # - - Circles\\n coords = WIDTH-(OFFSET+16*SCALE), HEIGHT/2-37*SCALE, WIDTH-(OFFSET+46*SCALE), HEIGHT/2-7*SCALE\\n canvas.create_oval(coords, outline=RED, width=2, fill=WHITE)\\n coords = WIDTH-(OFFSET+30*SCALE), HEIGHT/2-23*SCALE, WIDTH-(OFFSET+32*SCALE), HEIGHT/2-21*SCALE\\n canvas.create_oval(coords, fill=RED, outline=\\\"\\\")\\n # - - Cross\\n coords = WIDTH-(OFFSET+25*SCALE), HEIGHT/2-22.8*SCALE, WIDTH-(OFFSET+29*SCALE), HEIGHT/2-22.8*SCALE, WIDTH-(OFFSET+29*SCALE), HEIGHT/2-25.8*SCALE\\n canvas.create_line(coords, fill=RED, width=2)\\n coords = WIDTH-(OFFSET+25*SCALE), HEIGHT/2-21.2*SCALE, WIDTH-(OFFSET+29*SCALE), HEIGHT/2-21.2*SCALE, WIDTH-(OFFSET+29*SCALE), HEIGHT/2-18.2*SCALE\\n canvas.create_line(coords, fill=RED, width=2)\\n coords = WIDTH-(OFFSET+37*SCALE), HEIGHT/2-22.8*SCALE, WIDTH-(OFFSET+33*SCALE), HEIGHT/2-22.8*SCALE, WIDTH-(OFFSET+33*SCALE), HEIGHT/2-25.8*SCALE\\n canvas.create_line(coords, fill=RED, width=2)\\n coords = WIDTH-(OFFSET+37*SCALE), HEIGHT/2-21.2*SCALE, WIDTH-(OFFSET+33*SCALE), HEIGHT/2-21.2*SCALE, WIDTH-(OFFSET+33*SCALE), HEIGHT/2-18.2*SCALE\\n canvas.create_line(coords, fill=RED, width=2)\\n # - Bottom Right\\n # - - Ticks\\n coords = WIDTH-(OFFSET+29.5*SCALE), HEIGHT/2+39*SCALE, WIDTH-(OFFSET+29.5*SCALE), HEIGHT/2+5*SCALE\\n canvas.create_line(coords, fill=RED, width=2)\\n coords = WIDTH-(OFFSET+32.5*SCALE), HEIGHT/2+39*SCALE, WIDTH-(OFFSET+32.5*SCALE), HEIGHT/2+5*SCALE\\n canvas.create_line(coords, fill=RED, width=2)\\n # - - Circles\\n coords = WIDTH-(OFFSET+16*SCALE), HEIGHT/2+37*SCALE, WIDTH-(OFFSET+46*SCALE), HEIGHT/2+7*SCALE\\n canvas.create_oval(coords, outline=RED, width=2, fill=WHITE)\\n coords = WIDTH-(OFFSET+30*SCALE), HEIGHT/2+23*SCALE, WIDTH-(OFFSET+32*SCALE), HEIGHT/2+21*SCALE\\n canvas.create_oval(coords, fill=RED, outline=\\\"\\\")\\n # - - Cross\\n coords = WIDTH-(OFFSET+25*SCALE), HEIGHT/2+22.8*SCALE, WIDTH-(OFFSET+29*SCALE), HEIGHT/2+22.8*SCALE, WIDTH-(OFFSET+29*SCALE), HEIGHT/2+25.8*SCALE\\n canvas.create_line(coords, fill=RED, width=2)\\n coords = WIDTH-(OFFSET+25*SCALE), HEIGHT/2+21.2*SCALE, WIDTH-(OFFSET+29*SCALE), HEIGHT/2+21.2*SCALE, WIDTH-(OFFSET+29*SCALE), HEIGHT/2+18.2*SCALE\\n canvas.create_line(coords, fill=RED, width=2)\\n coords = WIDTH-(OFFSET+37*SCALE), HEIGHT/2+22.8*SCALE, WIDTH-(OFFSET+33*SCALE), HEIGHT/2+22.8*SCALE, WIDTH-(OFFSET+33*SCALE), HEIGHT/2+25.8*SCALE\\n canvas.create_line(coords, fill=RED, width=2)\\n coords = WIDTH-(OFFSET+37*SCALE), HEIGHT/2+21.2*SCALE, WIDTH-(OFFSET+33*SCALE), HEIGHT/2+21.2*SCALE, WIDTH-(OFFSET+33*SCALE), HEIGHT/2+18.2*SCALE\\n canvas.create_line(coords, fill=RED, width=2)\\n\\n # NEUTRAL ZONE FACEOFF\\n # - Top Left\\n coords = WIDTH/2-21*SCALE, HEIGHT/2-23*SCALE, WIDTH/2-19*SCALE, HEIGHT/2-21*SCALE\\n canvas.create_oval(coords, outline=\\\"\\\", fill=RED)\\n # - Bottom Left\\n coords = WIDTH/2-21*SCALE, HEIGHT/2+23*SCALE, WIDTH/2-19*SCALE, HEIGHT/2+21*SCALE\\n canvas.create_oval(coords, outline=\\\"\\\", fill=RED)\\n # - Top Right\\n coords = WIDTH/2+21*SCALE, HEIGHT/2-23*SCALE, WIDTH/2+19*SCALE, HEIGHT/2-21*SCALE\\n canvas.create_oval(coords, outline=\\\"\\\", fill=RED)\\n # - Bottom Right\\n coords = WIDTH/2+21*SCALE, HEIGHT/2+23*SCALE, WIDTH/2+19*SCALE, HEIGHT/2+21*SCALE\\n canvas.create_oval(coords, outline=\\\"\\\", fill=RED)\\n\\n\\n canvas.grid(row=1, columnspan=5)\",\n \"def ring(radius = 10, width = 0.5, angle_resolution = 2.5, layer = 0):\\n D = Device(name = 'ring')\\n inner_radius = radius - width/2\\n outer_radius = radius + width/2\\n n = int(np.round(360/angle_resolution))\\n t = np.linspace(0, 360, n+1) * pi/180\\n inner_points_x = (inner_radius*cos(t)).tolist()\\n inner_points_y = (inner_radius*sin(t)).tolist()\\n outer_points_x = (outer_radius*cos(t)).tolist()\\n outer_points_y = (outer_radius*sin(t)).tolist()\\n xpts = inner_points_x + outer_points_x[::-1]\\n ypts = inner_points_y + outer_points_y[::-1]\\n D.add_polygon(points = (xpts, ypts), layer = layer)\\n return D\",\n \"def create_surface(self):\\n oval = graphics.Oval(graphics.Point(5,0), graphics.Point(300, -10))\\n oval.setFill(\\\"gray\\\")\\n return oval\",\n \"def test_random_polygon(self):\\n p = g.trimesh.path.polygons.random_polygon()\\n assert p.area > 0.0\\n assert p.is_valid\",\n \"def boundary_polygon(self, time):\\n ti = np.where(time == self.times)[0][0]\\n com_x, com_y = self.center_of_mass(time)\\n # If at least one point along perimeter of the mask rectangle is unmasked, find_boundaries() works.\\n # But if all perimeter points are masked, find_boundaries() does not find the object.\\n # Therefore, pad the mask with zeroes first and run find_boundaries on the padded array.\\n padded_mask = np.pad(self.masks[ti], 1, 'constant', constant_values=0)\\n chull = convex_hull_image(padded_mask)\\n boundary_image = find_boundaries(chull, mode='inner', background=0)\\n # Now remove the padding.\\n boundary_image = boundary_image[1:-1, 1:-1]\\n boundary_x = self.x[ti].ravel()[boundary_image.ravel()]\\n boundary_y = self.y[ti].ravel()[boundary_image.ravel()]\\n r = np.sqrt((boundary_x - com_x) ** 2 + (boundary_y - com_y) ** 2)\\n theta = np.arctan2((boundary_y - com_y), (boundary_x - com_x)) * 180.0 / np.pi + 360\\n polar_coords = np.array([(r[x], theta[x]) for x in range(r.size)], dtype=[('r', 'f4'), ('theta', 'f4')])\\n coord_order = np.argsort(polar_coords, order=['theta', 'r'])\\n ordered_coords = np.vstack([boundary_x[coord_order], boundary_y[coord_order]])\\n return ordered_coords\",\n \"def optimal_polygon(y, w=0.5, debug=False):\\n # Make sure that we use numpy array\\n y = np.array(y)\\n x = np.arange(len(y))\\n\\n # Initialization\\n y = np.round(y, 6)\\n p_plus = (x[0], y[0] + w)\\n l_plus = (x[0], y[0] + w)\\n r_plus = (x[1], y[1] + w)\\n s_plus = {(x[0], y[0] + w): (x[1], y[1] + w)}\\n t_plus = {(x[1], y[1] + w): (x[0], y[0] + w)}\\n p_minus = (x[0], y[0] - w)\\n l_minus = (x[0], y[0] - w)\\n r_minus = (x[1], y[1] - w)\\n s_minus = {(x[0], y[0] - w): (x[1], y[1] - w)}\\n t_minus = {(x[1], y[1] - w): (x[0], y[0] - w)}\\n q = []\\n i = 2\\n\\n while i < len(y):\\n # Updating CH_plus (convex hull) and CH_minus\\n p = (x[i - 1], y[i - 1] + w)\\n p_i_plus = (x[i], y[i] + w)\\n while (p != p_plus) and _angle(p_i_plus, p, t_plus[p], '+') > np.pi:\\n p = t_plus[p]\\n s_plus[p] = p_i_plus\\n t_plus[p_i_plus] = p\\n\\n p = (x[i - 1], y[i - 1] - w)\\n p_i_minus = (x[i], y[i] - w)\\n while (p != p_minus) and _angle(p_i_minus, p, t_minus[p], '-') > np.pi:\\n p = t_minus[p]\\n s_minus[p] = p_i_minus\\n t_minus[p_i_minus] = p\\n\\n # Check if CH_plus and CH_minus intersect\\n if _angle(p_i_plus, l_plus, r_minus, '+') < np.pi:\\n q.append((_intersect(l_plus, r_minus, p_plus, p_minus), l_plus, r_minus, p_plus, p_minus))\\n p_minus = r_minus\\n p_plus = _intersect(l_plus, r_minus, (x[i - 1], y[i - 1] + w), p_i_plus)\\n s_plus[p_plus] = p_i_plus\\n t_plus[p_i_plus] = p_plus\\n r_plus = p_i_plus\\n r_minus = p_i_minus\\n l_plus = p_plus\\n l_minus = p_minus\\n while _angle(l_minus, r_plus, s_minus[l_minus], '-') < np.pi:\\n l_minus = s_minus[l_minus]\\n elif _angle(p_i_minus, l_minus, r_plus, '-') < np.pi:\\n q.append((_intersect(l_minus, r_plus, p_minus, p_plus), l_minus, r_plus, p_minus, p_plus))\\n p_plus = r_plus\\n p_minus = _intersect(l_minus, r_plus, (x[i - 1], y[i - 1] - w), p_i_minus)\\n s_minus[p_minus] = p_i_minus\\n t_minus[p_i_minus] = p_minus\\n r_minus = p_i_minus\\n r_plus = p_i_plus\\n l_minus = p_minus\\n l_plus = p_plus\\n while _angle(l_plus, r_minus, s_plus[l_plus], '+') < np.pi:\\n l_plus = s_plus[l_plus]\\n else:\\n # Updating the two seperating and supporting lines\\n if _angle(p_i_plus, l_minus, r_plus, '+') < np.pi:\\n r_plus = p_i_plus\\n while _angle(p_i_plus, l_minus, s_minus[l_minus], '+') < np.pi:\\n l_minus = s_minus[l_minus]\\n\\n if _angle(p_i_minus, l_plus, r_minus, '-') < np.pi:\\n r_minus = p_i_minus\\n while _angle(p_i_minus, l_plus, s_plus[l_plus], '-') < np.pi:\\n l_plus = s_plus[l_plus]\\n i += 1\\n\\n # Add last change point\\n a = _intersect(l_plus, r_minus, p_plus, p_minus)\\n b = _intersect(l_minus, r_plus, p_minus, p_plus)\\n p = ((a[0] + b[0]) / 2, (a[1] + b[1]) / 2)\\n q.append((p, r_minus, r_plus, p_minus, p_plus))\\n\\n end_a = _intersect(p, r_plus, p_i_minus, p_i_plus)\\n end_b = _intersect(p, r_minus, p_i_minus, p_i_plus)\\n end = ((end_a[0] + end_b[0]) / 2, (end_a[1] + end_b[1]) / 2)\\n q.append((end, (None, None), (None, None), p_i_minus, p_i_plus))\\n\\n if debug:\\n return np.array(q)\\n else:\\n return np.array([o[0] for o in q])\",\n \"def validate_clockwise_points(points):\\n\\n if len(points) != 8:\\n raise Exception(\\\"Points list not valid.\\\" + str(len(points)))\\n\\n point = [\\n [int(points[0]), int(points[1])],\\n [int(points[2]), int(points[3])],\\n [int(points[4]), int(points[5])],\\n [int(points[6]), int(points[7])]\\n ]\\n edge = [\\n (point[1][0] - point[0][0]) * (point[1][1] + point[0][1]),\\n (point[2][0] - point[1][0]) * (point[2][1] + point[1][1]),\\n (point[3][0] - point[2][0]) * (point[3][1] + point[2][1]),\\n (point[0][0] - point[3][0]) * (point[0][1] + point[3][1])\\n ]\\n\\n summatory = edge[0] + edge[1] + edge[2] + edge[3];\\n if summatory > 0:\\n raise Exception(\\n \\\"Points are not clockwise. The coordinates of bounding quadrilaterals have to be given in clockwise order. Regarding the correct interpretation of 'clockwise' remember that the image coordinate system used is the standard one, with the image origin at the upper left, the X axis extending to the right and Y axis extending downwards.\\\")\",\n \"def test_str_solid_angle(self):\\n xknx = XKNX()\\n sensor = Sensor(\\n xknx, \\\"TestSensor\\\", group_address_state=\\\"1/2/3\\\", value_type=\\\"solid_angle\\\"\\n )\\n sensor.sensor_value.payload = DPTArray(\\n (\\n 0xC5,\\n 0xC6,\\n 0xE5,\\n 0x47,\\n )\\n )\\n\\n self.assertEqual(sensor.resolve_state(), -6364.65966796875)\\n self.assertEqual(sensor.unit_of_measurement(), \\\"sr\\\")\\n self.assertEqual(sensor.ha_device_class(), None)\",\n \"def unitQuad_Edge(lens, N=3):\\n template = [ np.array([0,0]), np.array([lens[0], 0]), None, None ] #Template from which to generate other Quad Vertex Lists\\n leftDegenerate = template.copy() #Left Limit of quad if you were to rotate edge 3 CCW about the origin until you no longer can\\n rightDegenerate = template.copy() #Right Limit of quad if you were to rotate edge 2 CW about point 1 until you no longer can,\\n # or alternatively, how far edge 3 can rotate CW until the quad is degenerate\\n try:\\n leftDegenerate[3] = np.array( circleIntersection(leftDegenerate[0], lens[3], leftDegenerate[1], lens[1]+lens[2]) )\\n leftDegenerate[2] = ( lens[1] / (lens[2]+lens[1]) ) * (leftDegenerate[3]-leftDegenerate[1]) + leftDegenerate[1]\\n except: \\n leftDegenerate[3] = np.array([-lens[3],0])\\n leftDegenerate[2] = np.array( circleIntersection(leftDegenerate[3], lens[2], leftDegenerate[1], lens[1]) )\\n\\n try:\\n rightDegenerate[2] = np.array( circleIntersection(rightDegenerate[0], lens[2]+lens[3], rightDegenerate[1], lens[1]) )\\n rightDegenerate[3] = ( lens[3] / (lens[3]+lens[2]) ) * rightDegenerate[2]\\n except:\\n rightDegenerate[2] = np.array([lens[0]+lens[1], 0])\\n rightDegenerate[3] = np.array( circleIntersection(rightDegenerate[0], lens[3], rightDegenerate[2], lens[2]))\\n \\n rightOfOrigin = np.array([1,0]) #Theta = 0 on the Unit Circle\\n thetaMin = angle_between(leftDegenerate[3], rightOfOrigin) #Angle of \\n thetaMax = angle_between(rightDegenerate[3], rightOfOrigin)\\n pitch = (thetaMax - thetaMin) / (N-1)\\n\\n result = []\\n result.append(leftDegenerate) \\n for i in range(1, N-1):\\n result.append(template.copy())\\n result[i][3] = lens[3]*unitCircPt(i*pitch+thetaMin)\\n result[i][2] = np.array(circleIntersection( result[i][3], lens[2], result[i][1], lens[1]))\\n result.append(rightDegenerate) \\n\\n return listify(result)\",\n \"def external_shape(self):\\n return ScaledShape(shape_in=self.tail_joiner, reference_point=Point(0, 0, 0), factor=1, hidden=True)\",\n \"def is_solid(self, world=None):\\n return self.solid\",\n \"def bound_green_object(self, img):\\n\\n self.x = self.y = self.w = self.h = 0\\n\\n # Apply the threshold to get the green parts\\n masked_img = self.threshold(img)\\n\\n # Get contours\\n img_gray = cv2.cvtColor(masked_img, cv2.COLOR_BGR2GRAY)\\n _, contours, _ = cv2.findContours(img_gray, cv2.RETR_LIST, cv2.CHAIN_APPROX_SIMPLE)\\n if len(contours) > 0:\\n # Find the largest contour\\n areas = [cv2.contourArea(c) for c in contours]\\n max_index = np.argmax(areas)\\n max_contour = contours[max_index]\\n\\n self.perimeter_size = cv2.arcLength(max_contour, True)\\n\\n if self.perimeter_size < MIN_PERIMETER:\\n return img\\n\\n # Draw rectangle bounding box on image\\n self.x, self.y, self.w, self.h = cv2.boundingRect(max_contour)\\n\\n # if wider than long, ignore\\n if float(self.h) / self.w < 1:\\n self.x = self.y = self.w = self.h = 0\\n return img\\n\\n cv2.rectangle(img, (self.x, self.y), (self.x + self.w, self.y + self.h), color=(0, 255, 0), thickness=2)\\n\\n # get center\\n M = cv2.moments(max_contour)\\n if M['m00'] > 0:\\n cx = int(M['m10']/M['m00'])\\n cy = int(M['m01']/M['m00'])\\n # draw a circle on the center\\n cv2.circle(img, (cx, cy), 20, (0,0,255), -1)\\n # calc ang error\\n self.ang_error = cx - 320\\n\\n return img\",\n \"def settle_falilng_shape(self):\\n if self.falling_shape:\\n self._settle_shape(self.falling_shape)\\n self.falling_shape = None\\n self.new_shape()\",\n \"def polygon(t, length, n):\\n for i in range(n):\\n t.fd(length)\\n t.lt(360/n)\",\n \"def walls_cc(lenght, width, wall_height=3, roof_height=4):\\n a = min(0.1*lenght, 0.1*width, 0.4*(wall_height+0.5*roof_height))\\n trian = 0.5*width*roof_height\\n trian_5 = 0.5*a*a*(wall_height/roof_height)\\n # trian_4 = trian - 2*trian_5\\n\\n area = (lenght + width)*2*wall_height + 2*trian\\n area_5 = 8*a*wall_height + 4*trian_5\\n area_4 = area - area_5\\n\\n return area, area_4, area_5\",\n \"def bend_s(\\n size: Float2 = (10.0, 2.0),\\n nb_points: int = 99,\\n with_cladding_box: bool = True,\\n cross_section: CrossSectionFactory = strip,\\n **kwargs\\n) -> Component:\\n dx, dy = size\\n x = cross_section(**kwargs)\\n width = x.info[\\\"width\\\"]\\n layer = x.info[\\\"layer\\\"]\\n\\n c = Component()\\n\\n bend = bezier(\\n width=width,\\n control_points=[(0, 0), (dx / 2, 0), (dx / 2, dy), (dx, dy)],\\n npoints=nb_points,\\n layer=layer,\\n )\\n\\n bend_ref = c << bend\\n c.add_ports(bend_ref.ports)\\n c.copy_child_info(bend)\\n c.info[\\\"start_angle\\\"] = bend.info[\\\"start_angle\\\"]\\n c.info[\\\"end_angle\\\"] = bend.info[\\\"end_angle\\\"]\\n c.info[\\\"length\\\"] = bend.info[\\\"length\\\"]\\n c.info[\\\"min_bend_radius\\\"] = bend.info[\\\"min_bend_radius\\\"]\\n\\n if with_cladding_box and x.info[\\\"layers_cladding\\\"]:\\n layers_cladding = x.info[\\\"layers_cladding\\\"]\\n cladding_offset = x.info[\\\"cladding_offset\\\"]\\n points = get_padding_points(\\n component=c,\\n default=0,\\n bottom=cladding_offset,\\n top=cladding_offset,\\n )\\n for layer in layers_cladding or []:\\n c.add_polygon(points, layer=layer)\\n\\n auto_rename_ports(c)\\n return c\",\n \"def stairs(x, y, length, blueness):\\n color = (0, 0.5*blueness, blueness)\\n if length>3:\\n penup()\\n goto(x, y)\\n pendown()\\n fillcolor(color)\\n begin_fill()\\n square(length)\\n end_fill()\\n stairs(x, y+length, length/2, blueness/1.25)\\n stairs(x+length, y, length/2, blueness/1.25)\",\n \"def sector_mask(shape,centre,radius,angle_range):\\n\\n x,y = np.ogrid[:shape[0],:shape[1]]\\n cx,cy = centre\\n tmin,tmax = np.deg2rad(angle_range)\\n\\n # ensure stop angle > start angle\\n if tmax < tmin:\\n tmax += 2*np.pi\\n\\n # convert cartesian --> polar coordinates\\n r2 = (x-cx)*(x-cx) + (y-cy)*(y-cy)\\n theta = np.arctan2(x-cx,y-cy) - tmin\\n\\n # wrap angles between 0 and 2*pi\\n theta %= (2*np.pi)\\n\\n # circular mask\\n circmask = r2 <= radius*radius\\n\\n # angular mask\\n anglemask = theta <= (tmax-tmin)\\n\\n return circmask*anglemask\",\n \"def sector_mask(shape,centre,radius,angle_range):\\n\\n x,y = np.ogrid[:shape[0],:shape[1]]\\n cx,cy = centre\\n tmin,tmax = np.deg2rad(angle_range)\\n\\n # ensure stop angle > start angle\\n if tmax < tmin:\\n tmax += 2*np.pi\\n\\n # convert cartesian --> polar coordinates\\n r2 = (x-cx)*(x-cx) + (y-cy)*(y-cy)\\n theta = np.arctan2(x-cx,y-cy) - tmin\\n\\n # wrap angles between 0 and 2*pi\\n theta %= (2*np.pi)\\n\\n # circular mask\\n circmask = r2 <= radius*radius\\n\\n # angular mask\\n anglemask = theta <= (tmax-tmin)\\n\\n return circmask*anglemask\",\n \"def sector_mask(shape,centre,radius,angle_range):\\n\\n x,y = np.ogrid[:shape[0],:shape[1]]\\n cx,cy = centre\\n tmin,tmax = np.deg2rad(angle_range)\\n\\n # ensure stop angle > start angle\\n if tmax < tmin:\\n tmax += 2*np.pi\\n\\n # convert cartesian --> polar coordinates\\n r2 = (x-cx)*(x-cx) + (y-cy)*(y-cy)\\n theta = np.arctan2(x-cx,y-cy) - tmin\\n\\n # wrap angles between 0 and 2*pi\\n theta %= (2*np.pi)\\n\\n # circular mask\\n circmask = r2 <= radius*radius\\n\\n # angular mask\\n anglemask = theta <= (tmax-tmin)\\n\\n return circmask*anglemask\",\n \"def stokes_left_circular():\\n return np.array([1, 0, 0, -1])\",\n \"def _check_curve(layer: ogr.Layer) -> None:\\n # Check if the feature geometry is polygonal:\\n feature_defn = layer.GetLayerDefn()\\n layer.ResetReading()\\n feature = layer.GetNextFeature()\\n while feature is not None:\\n geom = feature.GetGeometryRef()\\n name_wkt = geom.ExportToWkt()\\n\\n # Approximate a curvature by a polygon geometry:\\n if 'curv' in name_wkt.lower():\\n linear_geom = geom.GetLinearGeometry()\\n new_feature = ogr.Feature(feature_defn)\\n new_feature.SetGeometryDirectly(linear_geom)\\n layer.CreateFeature(new_feature)\\n layer.DeleteFeature(feature.GetFID())\\n\\n feature = layer.GetNextFeature()\",\n \"def XCAFDoc_ShapeTool_IsSimpleShape(*args):\\n return _XCAFDoc.XCAFDoc_ShapeTool_IsSimpleShape(*args)\",\n \"def is_ring(self): # -> bool:\\n ...\",\n \"def c_shape(self,image,i,j):\\r\\n\\r\\n if ((i <= 280 + self.padding) and (j >= 200 - self.padding) and (i >= 230 - self.padding) and (j <= 230 + self.padding)) and not ((i <= 270 - self.padding) and (j >= 210 + self.padding) and (i >= 240 + self.padding) and (j <= 230 + self.padding)):\\r\\n image[self.maximum_size-i,j,:]=0,0,0\\r\\n self.image_p[i,j,:]=2\",\n \"def watershed(mask, img, plotImage = False, kernelSize = None):\\n imgCopy = img.copy()\\n maskCopy = np.array(mask.copy(), dtype=np.uint8)\\n \\n if kernelSize is None:\\n kernelSize = 2\\n\\n # Finding sure foreground area\\n #dist_transform = cv2.distanceTransform(mask, cv2.DIST_L2, 5)\\n #ret, sure_fg = cv2.threshold(dist_transform,0.3*dist_transform.max(),255,0) #change the second argument to change the sensitivity \\n maskClosed = skimage.morphology.closing(np.array(maskCopy, dtype=np.uint8))\\n maskClosed = skimage.morphology.closing(np.array(maskClosed, dtype=np.uint8))\\n kernel = np.ones((kernelSize,kernelSize), np.uint8)\\n # maskCopy = img_as_bool(maskCopy)\\n sure_fg = cv2.erode(maskClosed, kernel, iterations = 2) ###\\n sure_fg = skimage.morphology.closing(np.array(sure_fg, dtype=np.uint8))\\n # kernel = np.ones((2,2), np.uint8)\\n # sure_fg = binary_closing(sure_fg, kernel)\\n \\n # sure background area\\n #kernel = np.ones((5, 5), np.uint8)\\n #sure_bg = cv2.dilate(mask, kernel, iterations = 1)\\n sure_fg_bool = 1 - img_as_bool(sure_fg)\\n # sure_bg = np.uint8(1 - morphology.medial_axis(sure_fg_bool)) ### \\n sure_bg = np.uint8(1 - morphology.skeletonize(sure_fg_bool))\\n sure_bg[0, :] = 1\\n sure_bg[-1, :] = 1\\n sure_bg[:, 0] = 1\\n sure_bg[:, -1] = 1\\n \\n # Finding unknown region\\n sure_fg = np.uint8(sure_fg)\\n unknown = cv2.subtract(sure_bg, sure_fg)\\n \\n if plotImage:\\n plt.figure()\\n plt.imshow(sure_fg)\\n plt.title(\\\"Inner Marker\\\")\\n plt.figure()\\n plt.imshow(sure_bg)\\n plt.title(\\\"Outer Marker\\\")\\n plt.figure()\\n plt.imshow(unknown)\\n plt.title(\\\"Unknown\\\")\\n \\n # Marker labelling\\n ret, markers = cv2.connectedComponents(sure_fg)\\n\\n # Add one to all labels so that sure background is not 0, but 1\\n markers = markers+1\\n\\n # Now, mark the region of unknown with zero\\n markers[unknown==1] = 0\\n \\n if plotImage:\\n plt.figure()\\n plt.imshow(markers, cmap='jet')\\n plt.title(\\\"Markers\\\")\\n \\n # Do watershed\\n markers = cv2.watershed(imgCopy, markers)\\n \\n imgCopy[markers == -1] = [0, 255 ,0]\\n\\n if plotImage:\\n plt.figure()\\n plt.imshow(markers,cmap='jet')\\n plt.title(\\\"Mask\\\")\\n plt.figure()\\n plt.imshow(img)\\n plt.title(\\\"Original Image\\\")\\n plt.figure()\\n plt.imshow(imgCopy)\\n plt.title(\\\"Marked Image\\\")\\n plt.show()\\n\\n return markers\",\n \"def sector_mask(shape, centre, radius, angle_range):\\n\\n x,y = np.ogrid[:shape[0],:shape[1]]\\n cx,cy = centre\\n tmin,tmax = np.deg2rad(angle_range)\\n\\n # ensure stop angle > start angle\\n if tmax < tmin:\\n tmax += 2*np.pi\\n\\n # convert cartesian --> polar coordinates\\n r2 = (x-cx)*(x-cx) + (y-cy)*(y-cy)\\n theta = np.arctan2(x-cx, y-cy) - tmin\\n\\n # wrap angles between 0 and 2*pi\\n theta %= (2*np.pi)\\n\\n # circular mask\\n circmask = r2 <= radius*radius\\n\\n # angular mask\\n anglemask = theta <= (tmax-tmin)\\n\\n return circmask*anglemask\",\n \"def draw_housing():\\n tess.pensize(3)\\n tess.color(\\\"black\\\", \\\"darkgrey\\\")\\n tess.begin_fill()\\n tess.forward(80)\\n tess.left(90)\\n tess.forward(200)\\n tess.circle(40, 180)\\n tess.forward(200)\\n tess.left(90)\\n tess.end_fill()\",\n \"def is_ring(geometry, **kwargs):\\n return lib.is_ring(geometry, **kwargs)\",\n \"def C(width = 1, size = (10, 20), layer = 0):\\n D = Device(name = 'C')\\n w = width/2\\n s1, s2 = size\\n points = [(-w, -w), (s1, -w), (s1, w), (w, w), (w, s2-w),\\n (s1, s2-w), (s1, s2+w), (-w, s2+w), (-w, -w)]\\n D.add_polygon(points, layer = layer)\\n D.add_port(name = 1, midpoint = (s1, s2), width = width, orientation = 0)\\n D.add_port(name = 2, midpoint = (s1, 0), width = width, orientation = 0)\\n return D\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.54048467","0.537262","0.5357499","0.5338746","0.5328752","0.529666","0.51922953","0.51870656","0.51857233","0.5181824","0.5127006","0.512343","0.5072488","0.507105","0.5065166","0.50545657","0.5044749","0.501881","0.5014258","0.49945888","0.49945888","0.4972429","0.4966148","0.49602622","0.4956445","0.49483868","0.49363256","0.49332193","0.4921188","0.49002352","0.48891544","0.48819494","0.48768982","0.4871201","0.48637977","0.48612154","0.48489583","0.48433697","0.4803214","0.47935036","0.47885767","0.4784945","0.47674394","0.47608224","0.47495633","0.47421968","0.474096","0.47404775","0.4736033","0.47339123","0.47339123","0.47307","0.4729536","0.47258747","0.47236496","0.47180685","0.47172964","0.47171968","0.47133893","0.47133258","0.47123188","0.47092944","0.47082093","0.47013474","0.46959135","0.46956545","0.46918786","0.46890533","0.46851605","0.46815607","0.4674296","0.46658602","0.4663404","0.4657171","0.46537545","0.4652617","0.46474525","0.4642915","0.464161","0.4641565","0.46402422","0.46390188","0.46317896","0.4631681","0.46314043","0.46297812","0.46284047","0.46278292","0.46259847","0.46259847","0.46259847","0.46211737","0.4620194","0.46192694","0.46176502","0.46075553","0.46065524","0.46043473","0.4603886","0.4598951","0.4598553"],"string":"[\n \"0.54048467\",\n \"0.537262\",\n \"0.5357499\",\n \"0.5338746\",\n \"0.5328752\",\n \"0.529666\",\n \"0.51922953\",\n \"0.51870656\",\n \"0.51857233\",\n \"0.5181824\",\n \"0.5127006\",\n \"0.512343\",\n \"0.5072488\",\n \"0.507105\",\n \"0.5065166\",\n \"0.50545657\",\n \"0.5044749\",\n \"0.501881\",\n \"0.5014258\",\n \"0.49945888\",\n \"0.49945888\",\n \"0.4972429\",\n \"0.4966148\",\n \"0.49602622\",\n \"0.4956445\",\n \"0.49483868\",\n \"0.49363256\",\n \"0.49332193\",\n \"0.4921188\",\n \"0.49002352\",\n \"0.48891544\",\n \"0.48819494\",\n \"0.48768982\",\n \"0.4871201\",\n \"0.48637977\",\n \"0.48612154\",\n \"0.48489583\",\n \"0.48433697\",\n \"0.4803214\",\n \"0.47935036\",\n \"0.47885767\",\n \"0.4784945\",\n \"0.47674394\",\n \"0.47608224\",\n \"0.47495633\",\n \"0.47421968\",\n \"0.474096\",\n \"0.47404775\",\n \"0.4736033\",\n \"0.47339123\",\n \"0.47339123\",\n \"0.47307\",\n \"0.4729536\",\n \"0.47258747\",\n \"0.47236496\",\n \"0.47180685\",\n \"0.47172964\",\n \"0.47171968\",\n \"0.47133893\",\n \"0.47133258\",\n \"0.47123188\",\n \"0.47092944\",\n \"0.47082093\",\n \"0.47013474\",\n \"0.46959135\",\n \"0.46956545\",\n \"0.46918786\",\n \"0.46890533\",\n \"0.46851605\",\n \"0.46815607\",\n \"0.4674296\",\n \"0.46658602\",\n \"0.4663404\",\n \"0.4657171\",\n \"0.46537545\",\n \"0.4652617\",\n \"0.46474525\",\n \"0.4642915\",\n \"0.464161\",\n \"0.4641565\",\n \"0.46402422\",\n \"0.46390188\",\n \"0.46317896\",\n \"0.4631681\",\n \"0.46314043\",\n \"0.46297812\",\n \"0.46284047\",\n \"0.46278292\",\n \"0.46259847\",\n \"0.46259847\",\n \"0.46259847\",\n \"0.46211737\",\n \"0.4620194\",\n \"0.46192694\",\n \"0.46176502\",\n \"0.46075553\",\n \"0.46065524\",\n \"0.46043473\",\n \"0.4603886\",\n \"0.4598951\",\n \"0.4598553\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":89886,"cells":{"query":{"kind":"string","value":"Creates CoolantChannelRingStraight shapes and checks that the volumes are correct."},"document":{"kind":"string","value":"def test_volume(self):\n\n self.test_shape.workplane = \"XY\"\n self.test_shape.rotation_axis = \"Z\"\n\n assert self.test_shape.volume() == pytest.approx(math.pi * (10**2) * 100 * 8)"},"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_creation(self):\n\n assert self.test_shape.solid is not None\n assert self.test_shape.volume() > 1000","def test_creation(self):\n\n assert self.test_shape.solid is not None\n assert self.test_shape.volume() > 1000","def add_cable_ring(self, env, info={}, cable_idx=0):\n def rad_to_deg(rad):\n return (rad * 180.0) / np.pi\n\n def get_discretized_rotations(num_rotations):\n # counter-clockwise\n theta = i * (2 * np.pi) / num_rotations\n return (theta, rad_to_deg(theta))\n\n # Bead properties.\n num_parts = self.num_parts\n radius = self.radius\n color = self.colors[cable_idx] + [1]\n\n # The `ring_radius` (not the bead radius!) has to be tuned somewhat.\n # Try to make sure the beads don't have notable gaps between them.\n ring_radius = info['ring_radius']\n beads = []\n bead_positions_l = []\n\n # Add beaded cable. Here, `position` is the circle center.\n position = np.float32(info['center_position'])\n part_shape = p.createCollisionShape(p.GEOM_BOX, halfExtents=[radius]*3)\n part_visual = p.createVisualShape(p.GEOM_SPHERE, radius=radius*1.5)\n\n # Iterate through parts and create constraints as needed.\n for i in range(num_parts):\n angle_rad, _ = get_discretized_rotations(num_parts)\n px = ring_radius * np.cos(angle_rad)\n py = ring_radius * np.sin(angle_rad)\n #print(f'pos: {px:0.2f}, {py:0.2f}, angle: {angle_rad:0.2f}, {angle_deg:0.1f}')\n bead_position = np.float32([position[0] + px, position[1] + py, 0.01])\n part_id = p.createMultiBody(0.1, part_shape, part_visual,\n basePosition=bead_position)\n p.changeVisualShape(part_id, -1, rgbaColor=color)\n\n if i > 0:\n parent_frame = bead_position - bead_positions_l[-1]\n constraint_id = p.createConstraint(\n parentBodyUniqueId=beads[-1],\n parentLinkIndex=-1,\n childBodyUniqueId=part_id,\n childLinkIndex=-1,\n jointType=p.JOINT_POINT2POINT,\n jointAxis=(0, 0, 0),\n parentFramePosition=parent_frame,\n childFramePosition=(0, 0, 0))\n p.changeConstraint(constraint_id, maxForce=100)\n\n # Make a constraint with i=0. Careful with `parent_frame`!\n if i == num_parts - 1:\n parent_frame = bead_positions_l[0] - bead_position\n constraint_id = p.createConstraint(\n parentBodyUniqueId=part_id,\n parentLinkIndex=-1,\n childBodyUniqueId=beads[0],\n childLinkIndex=-1,\n jointType=p.JOINT_POINT2POINT,\n jointAxis=(0, 0, 0),\n parentFramePosition=parent_frame,\n childFramePosition=(0, 0, 0))\n p.changeConstraint(constraint_id, maxForce=100)\n\n # Track beads.\n beads.append(part_id)\n bead_positions_l.append(bead_position)\n\n # The usual for tracking IDs. Four things to add.\n self.cable_bead_IDs.append(part_id)\n self._IDs[part_id] = f'cable_part_{str(part_id).zfill(2)}'\n env.objects.append(part_id)\n self.object_points[part_id] = np.float32((0, 0, 0)).reshape(3, 1)\n\n if 'cable-ring' in self._name:\n # For targets, we can assume the starting position gives us\n # that. Later, apply a random force on the ring to perturb it.\n true_position = (bead_position[0], bead_position[1], 0)\n self.goal['places'][part_id] = (true_position, (0, 0, 0, 1.))\n symmetry = 0\n self.goal['steps'][0][part_id] = (symmetry, [part_id])\n\n # Make the true positions visible if desired.\n if info['targets_visible']:\n sq_pose = ((true_position[0], true_position[1], 0.002), (0,0,0,1))\n sq_template = 'assets/square/square-template-allsides-green.urdf'\n replace = {'DIM': (0.003,), 'HALF': (0.003 / 2,)}\n urdf = self.fill_template(sq_template, replace)\n env.add_object(urdf, sq_pose, fixed=True)\n os.remove(urdf)\n else:\n print(f'Warning, env {self._name} will not have goals.')","def generate_solid(self):\n ext = os.path.splitext(self.filename)[1][1:]\n if ext == 'stl':\n shaft_compound = read_stl_file(self.filename)\n elif ext == 'iges':\n iges_reader = IGESControl_Reader()\n iges_reader.ReadFile(self.filename)\n iges_reader.TransferRoots()\n shaft_compound = iges_reader.Shape()\n else:\n raise Exception('The shaft file is not in iges/stl formats')\n sewer = BRepBuilderAPI_Sewing(1e-2)\n sewer.Add(shaft_compound)\n sewer.Perform()\n result_sewed_shaft = sewer.SewedShape()\n shaft_solid_maker = BRepBuilderAPI_MakeSolid()\n shaft_solid_maker.Add(OCC.Core.TopoDS.topods_Shell(result_sewed_shaft))\n if not shaft_solid_maker.IsDone():\n raise RuntimeError('Unsuccessful assembling of solid shaft')\n shaft_solid = shaft_solid_maker.Solid()\n return shaft_solid","def _create_main_shape(self):\n\n a, b = gc( self.size/2,\n self._ZERO_DEGREES - self.angle,\n self._180_DEGREES + self.angle)\n self.wafer_points = zip(a,b)\n self.wafer_polygon = gdspy.Polygon(self.wafer_points, self.WAFER_LAYER)\n self.cell.add(self.wafer_polygon)","def _check_mount(self):\n if self.mount == ComponentBase.MOUNT_SMD:\n valid_shapes = [Con.SHAPE_PAD]\n default_shape = Con.SHAPE_PAD\n elif self.mount == ComponentBase.MOUNT_THT:\n valid_shapes = [Con.SHAPE_HOLE, Con.SHAPE_RHOLE]\n default_shape = Con.SHAPE_HOLE\n \n for con in self.connectors:\n if con.p_shape not in valid_shapes:\n con.p_shape = default_shape","def __bcc_left_diagonals(self) -> cq.cq.Workplane:\n # In a cuboid ABCDA1B1C1D1 this is the angle C1AD\n #angle_C1AD = 90 - degrees(acos(2**-.5))\n angle_C1AD = 90 - degrees(acos(0.5))\n angle_CAD = 90 - degrees(acos(sqrt(2/3)))\n pseudo_unit_cell_size = sqrt(2/3)*self.unit_cell_size\n corner_points = np.array(\n [(0, 0),\n (self.bcc_unit_cell_size, 0),\n (self.bcc_unit_cell_size, self.unit_cell_size),\n (0, self.unit_cell_size)]\n )\n result = (\n cq.Workplane(\"XY\")\n .pushPoints(corner_points)\n .eachpointAdaptive(\n create_bcc_diagonal_strut,\n callback_extra_args = [\n {\"unit_cell_size\": pseudo_unit_cell_size,\n \"radius\": self.strut_radius,\n \"angle_x\": - angle_CAD,\n \"angle_y\": angle_C1AD},\n {\"unit_cell_size\": 0.5 * pseudo_unit_cell_size,\n \"radius\": self.strut_radius,\n \"angle_x\": - angle_CAD,\n \"angle_y\": - angle_C1AD},\n {\"unit_cell_size\": 0.5 * pseudo_unit_cell_size,\n \"radius\": self.strut_radius,\n \"angle_x\": angle_CAD,\n \"angle_y\": - angle_C1AD},\n {\"unit_cell_size\": pseudo_unit_cell_size,\n \"radius\": self.strut_radius,\n \"angle_x\": angle_CAD,\n \"angle_y\": angle_C1AD}\n ],\n useLocalCoords = True\n )\n )\n return result","def test_drawSolid(self):\n\n image_name = filename(sys._getframe().f_code.co_name)\n result_file, reference_file = get_path(image_name)\n\n ''' This function is to create an empty image with a specific dimension\n with white background, and black/white colored '''\n\n image, canvas = get_image('RGB', (640, 480), 'white')\n\n '''\n for different representations of colors see\n \"https://pillow.readthedocs.io/en/3.0.x/reference/ImageColor.html#color-names\"\n '''\n drawSolid(canvas, regularPolygon(3, np.array([160, 120]), 50), 'red')\n drawSolid(canvas, regularPolygon(4, np.array([480, 120]), 90), 'blue')\n drawSolid(canvas, regularPolygon(5, np.array([420, 360]), 60), 'green')\n drawSolid(canvas, regularPolygon(6, np.array([160, 360]), 80), 'black')\n drawSolid(canvas, regularPolygon(7, np.array([320, 160]), 70), 'brown')\n\n \"\"\" saving the file and closing it \"\"\"\n image.save(result_file)\n image.close()\n\n \"\"\" validate the resultant file against the reference images\"\"\"\n\n validate(reference_file, result_file)","def test_rocket():\n ring = [(0,0), (10, 0), (15,5), (10,9), (1,7), (6,4), (0,0)]\n conv = ToPointsAndSegments()\n conv.add_polygon([ring])\n skel = calc_skel(conv, output=True, pause=True)\n print \"DONE\"","def finalize(self):\n\n if self.finalized:\n return\n\n ## Loop over each ring and add cells for inner rings\n params = zip(self.radii, self.box, self.fills, self.rot)\n for i, (radius, box, fill, rot) in enumerate(params):\n\n label = \"{0} radial {1}: {2}\".format(self._name, i, fill._name)\n\n if i == 0:\n # this is the first ring\n\n if box:\n # this first ring is a box ring\n\n cell = openmc.Cell(name=label, fill=fill)\n cell.region = radius\n if not rot is None: cell.rotation = rot\n self.add_cell(cell)\n\n else:\n # this first ring is a regular cylinder\n\n cell = openmc.Cell(name=label, fill=fill)\n cell.region = -radius\n if not rot is None: cell.rotation = rot\n self.add_cell(cell)\n\n else:\n # this is not the first ring\n\n if self.box[i-1]:\n # the last ring was a box\n\n if box:\n # this is a box ring, and the last one was also a box ring\n cell = openmc.Cell(name=label, fill=fill)\n cell.region = ~radius\n if not rot is None: cell.rotation = rot\n self.add_cell(cell)\n\n else:\n # this is a regular cylinder, and the last one was a box ring\n cell = openmc.Cell(name=label, fill=fill)\n cell.region = -r & ~self.radii[i-1]\n self.add_cell(cell)\n\n else:\n # the last ring was a regular cylinder\n\n if box:\n # this is a box ring, and the last one was a regular cylinder\n\n cell = openmc.Cell(name=label, fill=fill)\n cell.region = +self.radii[i-1] & radius\n if not rot is None: cell.rotation = rot\n self.add_cell(cell)\n\n else:\n # this is a regular ring, and the last one was a regular cylinder\n\n cell = openmc.Cell(name=label, fill=fill)\n cell.region = +self.radii[i-1] & -radius\n if not rot is None: cell.rotation = rot\n self.add_cell(cell)\n\n ## Now write the outermost cell(s) that go to infinity\n\n label = \"{0} radial outer: {1}\".format(self._name, self.fills[-1]._name)\n\n if self.box[-1]:\n # the last one is a box, we need 4 outer cells to infinity\n cell = openmc.Cell(name=label, fill=self.fills[-1])\n cell.region = ~radius\n if not self.rot[-1] is None: cell.rotation = self.rot[-1]\n self.add_cell(cell)\n\n else:\n\n # the last one is a regular cylindrical ring - just one cell to infinity\n cell = openmc.Cell(name=label, fill=self.fills[-1])\n cell.region = +self.radii[-1]\n if not self.rot[-1] is None: cell.rotation = self.rot[-1]\n self.add_cell(cell)\n\n self.finalized = True","def test_polygons_with_inner_rings(self):\n\n # Define two (closed) outer rings - clock wise direction\n outer_rings = [numpy.array([[106.79, -6.233],\n [106.80, -6.24],\n [106.78, -6.23],\n [106.77, -6.21],\n [106.79, -6.233]]),\n numpy.array([[106.76, -6.23],\n [106.72, -6.23],\n [106.72, -6.22],\n [106.72, -6.21],\n [106.76, -6.23]])]\n\n tmp_filename = unique_filename(suffix='.shp')\n\n # Do outer rings first (use default geometry type polygon)\n v_ref = Vector(geometry=outer_rings)\n assert v_ref.is_polygon_data\n\n v_ref.write_to_file(tmp_filename)\n v_file = read_layer(tmp_filename)\n assert v_file == v_ref\n assert v_file.is_polygon_data\n\n # Do it again but with (closed) inner rings as well\n\n # Define inner rings (counter clock wise)\n inner_rings = [\n # 2 rings for feature 0\n [numpy.array([[106.77827, -6.2252],\n [106.77775, -6.22378],\n [106.78, -6.22311],\n [106.78017, -6.22530],\n [106.77827, -6.2252]])[::-1],\n numpy.array([[106.78652, -6.23215],\n [106.78642, -6.23075],\n [106.78746, -6.23143],\n [106.78831, -6.23307],\n [106.78652, -6.23215]])[::-1]],\n # 1 ring for feature 1\n [numpy.array([[106.73709, -6.22752],\n [106.73911, -6.22585],\n [106.74265, -6.22814],\n [106.73971, -6.22926],\n [106.73709, -6.22752]])[::-1]]]\n\n polygons = []\n for i, outer_ring in enumerate(outer_rings):\n p = Polygon(outer_ring=outer_ring, inner_rings=inner_rings[i])\n polygons.append(p)\n\n v_ref = Vector(geometry=polygons)\n assert v_ref.is_polygon_data\n data_bbox = v_ref.get_bounding_box()\n\n # Check data from Vector object\n geometry = v_ref.get_geometry(as_geometry_objects=True)\n for i, g in enumerate(geometry):\n assert numpy.allclose(g.outer_ring, outer_rings[i])\n if i == 0:\n assert len(g.inner_rings) == 2\n else:\n assert len(g.inner_rings) == 1\n\n for j, ring in enumerate(inner_rings[i]):\n assert numpy.allclose(ring, g.inner_rings[j])\n\n # Write to file and read again\n v_ref.write_to_file(tmp_filename)\n #print 'With inner rings, written to ', tmp_filename\n v_file = read_layer(tmp_filename)\n assert v_file == v_ref\n assert v_file.is_polygon_data\n assert numpy.allclose(v_file.get_bounding_box(), data_bbox,\n rtol=1.0e-12, atol=1.0e-12)\n\n # Check data from file\n geometry = v_file.get_geometry(as_geometry_objects=True)\n for i, g in enumerate(geometry):\n assert numpy.allclose(g.outer_ring, outer_rings[i])\n if i == 0:\n assert len(g.inner_rings) == 2\n else:\n assert len(g.inner_rings) == 1\n\n for j, ring in enumerate(inner_rings[i]):\n assert numpy.allclose(ring, g.inner_rings[j])","def build_lens_icosahedron(kabamland, vtx, rad, diameter_ratio, thickness_ratio, half_EPD, blockers=True, blocker_thickness_ratio=1.0/1000, light_confinement=False, focal_length=1.0, lens_system_name=None):\n # Get the list of lens meshes from the appropriate lens system as well as the lens material'''\n scale_rad = rad*diameter_ratio #max_radius->rad of the lens assembly\n lenses = lenssystem.get_lens_mesh_list(lens_system_name, scale_rad)\n lensmat = lenssystem.get_lens_material(lens_system_name)\n face = None\n for lns in lenses:\n #lns = mh.rotate(lns,make_rotation_matrix(ph,ax))\n if not face:\n face = Solid(lns, lensmat, kabamland.detector_material)\n else:\n face += Solid(lns, lensmat, kabamland.detector_material)\n\n if light_confinement:\n shield = mh.rotate(cylindrical_shell(rad*(1 - 0.001), rad, focal_length,32), make_rotation_matrix(np.pi/2.0, (1,0,0)))\n baffle = Solid(shield, lensmat, kabamland.detector_material, black_surface, 0xff0000)\n\n if blockers:\n blocker_thickness = 2*rad*blocker_thickness_ratio\n if half_EPD < rad:\n c1 = lenssystem.get_lens_sys(lens_system_name).c1*lenssystem.get_scale_factor(lens_system_name,scale_rad)\n offset = [0,0,c1-np.sqrt(c1*c1-rad*rad)]\n anulus_blocker = mh.shift(mh.rotate(cylindrical_shell(half_EPD, rad, blocker_thickness, 32), make_rotation_matrix(np.pi/2.0, (1,0,0))),offset)\n face += Solid(anulus_blocker, lensmat, kabamland.detector_material, black_surface, 0xff0000)\n phi, axs = rot_axis([0,0,1],vtx)\n for vx,ph,ax in zip(vtx,-phi,axs):\n kabamland.add_solid(face, rotation=make_rotation_matrix(ph,ax), displacement = -vx)\n if light_confinement:\n kabamland.add_solid(baffle, rotation=make_rotation_matrix(ph,ax), displacement = -normalize(vx)*(np.linalg.norm(vx)+focal_length/2.0))","def createCylinder( basePoint=(0,-1,0), tipPoint=(0,1,0), radius = 1.0, colour=(0.6,0.6,0.6), samples = 20 ):\r\n \r\n basePoint = PyUtils.toPoint3d(basePoint)\r\n tipPoint = PyUtils.toPoint3d(tipPoint)\r\n baseToTipVector = Vector3d(basePoint,tipPoint)\r\n if baseToTipVector.isZeroVector() :\r\n raise ValueError( 'Invalid points for cylinder: base and tip are equal!' )\r\n baseToTipUnitVector = baseToTipVector.unit()\r\n xUnitVector = baseToTipUnitVector.crossProductWith( Vector3d(0,0,1) )\r\n if xUnitVector.length() < 0.5 :\r\n xUnitVector = baseToTipUnitVector.crossProductWith( Vector3d(0,-1,0) )\r\n xUnitVector.toUnit()\r\n yUnitVector = baseToTipUnitVector.crossProductWith( Vector3d(-1,0,0) )\r\n if yUnitVector.length() < 0.5 :\r\n yUnitVector = baseToTipUnitVector.crossProductWith( Vector3d(0,1,0) )\r\n yUnitVector.toUnit()\r\n\r\n vertices = []\r\n for i in range(samples):\r\n theta = i * 2 * math.pi / float(samples)\r\n vertices.append( basePoint + xUnitVector * math.cos(theta) * radius + yUnitVector * math.sin(theta) * radius )\r\n for i in range(samples):\r\n theta = i * 2 * math.pi / float(samples)\r\n vertices.append( tipPoint + xUnitVector * math.cos(theta) * radius + yUnitVector * math.sin(theta) * radius )\r\n for i in range(samples):\r\n theta = i * 2 * math.pi / float(samples)\r\n vertices.append( basePoint + xUnitVector * math.cos(theta) * radius + yUnitVector * math.sin(theta) * radius )\r\n vertices.append( tipPoint + xUnitVector * math.cos(theta) * radius + yUnitVector * math.sin(theta) * radius )\r\n \r\n faces = [ range(0,samples), range(samples,2*samples) ]\r\n for i in range(0,2*samples,2) :\r\n base = 2*samples\r\n size = 2*samples\r\n faces.append( (base+i, base+i+1, base+(i+3)%size, base+(i+2)%size ) )\r\n \r\n return create( vertices, faces, colour )","def create_rink():\n\n # RINK\n coords = OFFSET, OFFSET, OFFSET+22*SCALE, OFFSET+22*SCALE\n canvas.create_arc(coords, start=90, extent=90, fill=WHITE, outline=\"\")\n coords = OFFSET, HEIGHT-OFFSET-22*SCALE, OFFSET+22*SCALE, HEIGHT-OFFSET\n canvas.create_arc(coords, start=180, extent=90, fill=WHITE, outline=WHITE)\n coords = WIDTH-OFFSET-22*SCALE, HEIGHT-OFFSET-22*SCALE, WIDTH-OFFSET, HEIGHT-OFFSET\n canvas.create_arc(coords, start=270, extent=90, fill=WHITE, outline=WHITE)\n coords = WIDTH-OFFSET-22*SCALE, OFFSET, WIDTH-OFFSET, OFFSET+22*SCALE\n canvas.create_arc(coords, start=0, extent=90, fill=WHITE, outline=WHITE)\n coords = OFFSET+11*SCALE, OFFSET, WIDTH-OFFSET-11*SCALE, OFFSET, WIDTH-OFFSET-11*SCALE, HEIGHT-OFFSET, OFFSET+11*SCALE, HEIGHT-OFFSET\n canvas.create_polygon(coords, fill=WHITE, outline=WHITE)\n coords = OFFSET, OFFSET+11*SCALE, WIDTH-OFFSET, OFFSET+11*SCALE, WIDTH-OFFSET, HEIGHT-OFFSET-11*SCALE, OFFSET, HEIGHT-OFFSET-11*SCALE\n canvas.create_polygon(coords, fill=WHITE, outline=WHITE)\n\n # CENTER CIRCLE\n coords = WIDTH/2-15*SCALE, HEIGHT/2-15*SCALE, WIDTH/2+15*SCALE, HEIGHT/2+15*SCALE\n canvas.create_oval(coords, outline=BLUE, width=2, fill=WHITE)\n\n # HALF CENTER CIRCLE\n coords = WIDTH/2-10*SCALE, HEIGHT-OFFSET-10*SCALE, WIDTH/2+10*SCALE, HEIGHT-OFFSET+10*SCALE\n canvas.create_arc(coords, outline=RED, width=2, start=0, extent=180)\n\n # GOAL AREA\n # - Left\n # - - Crease\n coords = OFFSET+5*SCALE, HEIGHT/2-6*SCALE, OFFSET+17*SCALE, HEIGHT/2+6*SCALE\n canvas.create_arc(coords, fill=LIGHT_BLUE, start=318, extent=84, outline=\"\")\n canvas.create_arc(coords, outline=RED, start=318, extent=84, style=ARC)\n coords = OFFSET+11*SCALE, HEIGHT/2-4*SCALE, OFFSET+15.5*SCALE, HEIGHT/2-4*SCALE, OFFSET+15.5*SCALE, HEIGHT/2+4*SCALE, OFFSET+11*SCALE, HEIGHT/2+4*SCALE\n canvas.create_polygon(coords, fill=LIGHT_BLUE, outline=\"\")\n coords = OFFSET+11*SCALE, HEIGHT/2-4*SCALE, OFFSET+15.2*SCALE+1, HEIGHT/2-4*SCALE\n canvas.create_line(coords, fill=RED)\n coords = OFFSET+15.2*SCALE+1, HEIGHT/2+4*SCALE, OFFSET+11*SCALE, HEIGHT/2+4*SCALE\n canvas.create_line(coords, fill=RED)\n # - - Restricted Area\n coords = OFFSET, HEIGHT/2-14*SCALE, OFFSET+11*SCALE, HEIGHT/2-9*SCALE\n canvas.create_line(coords, fill=RED)\n coords = OFFSET, HEIGHT/2+14*SCALE, OFFSET+11*SCALE, HEIGHT/2+9*SCALE\n canvas.create_line(coords, fill=RED)\n # - - Goal\n coords = OFFSET+8*SCALE, HEIGHT/2-3*SCALE, OFFSET+11*SCALE, HEIGHT/2-3*SCALE, OFFSET+11*SCALE, HEIGHT/2+3*SCALE, OFFSET+8*SCALE, HEIGHT/2+3*SCALE\n canvas.create_polygon(coords, fill=GRAY, outline=RED)\n # - Right\n # - - Crease\n coords = WIDTH-(OFFSET+5*SCALE), HEIGHT/2-6*SCALE, WIDTH-(OFFSET+17*SCALE), HEIGHT/2+6*SCALE\n canvas.create_arc(coords, fill=LIGHT_BLUE, start=138, extent=84, outline=\"\")\n canvas.create_arc(coords, outline=RED, start=138, extent=84, style=ARC)\n coords = WIDTH-(OFFSET+11*SCALE), HEIGHT/2-4*SCALE, WIDTH-(OFFSET+15.5*SCALE), HEIGHT/2-4*SCALE, WIDTH-(OFFSET+15.5*SCALE), HEIGHT/2+4*SCALE, WIDTH-(OFFSET+11*SCALE), HEIGHT/2+4*SCALE\n canvas.create_polygon(coords, fill=LIGHT_BLUE, outline=\"\")\n coords = WIDTH-(OFFSET+11*SCALE), HEIGHT/2-4*SCALE, WIDTH-(OFFSET+15.2*SCALE+1), HEIGHT/2-4*SCALE\n canvas.create_line(coords, fill=RED)\n coords = WIDTH-(OFFSET+15.2*SCALE+1), HEIGHT/2+4*SCALE, WIDTH-(OFFSET+11*SCALE), HEIGHT/2+4*SCALE\n canvas.create_line(coords, fill=RED)\n # - - Restricted Area\n coords = WIDTH-OFFSET, HEIGHT/2-14*SCALE, WIDTH-OFFSET-11*SCALE, HEIGHT/2-9*SCALE\n canvas.create_line(coords, fill=RED)\n coords = WIDTH-OFFSET, HEIGHT/2+14*SCALE, WIDTH-OFFSET-11*SCALE, HEIGHT/2+9*SCALE\n canvas.create_line(coords, fill=RED)\n # - - Goal\n coords = WIDTH-(OFFSET+8*SCALE), HEIGHT/2-3*SCALE, WIDTH-(OFFSET+11*SCALE), HEIGHT/2-3*SCALE, WIDTH-(OFFSET+11*SCALE), HEIGHT/2+3*SCALE, WIDTH-(OFFSET+8*SCALE), HEIGHT/2+3*SCALE\n canvas.create_polygon(coords, fill=GRAY, outline=RED)\n\n # LINES\n # - Left Baseline\n coords = OFFSET+11*SCALE, OFFSET, OFFSET+11*SCALE, HEIGHT-OFFSET\n canvas.create_line(coords, fill=RED, width=1.5)\n # - Right Baseline\n coords = WIDTH-OFFSET-11*SCALE, OFFSET, WIDTH-OFFSET-11*SCALE, HEIGHT-OFFSET\n canvas.create_line(coords, fill=RED, width=1.5)\n # - Left Blueline\n coords = OFFSET+70*SCALE, OFFSET, OFFSET+70*SCALE, HEIGHT-OFFSET\n canvas.create_line(coords, fill=BLUE, width=7)\n # - Right Blueline\n coords = WIDTH-(OFFSET+70*SCALE), OFFSET, WIDTH-(OFFSET+70*SCALE), HEIGHT-OFFSET\n canvas.create_line(coords, fill=BLUE, width=7)\n # - Redline\n coords = WIDTH/2, OFFSET, WIDTH/2, HEIGHT-OFFSET\n canvas.create_line(coords, fill=RED, width=7)\n coords = WIDTH/2, OFFSET, WIDTH/2, HEIGHT-OFFSET\n canvas.create_line(coords, fill=WHITE, width=5, dash=(9,9))\n\n # RINK OUTLINE\n coords = OFFSET, OFFSET, OFFSET+22*SCALE, OFFSET+22*SCALE\n canvas.create_arc(coords, start=90, extent=90, outline=BLACK, style=ARC, width=2)\n coords = OFFSET, HEIGHT-OFFSET-22*SCALE, OFFSET+22*SCALE, HEIGHT-OFFSET\n canvas.create_arc(coords, start=180, extent=90, outline=BLACK, style=ARC, width=2)\n coords = WIDTH-OFFSET-22*SCALE, HEIGHT-OFFSET-22*SCALE, WIDTH-OFFSET, HEIGHT-OFFSET\n canvas.create_arc(coords, start=270, extent=90, outline=BLACK, style=ARC, width=2)\n coords = WIDTH-OFFSET-22*SCALE, OFFSET, WIDTH-OFFSET, OFFSET+22*SCALE\n canvas.create_arc(coords, start=0, extent=90, outline=BLACK, style=ARC, width=2)\n coords = OFFSET+11*SCALE, OFFSET, WIDTH-OFFSET-11*SCALE, OFFSET\n canvas.create_line(coords, fill=BLACK, width=2)\n coords = WIDTH-OFFSET, OFFSET+11*SCALE, WIDTH-OFFSET, HEIGHT-OFFSET-11*SCALE\n canvas.create_line(coords, fill=BLACK, width=2)\n coords = WIDTH-OFFSET-11*SCALE, HEIGHT-OFFSET, OFFSET+11*SCALE, HEIGHT-OFFSET\n canvas.create_line(coords, fill=BLACK, width=2)\n coords = OFFSET, OFFSET+11*SCALE, OFFSET, HEIGHT-OFFSET-11*SCALE\n canvas.create_line(coords, fill=BLACK, width=2)\n\n\n # CENTER DOT\n coords = WIDTH/2-1*SCALE-1, HEIGHT/2-1*SCALE-1, WIDTH/2+1*SCALE+1, HEIGHT/2+1*SCALE+1\n canvas.create_oval(coords, outline=WHITE, fill=BLUE)\n\n # FACEOFF\n # - Top Left\n # - - Ticks\n coords = OFFSET+29.5*SCALE, HEIGHT/2-39*SCALE, OFFSET+29.5*SCALE, HEIGHT/2-5*SCALE\n canvas.create_line(coords, fill=RED, width=2)\n coords = OFFSET+32.5*SCALE, HEIGHT/2-39*SCALE, OFFSET+32.5*SCALE, HEIGHT/2-5*SCALE\n canvas.create_line(coords, fill=RED, width=2)\n # - - Circles\n coords = OFFSET+16*SCALE, HEIGHT/2-37*SCALE, OFFSET+46*SCALE, HEIGHT/2-7*SCALE\n canvas.create_oval(coords, outline=RED, width=2, fill=WHITE)\n coords = OFFSET+30*SCALE, HEIGHT/2-23*SCALE, OFFSET+32*SCALE, HEIGHT/2-21*SCALE\n canvas.create_oval(coords, fill=RED, outline=\"\")\n # - - Cross\n coords = OFFSET+25*SCALE, HEIGHT/2-22.8*SCALE, OFFSET+29*SCALE, HEIGHT/2-22.8*SCALE, OFFSET+29*SCALE, HEIGHT/2-25.8*SCALE\n canvas.create_line(coords, fill=RED, width=2)\n coords = OFFSET+25*SCALE, HEIGHT/2-21.2*SCALE, OFFSET+29*SCALE, HEIGHT/2-21.2*SCALE, OFFSET+29*SCALE, HEIGHT/2-18.2*SCALE\n canvas.create_line(coords, fill=RED, width=2)\n coords = OFFSET+37*SCALE, HEIGHT/2-22.8*SCALE, OFFSET+33*SCALE, HEIGHT/2-22.8*SCALE, OFFSET+33*SCALE, HEIGHT/2-25.8*SCALE\n canvas.create_line(coords, fill=RED, width=2)\n coords = OFFSET+37*SCALE, HEIGHT/2-21.2*SCALE, OFFSET+33*SCALE, HEIGHT/2-21.2*SCALE, OFFSET+33*SCALE, HEIGHT/2-18.2*SCALE\n canvas.create_line(coords, fill=RED, width=2)\n # - Bottom Left\n # - - Ticks\n coords = OFFSET+29.5*SCALE, HEIGHT/2+39*SCALE, OFFSET+29.5*SCALE, HEIGHT/2+5*SCALE\n canvas.create_line(coords, fill=RED, width=2)\n coords = OFFSET+32.5*SCALE, HEIGHT/2+39*SCALE, OFFSET+32.5*SCALE, HEIGHT/2+5*SCALE\n canvas.create_line(coords, fill=RED, width=2)\n # - - Circles\n coords = OFFSET+16*SCALE, HEIGHT/2+37*SCALE, OFFSET+46*SCALE, HEIGHT/2+7*SCALE\n canvas.create_oval(coords, outline=RED, width=2, fill=WHITE)\n coords = OFFSET+30*SCALE, HEIGHT/2+23*SCALE, OFFSET+32*SCALE, HEIGHT/2+21*SCALE\n canvas.create_oval(coords, fill=RED, outline=\"\")\n # - - Cross\n coords = OFFSET+25*SCALE, HEIGHT/2+22.8*SCALE, OFFSET+29*SCALE, HEIGHT/2+22.8*SCALE, OFFSET+29*SCALE, HEIGHT/2+25.8*SCALE\n canvas.create_line(coords, fill=RED, width=2)\n coords = OFFSET+25*SCALE, HEIGHT/2+21.2*SCALE, OFFSET+29*SCALE, HEIGHT/2+21.2*SCALE, OFFSET+29*SCALE, HEIGHT/2+18.2*SCALE\n canvas.create_line(coords, fill=RED, width=2)\n coords = OFFSET+37*SCALE, HEIGHT/2+22.8*SCALE, OFFSET+33*SCALE, HEIGHT/2+22.8*SCALE, OFFSET+33*SCALE, HEIGHT/2+25.8*SCALE\n canvas.create_line(coords, fill=RED, width=2)\n coords = OFFSET+37*SCALE, HEIGHT/2+21.2*SCALE, OFFSET+33*SCALE, HEIGHT/2+21.2*SCALE, OFFSET+33*SCALE, HEIGHT/2+18.2*SCALE\n canvas.create_line(coords, fill=RED, width=2)\n # - Top Right\n # - - Ticks\n coords = WIDTH-(OFFSET+29.5*SCALE), HEIGHT/2-39*SCALE, WIDTH-(OFFSET+29.5*SCALE), HEIGHT/2-5*SCALE\n canvas.create_line(coords, fill=RED, width=2)\n coords = WIDTH-(OFFSET+32.5*SCALE), HEIGHT/2-39*SCALE, WIDTH-(OFFSET+32.5*SCALE), HEIGHT/2-5*SCALE\n canvas.create_line(coords, fill=RED, width=2)\n # - - Circles\n coords = WIDTH-(OFFSET+16*SCALE), HEIGHT/2-37*SCALE, WIDTH-(OFFSET+46*SCALE), HEIGHT/2-7*SCALE\n canvas.create_oval(coords, outline=RED, width=2, fill=WHITE)\n coords = WIDTH-(OFFSET+30*SCALE), HEIGHT/2-23*SCALE, WIDTH-(OFFSET+32*SCALE), HEIGHT/2-21*SCALE\n canvas.create_oval(coords, fill=RED, outline=\"\")\n # - - Cross\n coords = WIDTH-(OFFSET+25*SCALE), HEIGHT/2-22.8*SCALE, WIDTH-(OFFSET+29*SCALE), HEIGHT/2-22.8*SCALE, WIDTH-(OFFSET+29*SCALE), HEIGHT/2-25.8*SCALE\n canvas.create_line(coords, fill=RED, width=2)\n coords = WIDTH-(OFFSET+25*SCALE), HEIGHT/2-21.2*SCALE, WIDTH-(OFFSET+29*SCALE), HEIGHT/2-21.2*SCALE, WIDTH-(OFFSET+29*SCALE), HEIGHT/2-18.2*SCALE\n canvas.create_line(coords, fill=RED, width=2)\n coords = WIDTH-(OFFSET+37*SCALE), HEIGHT/2-22.8*SCALE, WIDTH-(OFFSET+33*SCALE), HEIGHT/2-22.8*SCALE, WIDTH-(OFFSET+33*SCALE), HEIGHT/2-25.8*SCALE\n canvas.create_line(coords, fill=RED, width=2)\n coords = WIDTH-(OFFSET+37*SCALE), HEIGHT/2-21.2*SCALE, WIDTH-(OFFSET+33*SCALE), HEIGHT/2-21.2*SCALE, WIDTH-(OFFSET+33*SCALE), HEIGHT/2-18.2*SCALE\n canvas.create_line(coords, fill=RED, width=2)\n # - Bottom Right\n # - - Ticks\n coords = WIDTH-(OFFSET+29.5*SCALE), HEIGHT/2+39*SCALE, WIDTH-(OFFSET+29.5*SCALE), HEIGHT/2+5*SCALE\n canvas.create_line(coords, fill=RED, width=2)\n coords = WIDTH-(OFFSET+32.5*SCALE), HEIGHT/2+39*SCALE, WIDTH-(OFFSET+32.5*SCALE), HEIGHT/2+5*SCALE\n canvas.create_line(coords, fill=RED, width=2)\n # - - Circles\n coords = WIDTH-(OFFSET+16*SCALE), HEIGHT/2+37*SCALE, WIDTH-(OFFSET+46*SCALE), HEIGHT/2+7*SCALE\n canvas.create_oval(coords, outline=RED, width=2, fill=WHITE)\n coords = WIDTH-(OFFSET+30*SCALE), HEIGHT/2+23*SCALE, WIDTH-(OFFSET+32*SCALE), HEIGHT/2+21*SCALE\n canvas.create_oval(coords, fill=RED, outline=\"\")\n # - - Cross\n coords = WIDTH-(OFFSET+25*SCALE), HEIGHT/2+22.8*SCALE, WIDTH-(OFFSET+29*SCALE), HEIGHT/2+22.8*SCALE, WIDTH-(OFFSET+29*SCALE), HEIGHT/2+25.8*SCALE\n canvas.create_line(coords, fill=RED, width=2)\n coords = WIDTH-(OFFSET+25*SCALE), HEIGHT/2+21.2*SCALE, WIDTH-(OFFSET+29*SCALE), HEIGHT/2+21.2*SCALE, WIDTH-(OFFSET+29*SCALE), HEIGHT/2+18.2*SCALE\n canvas.create_line(coords, fill=RED, width=2)\n coords = WIDTH-(OFFSET+37*SCALE), HEIGHT/2+22.8*SCALE, WIDTH-(OFFSET+33*SCALE), HEIGHT/2+22.8*SCALE, WIDTH-(OFFSET+33*SCALE), HEIGHT/2+25.8*SCALE\n canvas.create_line(coords, fill=RED, width=2)\n coords = WIDTH-(OFFSET+37*SCALE), HEIGHT/2+21.2*SCALE, WIDTH-(OFFSET+33*SCALE), HEIGHT/2+21.2*SCALE, WIDTH-(OFFSET+33*SCALE), HEIGHT/2+18.2*SCALE\n canvas.create_line(coords, fill=RED, width=2)\n\n # NEUTRAL ZONE FACEOFF\n # - Top Left\n coords = WIDTH/2-21*SCALE, HEIGHT/2-23*SCALE, WIDTH/2-19*SCALE, HEIGHT/2-21*SCALE\n canvas.create_oval(coords, outline=\"\", fill=RED)\n # - Bottom Left\n coords = WIDTH/2-21*SCALE, HEIGHT/2+23*SCALE, WIDTH/2-19*SCALE, HEIGHT/2+21*SCALE\n canvas.create_oval(coords, outline=\"\", fill=RED)\n # - Top Right\n coords = WIDTH/2+21*SCALE, HEIGHT/2-23*SCALE, WIDTH/2+19*SCALE, HEIGHT/2-21*SCALE\n canvas.create_oval(coords, outline=\"\", fill=RED)\n # - Bottom Right\n coords = WIDTH/2+21*SCALE, HEIGHT/2+23*SCALE, WIDTH/2+19*SCALE, HEIGHT/2+21*SCALE\n canvas.create_oval(coords, outline=\"\", fill=RED)\n\n\n canvas.grid(row=1, columnspan=5)","def RingPartition(ringsize, z, r, beta):\n # divide the ring into segments and initialise the coordinate of the segments\n location = list(range(ringsize))\n assert ringsize<=16 and ringsize>=5, \"Ring size greater than 16 or smaller than 5 is not supported\"\n if ringsize<=7 and ringsize>=5:\n segment1 = location[0:3]\n segment2 = location[2:-1]\n segment2.reverse()\n segment3 = location[-2:]+[location[0]]\n segment3.reverse()\n elif ringsize<=10 and ringsize>=8:\n segment1 = location[0:4]\n segment2 = location[3:-2]\n segment2.reverse()\n segment3 = location[-3:]+[location[0]]\n segment3.reverse()\n elif ringsize<=13 and ringsize>=11:\n segment1 = location[0:5]\n segment2 = location[4:-3]\n segment2.reverse()\n segment3 = location[-4:]+[location[0]]\n segment3.reverse()\n else: #ringsize<=16 and ringsize>=14:\n segment1 = location[0:6]\n segment2 = location[5:-4]\n segment2.reverse()\n segment3 = location[-5:] + [location[0]]\n segment3.reverse()\n segcoord_1_init = SegCoord(segment1, r, beta)\n segcoord_2_init = SegCoord(segment2, r, beta)\n segcoord_3_init = SegCoord(segment3, r, beta)\n Reflection = np.array((-1,1))\n OPsq = np.inner(segcoord_1_init[-1], segcoord_1_init[-1])\n PQsq = np.inner(segcoord_2_init[-1], segcoord_2_init[-1])\n OQsq = np.inner(segcoord_3_init[-1], segcoord_3_init[-1])\n segcoord_1 = [Reflection*item for item in segcoord_1_init]\n segcoord_2 = [x + np.sqrt((OQsq,0)) for x in segcoord_2_init]\n segcoord_3 = [np.array(x) for x in segcoord_3_init]\n # Link segment together\n xp = (OPsq+OQsq-PQsq)/(2*np.sqrt(OQsq))\n yp = np.sqrt(OPsq-np.square(xp))\n phi1, phi2, phi3 = np.arctan2(segcoord_1[-1][1],segcoord_1[-1][0]), np.arctan2(segcoord_2[-1][1], segcoord_2[-1][0]-np.sqrt(OQsq)), np.arctan2(segcoord_3[-1][1], segcoord_3[-1][0])\n phiseg1, phiseg2 = np.arctan2(yp,xp), np.arctan2(yp,xp-np.sqrt(OQsq))\n sigma1, sigma2, sigma3 = np.abs(phi1-phiseg1), np.abs(phiseg2-phi2), np.abs(phi3)\n Rsigma1, Rsigma2, Rsigma3 = RotationMatrix(-sigma1), RotationMatrix(sigma2), RotationMatrix(-sigma3)\n coordinate_1 = [np.array((0,0))]\n seg1_size = len(segcoord_1)\n for i in range(1,seg1_size-1):\n coordinate_1.append(np.matmul(Rsigma1,segcoord_1[i]))\n coordinate_1.append(np.array((xp,yp)))\n #### Check Here ####\n coordinate_2 = []\n seg2_size = len(segcoord_2)\n for i in range(seg2_size-2,0,-1):\n tmp = np.sqrt((OQsq,0))\n coordinate_2.append(tmp + np.matmul(Rsigma2, (segcoord_2[i]-tmp)))\n coordinate_3 = [np.sqrt((OQsq,0))]\n seg3_size = len(segcoord_3)\n for i in range(seg3_size-2,0,-1):\n coordinate_3.append(np.matmul(Rsigma3, segcoord_3[i]))\n coordinate = coordinate_1 + coordinate_2 + coordinate_3\n Rg = np.sum(coordinate,axis=0)\n phig = np.arctan2(Rg[1],Rg[0]) + np.pi/2\n Rphig = RotationMatrix(-phig) \n newcoord = [np.matmul(Rphig, coordinate[i]-Rg).tolist()+[z[i]] for i in range(ringsize)]\n origin = np.mean(newcoord,axis=0)\n finalcoord = np.array(newcoord)-origin\n return finalcoord","def __bcc_top_diagonals(self) -> cq.cq.Workplane:\n # In a cuboid ABCDA1B1C1D1 this is the angle C1AD\n #angle_C1AD = 90 - degrees(acos(2**-.5))\n angle_C1AD = 90 - degrees(acos(0.5))\n angle_CAD = 90 - degrees(acos(sqrt(2/3)))\n pseudo_unit_cell_size = sqrt(2/3)*self.unit_cell_size\n corner_points = np.array(\n [(0, 0),\n (self.bcc_unit_cell_size, 0),\n (self.bcc_unit_cell_size, self.unit_cell_size),\n (0, self.unit_cell_size)]\n )\n result = (\n cq.Workplane(\"XY\")\n .pushPoints(corner_points)\n .eachpointAdaptive(\n create_bcc_diagonal_strut,\n callback_extra_args = [\n {\"unit_cell_size\": 0.5 * pseudo_unit_cell_size,\n \"radius\": self.strut_radius,\n \"angle_x\": - angle_CAD,\n \"angle_y\": angle_C1AD},\n {\"unit_cell_size\": pseudo_unit_cell_size,\n \"radius\": self.strut_radius,\n \"angle_x\": - angle_CAD,\n \"angle_y\": - angle_C1AD},\n {\"unit_cell_size\": pseudo_unit_cell_size,\n \"radius\": self.strut_radius,\n \"angle_x\": angle_CAD,\n \"angle_y\": - angle_C1AD},\n {\"unit_cell_size\": 0.5 * pseudo_unit_cell_size,\n \"radius\": self.strut_radius,\n \"angle_x\": angle_CAD,\n \"angle_y\": angle_C1AD}\n ],\n useLocalCoords = True\n )\n )\n return result","def create_solids(self):\n\n plasma = self.create_plasma()\n pf_coils = self.create_pf_coils()\n tf_coil = self.create_tf_coils()\n vessel = self.create_vessel_components()\n\n shapes_and_components = plasma + pf_coils + vessel[:-1] + tf_coil\n self.shapes_and_components = shapes_and_components\n\n return shapes_and_components","def create_cylinders_volume(\n shape: (int, int, int),\n cylinders_list: list,\n foreground=1,\n dtype=np.uint8):\n volume = np.zeros(shape, dtype=bool)\n for point1, point2, radius in cylinders_list:\n volume = add_cylinder_px(volume, point1, point2, radius)\n return volume_bool_to_dtype(volume, fg=foreground, dtype=dtype)","def cleanOpenBranches(skeleton, skelton_copy, points, radii, length, clean = True, verbose = False):\n \n assert np.isfortran(skeleton);\n assert np.isfortran(skelton_copy);\n \n timer = tmr.Timer();\n timer_all = tmr.Timer();\n \n # find branch and end points\n deg = cpl.convolve_3d_indices(skeleton, t3d.n26, points, out_dtype = 'uint8');\n branchpoints = points[deg >= 3];\n e_pts = points[deg == 1];\n \n if verbose:\n timer.printElapsedTime('Detected %d branch and %d endpoints' % (branchpoints.shape[0], e_pts.shape[0]));\n timer.reset();\n \n #prepare temps\n #skel = skeleton.copy();\n skel_flat = np.reshape(skelton_copy, -1, order = 'A');\n strides = np.array(skelton_copy.strides);\n \n \n if verbose:\n timer.printElapsedTime('Detected %d branch and %d endpoints' % (branchpoints.shape[0], e_pts.shape[0]));\n timer.reset();\n \n label = np.arange(27);\n label = label.reshape([3,3,3]);\n label[1,1,1] = 0;\n \n critical_points = [e_pts];\n delete_points = [];\n \n for l in range(1, length + 1):\n #neighbours of end points\n e_pts_label = cpl.convolve_3d_indices(skelton_copy, label, e_pts);\n \n if verbose:\n timer.printElapsedTime('Done labeling %d / %d' % (l, length));\n timer.reset();\n \n #label zero points are non-critical short isolated branches\n e_pts_zero = e_pts_label == 0;\n #print 'zero length:', np.unravel_index(e_pts[e_pts_zero], skel.shape)\n if e_pts_zero.sum() > 0:\n keep = np.logical_not(e_pts_zero);\n for m in range(l):\n critical_points[m] = critical_points[m][keep];\n e_pts_label = e_pts_label[keep];\n e_pts = e_pts[keep];\n \n if verbose:\n timer.printElapsedTime('Ignored %d small branches' % (keep.sum()));\n timer.reset();\n \n e_pts_new = e_pts + np.sum((np.vstack(np.unravel_index(e_pts_label, label.shape)) - 1).T * strides, axis = 1)\n \n # did we hit a branch point\n delete = np.in1d(e_pts_new, branchpoints); #, assume_unique = True);\n keep = np.logical_not(delete);\n #print delete.shape, keep.shape, e_pts_new.shape\n \n #delete all path that hit a branch point\n if delete.sum() > 0:\n for m in range(l):\n delete_points.append(critical_points[m][delete]);\n #print 'deleting:', np.unravel_index(critical_points[m][delete], skel.shape)\n critical_points[m] = critical_points[m][keep];\n e_pts_new = e_pts_new[keep];\n \n if verbose:\n timer.printElapsedTime('Deleted %d points' % (delete.sum()));\n timer.reset();\n \n if l < length:\n skel_flat[e_pts] = False; # remove endpoints for new neighbour detection\n critical_points.append(e_pts_new);\n e_pts = e_pts_new;\n \n if verbose:\n timer.printElapsedTime('Cleanup iteration %d / %d done.' % (l, length));\n \n #gather all points\n if len(delete_points) > 0:\n delete_points = np.hstack(delete_points);\n delete_points = np.unique(delete_points);\n else:\n delete_points = np.zeros(0);\n \n if verbose:\n timer_all.printElapsedTime('Cleanup');\n \n if clean:\n skel_flat = np.reshape(skeleton, -1, order = 'F');\n skel_flat[delete_points] = False;\n keep_ids = np.logical_not(np.in1d(points, delete_points, assume_unique = True))\n points = points[keep_ids];\n radii = radii[keep_ids];\n return skeleton, points, radii\n \n return delete_points;","def __bcc_diagonals(self) -> cq.cq.Workplane:\n # In a cuboid ABCDA1B1C1D1 this is the angle C1AD\n #angle_C1AD = 90 - degrees(acos(2**-.5))\n angle_C1AD = 90 - degrees(acos(0.5))\n angle_CAD = 90 - degrees(acos(sqrt(2/3)))\n pseudo_unit_cell_size = sqrt(2/3)*self.unit_cell_size\n corner_points = np.array(\n [(0, 0),\n (self.bcc_unit_cell_size, 0),\n (self.bcc_unit_cell_size, self.unit_cell_size),\n (0, self.unit_cell_size)]\n )\n result = (\n cq.Workplane(\"XY\")\n .pushPoints(corner_points)\n .eachpointAdaptive(\n create_bcc_diagonal_strut,\n callback_extra_args = [\n {\"unit_cell_size\": pseudo_unit_cell_size,\n \"radius\": self.strut_radius,\n \"angle_x\": - angle_CAD,\n \"angle_y\": angle_C1AD},\n {\"unit_cell_size\": pseudo_unit_cell_size,\n \"radius\": self.strut_radius,\n \"angle_x\": - angle_CAD,\n \"angle_y\": - angle_C1AD},\n {\"unit_cell_size\": pseudo_unit_cell_size,\n \"radius\": self.strut_radius,\n \"angle_x\": angle_CAD,\n \"angle_y\": - angle_C1AD},\n {\"unit_cell_size\": pseudo_unit_cell_size,\n \"radius\": self.strut_radius,\n \"angle_x\": angle_CAD,\n \"angle_y\": angle_C1AD}\n ],\n useLocalCoords = True\n )\n )\n return result","def test_clip_points_by_polygons_with_holes_real(self):\n\n # Read real polygon with holes\n filename = '%s/%s' % (TESTDATA, 'donut.shp')\n L = read_layer(filename)\n\n # --------------------------------------------\n # Pick one polygon that has 2 inner rings\n P = L.get_geometry(as_geometry_objects=True)[1]\n\n outer_ring = P.outer_ring\n inner_ring0 = P.inner_rings[0]\n inner_ring1 = P.inner_rings[1]\n\n # Make some test points\n points_in_bbox = generate_random_points_in_bbox(outer_ring, 1000)\n points_in_inner_ring0 = populate_polygon(inner_ring0, 2, seed=13)\n points_in_inner_ring1 = populate_polygon(inner_ring1, 2, seed=17)\n points = numpy.concatenate((points_in_bbox,\n points_in_inner_ring0,\n points_in_inner_ring1))\n\n # Clip\n indices = inside_polygon(points, P.outer_ring, holes=P.inner_rings)\n\n # Sanity\n for point in points[indices, :]:\n # Must be inside outer ring\n assert is_inside_polygon(point, outer_ring)\n\n # But not in any of the inner rings\n assert not is_inside_polygon(point, inner_ring0)\n assert not is_inside_polygon(point, inner_ring1)\n\n # ---------------------------------------------------------\n # Pick a polygon that has 1 inner ring (nice visualisation)\n P = L.get_geometry(as_geometry_objects=True)[9]\n\n outer_ring = P.outer_ring\n inner_ring = P.inner_rings[0]\n\n # Make some test points\n points = generate_random_points_in_bbox(outer_ring, 500)\n\n # Clip\n indices = inside_polygon(points, P.outer_ring, holes=P.inner_rings)\n\n # Sanity\n for point in points[indices, :]:\n # Must be inside outer ring\n assert is_inside_polygon(point, outer_ring)\n\n # But not in the inner ring\n assert not is_inside_polygon(point, inner_ring)\n\n # Store for visual check (nice one!)\n # Uncomment os.remove if you want see the layers\n pol = Vector(geometry=[P])\n tmp_filename = unique_filename(suffix='.shp')\n pol.write_to_file(tmp_filename)\n #print 'Polygon with holes written to %s' % tmp_filename\n os.remove(tmp_filename)\n\n pts = Vector(geometry=points[indices, :])\n tmp_filename = unique_filename(suffix='.shp')\n pts.write_to_file(tmp_filename)\n #print 'Clipped points written to %s' % tmp_filename\n os.remove(tmp_filename)","def corridor(x,z, emap, width=10, length=10, height=10, details=None, walls=\"ns\", name=\"wall\", mergeshape=None):\r\n global wallnum\r\n n = z + width / 2\r\n s = z - width / 2\r\n e = x + length / 2\r\n w = x - length / 2\r\n\r\n solid_objects = []\r\n\r\n if \"n\" in walls:\r\n # TODO: abstract out the mostly-duplicate code in these cases...\r\n nwall = SolidObject(name+str(wallnum),\r\n Size(length, height, 1),\r\n Position(x, emap.calcHeight(x, z) + height / 2, n-0.5), 0)\r\n solid_objects.append(nwall)\r\n nwallmodel = createMyCuboid(nwall.w() * 2, nwall.h() * 2, nwall.d() * 2,\r\n name=name+str(wallnum),\r\n x=nwall.x(),y=nwall.y(),z=nwall.z(),\r\n rx=0.0, ry=0.0, rz=0.0, cx=0.0, cy=0.0, cz=0.0)\r\n if mergeshape:\r\n mergeshape.add(nwallmodel)\r\n else:\r\n nwall.setmodel(nwallmodel, details)\r\n\r\n\r\n wallnum += 1\r\n\r\n if \"s\" in walls:\r\n swall = SolidObject(name+str(wallnum), Size(length, height, 1), Position(x, emap.calcHeight(x, z)+height / 2, s+0.5), 0)\r\n solid_objects.append(swall)\r\n swallmodel = createMyCuboid(swall.w()*2, swall.h()*2, swall.d()*2,\r\n name=name+str(wallnum),\r\n x=swall.x(), y=swall.y(), z=swall.z(),\r\n rx=0.0, ry=0.0, rz=0.0, cx=0.0,cy=0.0, cz=0.0)\r\n if mergeshape:\r\n mergeshape.add(swallmodel)\r\n else:\r\n swall.setmodel(swallmodel, details)\r\n\r\n wallnum += 1\r\n\r\n if \"e\" in walls:\r\n ewall = SolidObject(name+str(wallnum), Size(1, height, width), Position(e-0.5, emap.calcHeight(x, z)+height / 2, z), 0)\r\n solid_objects.append(ewall)\r\n ewallmodel = createMyCuboid(ewall.w()*2, ewall.h()*2, ewall.d()*2,\r\n name=name+str(wallnum),\r\n x=ewall.x(), y=ewall.y(), z=ewall.z(),\r\n rx=0.0, ry=0.0, rz=0.0, cx=0.0, cy=0.0, cz=0.0)\r\n if mergeshape:\r\n mergeshape.add(ewallmodel)\r\n else:\r\n ewall.setmodel(ewallmodel, details)\r\n\r\n wallnum += 1\r\n\r\n if \"w\" in walls:\r\n wwall = SolidObject(name+str(wallnum), Size(1, height, width), Position(w+0.5, emap.calcHeight(x, z)+height / 2, z), 0)\r\n solid_objects.append(wwall)\r\n wwallmodel = createMyCuboid(wwall.w()*2, wwall.h()*2, wwall.d()*2,\r\n name=name+str(wallnum),\r\n x=wwall.x(), y=wwall.y(), z=wwall.z(),\r\n rx=0.0, ry=0.0, rz=0.0, cx=0.0, cy=0.0, cz=0.0)\r\n if mergeshape:\r\n mergeshape.add(wwallmodel)\r\n else:\r\n wwall.setmodel(wwallmodel, details)\r\n wallnum += 1\r\n\r\n if \"o\" not in walls:\r\n ceiling = SolidObject(name+str(wallnum), Size(length, 1, width), Position(x, emap.calcHeight(x, z)+height+0.5, z), 0)\r\n solid_objects.append(ceiling)\r\n ceilingmodel = createMyCuboid(ceiling.w()*2, ceiling.h()*2, ceiling.d()*2,\r\n name=name+str(wallnum),\r\n x=ceiling.x(), y=ceiling.y(), z=ceiling.z(),\r\n rx=0.0, ry=0.0, rz=0.0, cx=0.0, cy=0.0, cz=0.0)\r\n if mergeshape:\r\n mergeshape.add(ceilingmodel)\r\n else:\r\n ceiling.setmodel(ceilingmodel, details)\r\n\r\n wallnum += 1\r\n\r\n return solid_objects","def Cool_per_Grain(grain_size, grain_type, ZZ, fdist, ntot, xe, temp):\n import numpy as np\n import math\n import compute_charge_dist as fz\n \n tau = grain_size * fz.AAtocm * fz.kb * temp / fz.echarge**2\n \n # Loop over species!\n Cool_spec = 0\n for partner in [\"electron\", \"hydrogen\", \"carbon\"]:\n \n Cool_Zall = 0\n # Loop over charge\n for zi in range(len(ZZ)):\n \n if partner == \"electron\":\n nu = -1*ZZ[zi]\n stick_coef = fz.get_stickCoef(ZZ[zi], grain_size, grain_type)\n charge_frac = xe\n mass = fz.me\n \n elif partner == \"hydrogen\":\n nu = ZZ[zi]\n stick_coef = 1.0\n charge_frac = xe\n mass = fz.mH\n \n elif partner == \"carbon\":\n nu = ZZ[zi]\n stick_coef = 1.0\n # Maximum fraction of ionized Carbon is 1e-4*ntot.\n charge_frac = min(1.0e-4, xe)\n mass = fz.mC\n \n Cooltilde = 1.0\n \n if nu < 0:\n Cooltilde = fz.Jtilde_neg(tau, nu)\n elif nu == 0:\n Cooltilde = fz.Jtilde_0(tau, nu)\n else:\n Cooltilde = fz.Jtilde_pos(tau, nu)\n \n #print(zi)\n Cool_Zhere = fdist[zi]*Cooltilde*fz.kb*temp\n Cool_Zall += Cool_Zhere\n \n #print(\"Collisional Partner = \", partner)\n Cool_spec += ntot*charge_frac*stick_coef*np.sqrt(8.0*fz.kb*temp/(np.pi*mass))*Cool_Zall\n \n Cool_tot = math.pi * (grain_size*AAtocm)**2 * Cool_spec\n \n return Cool_tot","def unitQuad_Edge(lens, N=3):\n template = [ np.array([0,0]), np.array([lens[0], 0]), None, None ] #Template from which to generate other Quad Vertex Lists\n leftDegenerate = template.copy() #Left Limit of quad if you were to rotate edge 3 CCW about the origin until you no longer can\n rightDegenerate = template.copy() #Right Limit of quad if you were to rotate edge 2 CW about point 1 until you no longer can,\n # or alternatively, how far edge 3 can rotate CW until the quad is degenerate\n try:\n leftDegenerate[3] = np.array( circleIntersection(leftDegenerate[0], lens[3], leftDegenerate[1], lens[1]+lens[2]) )\n leftDegenerate[2] = ( lens[1] / (lens[2]+lens[1]) ) * (leftDegenerate[3]-leftDegenerate[1]) + leftDegenerate[1]\n except: \n leftDegenerate[3] = np.array([-lens[3],0])\n leftDegenerate[2] = np.array( circleIntersection(leftDegenerate[3], lens[2], leftDegenerate[1], lens[1]) )\n\n try:\n rightDegenerate[2] = np.array( circleIntersection(rightDegenerate[0], lens[2]+lens[3], rightDegenerate[1], lens[1]) )\n rightDegenerate[3] = ( lens[3] / (lens[3]+lens[2]) ) * rightDegenerate[2]\n except:\n rightDegenerate[2] = np.array([lens[0]+lens[1], 0])\n rightDegenerate[3] = np.array( circleIntersection(rightDegenerate[0], lens[3], rightDegenerate[2], lens[2]))\n \n rightOfOrigin = np.array([1,0]) #Theta = 0 on the Unit Circle\n thetaMin = angle_between(leftDegenerate[3], rightOfOrigin) #Angle of \n thetaMax = angle_between(rightDegenerate[3], rightOfOrigin)\n pitch = (thetaMax - thetaMin) / (N-1)\n\n result = []\n result.append(leftDegenerate) \n for i in range(1, N-1):\n result.append(template.copy())\n result[i][3] = lens[3]*unitCircPt(i*pitch+thetaMin)\n result[i][2] = np.array(circleIntersection( result[i][3], lens[2], result[i][1], lens[1]))\n result.append(rightDegenerate) \n\n return listify(result)","def _makeComponentPatch(component, position, cold):\n x = position[0]\n y = position[1]\n\n if isinstance(component, Helix):\n blockPatch = matplotlib.patches.Wedge(\n (\n x\n + component.getDimension(\"helixDiameter\", cold=cold)\n / 2\n * math.cos(math.pi / 6),\n y\n + component.getDimension(\"helixDiameter\", cold=cold)\n / 2\n * math.sin(math.pi / 6),\n ),\n component.getDimension(\"od\", cold=cold) / 2,\n 0,\n 360,\n width=(component.getDimension(\"od\", cold=cold) / 2)\n - (component.getDimension(\"id\", cold=cold) / 2),\n )\n elif isinstance(component, Circle):\n\n blockPatch = matplotlib.patches.Wedge(\n (x, y),\n component.getDimension(\"od\", cold=cold) / 2,\n 0,\n 360,\n width=(component.getDimension(\"od\", cold=cold) / 2)\n - (component.getDimension(\"id\", cold=cold) / 2),\n )\n elif isinstance(component, Hexagon):\n if component.getDimension(\"ip\", cold=cold) != 0:\n innerPoints = numpy.array(\n hexagon.corners(30) * component.getDimension(\"ip\", cold=cold)\n )\n outerPoints = numpy.array(\n hexagon.corners(30) * component.getDimension(\"op\", cold=cold)\n )\n blockPatch = []\n for n in range(6):\n corners = [\n innerPoints[n],\n innerPoints[(n + 1) % 6],\n outerPoints[(n + 1) % 6],\n outerPoints[n],\n ]\n patch = matplotlib.patches.Polygon(corners, fill=True)\n blockPatch.append(patch)\n else:\n # Just make it a hexagon...\n blockPatch = matplotlib.patches.RegularPolygon(\n (x, y), 6, component.getDimension(\"op\", cold=cold) / math.sqrt(3)\n )\n\n elif isinstance(component, Rectangle):\n if component.getDimension(\"widthInner\", cold=cold) != 0:\n innerPoints = numpy.array(\n [\n [\n x + component.getDimension(\"widthInner\", cold=cold) / 2,\n y + component.getDimension(\"lengthInner\", cold=cold) / 2,\n ],\n [\n x + component.getDimension(\"widthInner\", cold=cold) / 2,\n y - component.getDimension(\"lengthInner\", cold=cold) / 2,\n ],\n [\n x - component.getDimension(\"widthInner\", cold=cold) / 2,\n y - component.getDimension(\"lengthInner\", cold=cold) / 2,\n ],\n [\n x - component.getDimension(\"widthInner\", cold=cold) / 2,\n y + component.getDimension(\"lengthInner\", cold=cold) / 2,\n ],\n ]\n )\n\n outerPoints = numpy.array(\n [\n [\n x + component.getDimension(\"widthOuter\", cold=cold) / 2,\n y + component.getDimension(\"lengthOuter\", cold=cold) / 2,\n ],\n [\n x + component.getDimension(\"widthOuter\", cold=cold) / 2,\n y - component.getDimension(\"lengthOuter\", cold=cold) / 2,\n ],\n [\n x - component.getDimension(\"widthOuter\", cold=cold) / 2,\n y - component.getDimension(\"lengthOuter\", cold=cold) / 2,\n ],\n [\n x - component.getDimension(\"widthOuter\", cold=cold) / 2,\n y + component.getDimension(\"lengthOuter\", cold=cold) / 2,\n ],\n ]\n )\n blockPatch = []\n for n in range(4):\n corners = [\n innerPoints[n],\n innerPoints[(n + 1) % 4],\n outerPoints[(n + 1) % 4],\n outerPoints[n],\n ]\n patch = matplotlib.patches.Polygon(corners, fill=True)\n blockPatch.append(patch)\n else:\n # Just make it a rectangle...\n blockPatch = matplotlib.patches.Rectangle(\n (\n x - component.getDimension(\"widthOuter\", cold=cold) / 2,\n y - component.getDimension(\"lengthOuter\", cold=cold) / 2,\n ),\n component.getDimension(\"widthOuter\", cold=cold),\n component.getDimension(\"lengthOuter\", cold=cold),\n )\n if isinstance(blockPatch, list):\n return blockPatch\n return [blockPatch]","def test_clip_points_by_polygons_with_holes0(self):\n\n # Define an outer ring\n outer_ring = numpy.array([[106.79, -6.233],\n [106.80, -6.24],\n [106.78, -6.23],\n [106.77, -6.21],\n [106.79, -6.233]])\n\n # Define inner rings\n inner_rings = [numpy.array([[106.77827, -6.2252],\n [106.77775, -6.22378],\n [106.78, -6.22311],\n [106.78017, -6.22530],\n [106.77827, -6.2252]])[::-1],\n numpy.array([[106.78652, -6.23215],\n [106.78642, -6.23075],\n [106.78746, -6.23143],\n [106.78831, -6.23307],\n [106.78652, -6.23215]])[::-1]]\n\n v = Vector(geometry=[Polygon(outer_ring=outer_ring,\n inner_rings=inner_rings)])\n assert v.is_polygon_data\n\n # Write it to file\n tmp_filename = unique_filename(suffix='.shp')\n v.write_to_file(tmp_filename)\n\n # Read polygon it back\n L = read_layer(tmp_filename)\n P = L.get_geometry(as_geometry_objects=True)[0]\n\n outer_ring = P.outer_ring\n inner_ring0 = P.inner_rings[0]\n inner_ring1 = P.inner_rings[1]\n\n # Make some test points\n points = generate_random_points_in_bbox(outer_ring, 1000, seed=13)\n\n # Clip to outer ring, excluding holes\n indices = inside_polygon(points, P.outer_ring, holes=P.inner_rings)\n\n # Sanity\n for point in points[indices, :]:\n # Must be inside outer ring\n assert is_inside_polygon(point, outer_ring)\n\n # But not in any of the inner rings\n assert not is_inside_polygon(point, inner_ring0)\n assert not is_inside_polygon(point, inner_ring1)\n\n if False:\n # Store for visual check\n pol = Vector(geometry=[P])\n tmp_filename = unique_filename(suffix='.shp')\n pol.write_to_file(tmp_filename)\n print 'Polygon with holes written to %s' % tmp_filename\n\n pts = Vector(geometry=points[indices, :])\n tmp_filename = unique_filename(suffix='.shp')\n pts.write_to_file(tmp_filename)\n print 'Clipped points written to %s' % tmp_filename","def RemovePolygonHoles_management(in_fc, threshold=0.0):\n desc = arcpy.Describe(in_fc)\n if desc.dataType != \"FeatureClass\" and desc.dataType != \"ShapeFile\":\n print(\"Invalid data type. The input is supposed to be a Polygon FeatureClass or Shapefile.\")\n return\n else:\n if desc.shapeType != \"Polygon\":\n print(\"The input is supposed to be a Polygon FeatureClass or Shapefile.\")\n return\n if threshold < 0.0:\n threshold = 0.0\n with arcpy.da.UpdateCursor(in_fc, [\"SHAPE@\"]) as updateCursor:\n for updateRow in updateCursor:\n shape = updateRow[0]\n new_shape = arcpy.Array()\n for part in shape:\n new_part = arcpy.Array()\n if threshold > 0:\n # find None point in shape part\n # in arcpy module, a None point is used to seperate exterior and interior vertices\n null_point_index = []\n for i in range(len(part)):\n if part[i] is None:\n null_point_index.append(i)\n # if interior vertices exist, create polygons and compare polygon shape area to given threshold\n # if larger, keep vertices, else, dismiss them\n if len(null_point_index) > 0:\n for k in range(0, null_point_index[0]):\n new_part.add(part[k])\n for i in range(len(null_point_index)):\n pointArray = arcpy.Array()\n # determine if the None point is the last one\n if i+1 < len(null_point_index):\n for j in range(null_point_index[i] + 1, null_point_index[i+1]):\n pointArray.add(part[j])\n else:\n for j in range(null_point_index[i] + 1, len(part)):\n pointArray.add(part[j])\n # create a polygon to check shape area against the given threshold\n inner_poly = arcpy.Polygon(pointArray)\n # if larger than threshold, then add to the new part Array\n if inner_poly.area > threshold:\n if i+1 < len(null_point_index):\n for k in range(null_point_index[i], null_point_index[i+1]):\n new_part.add(part[k])\n else:\n for k in range(null_point_index[i], len(part)):\n new_part.add(part[k])\n new_shape.add(new_part)\n # if interior does not exist, add the whole part\n else:\n new_shape.add(part)\n else:\n # get the first None point index\n first_null_point_index = 0\n for i in range(len(part)):\n if part[i] is None:\n first_null_point_index = i\n break\n if first_null_point_index == 0:\n new_shape.add(part)\n else:\n for j in range(first_null_point_index):\n new_part.add(part[j])\n new_shape.add(new_part)\n if len(new_shape) > 0:\n new_poly = arcpy.Polygon(new_shape)\n updateRow[0] = new_poly\n updateCursor.updateRow(updateRow)","def is_ring(self): # -> bool:\n ...","def reset_shapes():\n if bpy.context.object.modeling_cloth:\n ob = bpy.context.object\n else: \n ob = extra_data['last_object']\n\n if ob.data.shape_keys == None:\n ob.shape_key_add('Basis') \n if 'modeling cloth source key' not in ob.data.shape_keys.key_blocks:\n ob.shape_key_add('modeling cloth source key') \n if 'modeling cloth key' not in ob.data.shape_keys.key_blocks:\n ob.shape_key_add('modeling cloth key') \n ob.data.shape_keys.key_blocks['modeling cloth key'].value=1\n \n keys = ob.data.shape_keys.key_blocks\n count = len(ob.data.vertices)\n co = np.zeros(count * 3, dtype=np.float32)\n keys['modeling cloth source key'].data.foreach_get('co', co)\n keys['modeling cloth key'].data.foreach_set('co', co)\n\n data[ob.name].vel *= 0\n \n ob.data.shape_keys.key_blocks['modeling cloth key'].mute = True\n ob.data.shape_keys.key_blocks['modeling cloth key'].mute = False","def make_tight_box(self, tightness: float = 0.33) -> None:\r\n\r\n # Default to the plant's original box\r\n x1 = self.box[0]\r\n y1 = self.box[1]\r\n x2 = self.box[2]\r\n y2 = self.box[3]\r\n\r\n ## Find y coordinates\r\n # Initialize variables and sort pixels by x coordinate\r\n width = self.box[2] - self.box[0]\r\n cents = sorted(self.cluster, key = lambda u: u[1])\r\n clust = []\r\n curr = cents[0][1]\r\n last = 0\r\n\r\n # Split the pixels by x coordinate\r\n for p in range(len(cents)):\r\n if cents[p][1] != curr:\r\n clust.append(cents[last: p])\r\n curr = cents[p][1]\r\n last = p\r\n \r\n # Get the topmost y value which is <tightness> green\r\n for hor in clust:\r\n if len(hor) / width > tightness:\r\n y1 = hor[0][1]\r\n break\r\n\r\n # Get the bottommost y value which is <tightness> green\r\n for hor in clust[::-1]:\r\n if len(hor) / width > tightness:\r\n y2 = hor[0][1]\r\n break\r\n\r\n ## Find x coordinates\r\n # Initialize variables and sort pixels by y coordinate\r\n height = self.box[3] - self.box[1]\r\n cents = sorted(self.cluster, key = lambda u: u[0])\r\n clust = []\r\n curr = cents[0][0]\r\n last = 0\r\n\r\n # Split the pixels by y coordinate\r\n for p in range(len(cents)):\r\n if cents[p][0] != curr:\r\n clust.append(cents[last: p])\r\n curr = cents[p][0]\r\n last = p\r\n\r\n # Get the leftmost x value which is <tightness> green\r\n for ver in clust:\r\n if len(ver) / height > tightness:\r\n x1 = ver[0][0]\r\n break\r\n\r\n # Get the rightmost x value which is <tightness> green\r\n for ver in clust[::-1]:\r\n if len(ver) / height > tightness:\r\n x2 = ver[0][0]\r\n break\r\n\r\n # Default to original x values if no better estimate was found\r\n if x1 == x2:\r\n x1 = self.box[0]\r\n x2 = self.box[2]\r\n\r\n # Default to original y values if no better estimate was found\r\n if y1 == y2:\r\n y1 = self.box[1]\r\n y2 = self.box[3]\r\n\r\n self.tight_box = (x1, y1, x2, y2)","def cliques_on_ring(cliques,labels,G, cut=0):\n print(\"cliques_on_ring CUT:\", cut)\n #if partitions\n if cut > 1:\n partitions = get_partitions(cliques,cut)\n for partition in partitions:\n if len(partition) > 1:\n n1 = random.choice(partition[0])\n for idx,clique in enumerate(partition):\n if idx > 0:# and idx not in cuts:\n candidates = [n for n in clique if labels[n.id] != labels[n1.id]]\n candidates = candidates if len(candidates) > 0 else clique\n n2 = random.choice(candidates)\n G.add_edge(n1,n2)\n n1 = random.choice(clique)\n\n else:\n n1 = random.choice(cliques[0]) \n for idx,clique in enumerate(cliques):\n if idx > 0:# and idx not in cuts:\n candidates = [n for n in clique if labels[n.id] != labels[n1.id]]\n candidates = candidates if len(candidates) > 0 else clique\n n2 = random.choice(candidates)\n G.add_edge(n1,n2)\n n1 = random.choice(clique)\n \n #Attach head and tail cliques\n candidates = [n for n in cliques[0] if labels[n.id] != labels[n1.id]]\n candidates = candidates if len(candidates) > 0 else cliques[0]\n n2 = random.choice(candidates)\n G.add_edge(n1,n2)","def make_flower(shape, x, y, c1, c2, l, s):\n shape.penup()\n shape.speed(20)\n shape.setpos(x, y)\n shape.color(c2, c1)\n shape.begin_fill()\n shape.pendown()\n for side in range(6):\n shape.left(60)\n shape.forward(s) # s stands for short side\n shape.right(60)\n shape.forward(l) # l stands for long side\n shape.right(60)\n shape.forward(s)\n shape.right(60)\n shape.forward(s)\n shape.right(60)\n shape.forward(l)\n shape.right(60)\n shape.forward(s)\n shape.right(60)\n shape.end_fill()\n shape.pendown()\n\n shape.color(\"green\")\n shape.right(90)\n shape.penup()\n shape.forward(10)\n shape.pendown()\n shape.forward(110)\n shape.left(90)\n\n\n\n # ...","def generatePolygons():","def make_circle_fill():\n num_points = 40\n batch = pyglet.graphics.Batch()\n rad = math.pi * 2 / num_points # getting 360 / n in radians\n index = list(itertools.chain.from_iterable( (0, x-1, x) for x in range(2, num_points+1) ))\n index += [0, 1, num_points] # end of fan\n vertices = [0, 0] # adding center of fan\n for i in range(1, num_points + 1):\n angle = rad * i\n vertices += [math.cos(angle), math.sin(angle)]\n vertices += [1, 0] # adding end of fan\n circle = pyglet.graphics.vertex_list_indexed(num_points+2, index, ('v2f', vertices))\n return circle","def grating_coupler_circular(\n taper_angle: float = 30.0,\n taper_length: float = 10.0,\n length: float = 30.0,\n period: float = 1.0,\n fill_factor: float = 0.7,\n n_periods: int = 30,\n bias_gap: float = 0,\n port: Coordinate = (0.0, 0.0),\n layer_slab: Optional[LayerSpec] = None,\n layer_cladding: LayerSpec = \"WGCLAD\",\n gaps: Optional[Floats] = None,\n widths: Optional[Floats] = None,\n direction: str = \"EAST\",\n polarization: str = \"te\",\n wavelength: float = 1.55,\n fiber_marker_width: float = 11.0,\n fiber_marker_layer: Optional[LayerSpec] = \"TE\",\n cladding_offset: float = 2.0,\n cross_section: CrossSectionSpec = \"strip\",\n **kwargs,\n) -> Component:\n x = gf.get_cross_section(cross_section, **kwargs)\n layer = x.layer\n wg_width = x.width\n\n widths = widths or n_periods * [period * fill_factor]\n gaps = gaps or n_periods * [period * (1 - fill_factor)]\n\n gaps = np.array(gaps) + bias_gap\n widths = np.array(widths) - bias_gap\n teeth_list = list(zip(gaps, widths))\n\n layer = gf.get_layer(layer)\n layer_slab = gf.get_layer(layer_slab)\n layer_cladding = gf.get_layer(layer_cladding)\n\n c = pc.GratingCoupler(\n gf.call_if_func(\n strip,\n cladding_offset=cladding_offset,\n wg_width=wg_width,\n layer=layer,\n layer_cladding=layer_cladding,\n ),\n theta=np.deg2rad(taper_angle),\n length=length,\n taper_length=taper_length,\n period=period,\n dutycycle=fill_factor,\n ridge=bool(layer_slab),\n ridge_layers=layer_slab,\n teeth_list=teeth_list,\n port=port,\n direction=direction,\n )\n\n c = gf.read.from_picwriter(c)\n c.info[\"polarization\"] = polarization\n c.info[\"wavelength\"] = wavelength\n c.ports[\"o1\"].cross_section = x\n\n fiber_xoffset = np.round(c.center[0] + taper_length / 2, 3)\n\n if fiber_marker_layer:\n circle = gf.components.circle(\n radius=fiber_marker_width / 2, layer=fiber_marker_layer\n )\n circle_ref = c.add_ref(circle)\n circle_ref.movex(fiber_xoffset)\n\n c.add_port(\n name=f\"vertical_{polarization.lower()}\",\n center=[fiber_xoffset, 0],\n width=fiber_marker_width,\n orientation=0,\n layer=fiber_marker_layer,\n )\n if x.add_bbox:\n c = x.add_bbox(c)\n if x.add_pins:\n c = x.add_pins(c)\n return c","def test_comb(pad_size = (200, 200), wire_width = 1, wire_gap = 3,\n comb_layer = 0, overlap_zigzag_layer = 1,\n comb_pad_layer = 2, comb_gnd_layer = 3,\n overlap_pad_layer = 4):\n CI = Device(\"test_comb\")\n\n # if comb_pad_layer is None: comb_pad_layer = comb_layer\n # if comb_gnd_layer is None: comb_gnd_layer = comb_layer\n # if overlap_pad_layer is None: overlap_pad_layer = overlap_zigzag_layer\n wire_spacing = wire_width + wire_gap*2\n\n # pad overlays\n overlay_padb = CI.add_ref(rectangle(size = (pad_size[0]*9 / 10,\n pad_size[1]*9 / 10),\n layer = overlap_pad_layer))\n overlay_padl = CI.add_ref(rectangle(size = (pad_size[0]*9 / 10,\n pad_size[1]*9 / 10),\n layer = comb_pad_layer))\n overlay_padt = CI.add_ref(rectangle(size = (pad_size[0]*9 / 10,\n pad_size[1]*9 / 10),\n layer = comb_pad_layer))\n overlay_padr = CI.add_ref(rectangle(size = (pad_size[0]*9 / 10,\n pad_size[1]*9 / 10),\n layer = comb_gnd_layer))\n overlay_padl.xmin = 0\n overlay_padl.ymin = 0\n overlay_padb.ymax = 0\n overlay_padb.xmin = overlay_padl.xmax + pad_size[1]/5\n overlay_padr.ymin = overlay_padl.ymin\n overlay_padr.xmin = overlay_padb.xmax + pad_size[1]/5\n overlay_padt.xmin = overlay_padl.xmax + pad_size[1]/5\n overlay_padt.ymin = overlay_padl.ymax\n\n # pads\n padl = CI.add_ref(rectangle(size = pad_size, layer = comb_layer))\n padt = CI.add_ref(rectangle(size = pad_size, layer = comb_layer))\n padr = CI.add_ref(rectangle(size = pad_size, layer = comb_layer))\n padb = CI.add_ref(rectangle(size = pad_size, layer = overlap_zigzag_layer))\n padl_nub = CI.add_ref(rectangle(size = (pad_size[0]/4,\n pad_size[1]/2),\n layer = comb_layer))\n padr_nub = CI.add_ref(rectangle(size = (pad_size[0]/4,\n pad_size[1]/2),\n layer = comb_layer))\n padl.xmin = overlay_padl.xmin\n padl.center = [padl.center[0], overlay_padl.center[1]]\n padt.ymax = overlay_padt.ymax\n padt.center = [overlay_padt.center[0], padt.center[1]]\n padr.xmax = overlay_padr.xmax\n padr.center = [padr.center[0], overlay_padr.center[1]]\n padb.ymin = overlay_padb.ymin\n padb.center = [overlay_padb.center[0], padb.center[1]]\n padl_nub.xmin = padl.xmax\n padl_nub.center = [padl_nub.center[0], padl.center[1]]\n padr_nub.xmax = padr.xmin\n padr_nub.center = [padr_nub.center[0], padr.center[1]]\n\n # connected zig\n head = CI.add_ref(compass(size = (pad_size[0]/12, wire_width),\n layer = comb_layer))\n head.xmin = padl_nub.xmax\n head.ymax = padl_nub.ymax\n connector = CI.add_ref(compass(size = (wire_width, wire_width),\n layer = comb_layer))\n connector.connect(port = 'W', destination = head.ports['E'])\n old_port = connector.ports['S']\n top = True\n obj = connector\n while(obj.xmax + pad_size[0]/12 < padr_nub.xmin):\n # long zig zag rectangle\n obj = CI.add_ref(compass(size = (pad_size[1]/2 - 2*wire_width,\n wire_width),\n layer = comb_layer))\n obj.connect(port = 'W', destination = old_port)\n old_port = obj.ports['E']\n if(top):\n # zig zag edge rectangle\n obj = CI.add_ref(compass(size = (wire_width, wire_width),\n layer = comb_layer))\n obj.connect(port = 'N', destination = old_port)\n top = False\n else:\n # zig zag edge rectangle\n obj = CI.add_ref(compass(size = (wire_width, wire_width),\n layer = comb_layer))\n obj.connect(port = 'S', destination = old_port)\n top = True\n # comb rectange\n comb = CI.add_ref(rectangle(\n size = ((padt.ymin - head.ymax) + pad_size[1]/2 \\\n - (wire_spacing + wire_width)/2, wire_width),\n layer = comb_layer))\n comb.rotate(90)\n comb.ymax = padt.ymin\n comb.xmax = obj.xmax - (wire_spacing + wire_width)/2\n old_port = obj.ports['E']\n obj = CI.add_ref(compass(size = (wire_spacing, wire_width),\n layer = comb_layer))\n obj.connect(port = 'W', destination = old_port)\n old_port = obj.ports['E']\n obj = CI.add_ref(compass(size = (wire_width, wire_width),\n layer = comb_layer))\n obj.connect(port = 'W', destination = old_port)\n if(top): old_port = obj.ports['S']\n else: old_port = obj.ports['N']\n old_port = obj.ports['E']\n if(padr_nub.xmin-obj.xmax > 0):\n tail = CI.add_ref(compass(size = (padr_nub.xmin-obj.xmax, wire_width),\n layer = comb_layer))\n else:\n tail = CI.add_ref(compass(size = (wire_width, wire_width),\n layer = comb_layer))\n tail.connect(port = 'W', destination = old_port)\n\n # disconnected zig\n dhead = CI.add_ref(compass(size = (padr_nub.ymin - padb.ymax - wire_width,\n wire_width),\n layer = overlap_zigzag_layer))\n dhead.rotate(90)\n dhead.ymin = padb.ymax\n dhead.xmax = tail.xmin - (wire_spacing+wire_width)/2\n connector = CI.add_ref(compass(size = (wire_width, wire_width),\n layer = overlap_zigzag_layer))\n connector.connect(port = 'S', destination = dhead.ports['E'])\n old_port = connector.ports['N']\n right = True\n obj = connector\n while(obj.ymax + wire_spacing + wire_width < head.ymax):\n obj = CI.add_ref(compass(size = (wire_spacing, wire_width),\n layer = overlap_zigzag_layer))\n obj.connect(port = 'W', destination = old_port)\n old_port = obj.ports['E']\n if(right):\n obj = CI.add_ref(compass(size = (wire_width, wire_width),\n layer = overlap_zigzag_layer))\n obj.connect(port = 'W', destination = old_port)\n right = False\n else:\n obj = CI.add_ref(compass(size = (wire_width, wire_width),\n layer = overlap_zigzag_layer))\n obj.connect(port = 'E', destination = old_port)\n right = True\n old_port = obj.ports['N']\n obj = CI.add_ref(compass(\n size = (dhead.xmin - (head.xmax+head.xmin+wire_width)/2,\n wire_width),\n layer = overlap_zigzag_layer))\n obj.connect(port = 'E', destination = old_port)\n old_port = obj.ports['W']\n obj = CI.add_ref(compass(size = (wire_width, wire_width),\n layer = overlap_zigzag_layer))\n obj.connect(port = 'S', destination = old_port)\n if(right):\n old_port = obj.ports['W']\n else:\n old_port = obj.ports['E']\n\n return CI","def C(width = 1, size = (10, 20), layer = 0):\n D = Device(name = 'C')\n w = width/2\n s1, s2 = size\n points = [(-w, -w), (s1, -w), (s1, w), (w, w), (w, s2-w),\n (s1, s2-w), (s1, s2+w), (-w, s2+w), (-w, -w)]\n D.add_polygon(points, layer = layer)\n D.add_port(name = 1, midpoint = (s1, s2), width = width, orientation = 0)\n D.add_port(name = 2, midpoint = (s1, 0), width = width, orientation = 0)\n return D","def add_cable(self, env, size_range, info={}, cable_idx=0,\n direction='z', max_force=100):\n num_parts = self.num_parts\n radius = self.radius\n length = self.length\n color = self.colors[cable_idx] + [1]\n color_end = U.COLORS['yellow'] + [1]\n\n # Add beaded cable.\n distance = length / num_parts\n position, _ = self.random_pose(env, size_range)\n position = np.float32(position)\n part_shape = p.createCollisionShape(p.GEOM_BOX, halfExtents=[radius]*3)\n part_visual = p.createVisualShape(p.GEOM_SPHERE, radius=radius*1.5)\n\n # Iterate through parts and create constraints as needed.\n for i in range(num_parts):\n if direction == 'x':\n position[0] += distance\n parent_frame = (distance, 0, 0)\n elif direction == 'y':\n position[1] += distance\n parent_frame = (0, distance, 0)\n else:\n position[2] += distance\n parent_frame = (0, 0, distance)\n\n part_id = p.createMultiBody(0.1, part_shape, part_visual,\n basePosition=position)\n if i > 0:\n constraint_id = p.createConstraint(\n parentBodyUniqueId=env.objects[-1],\n parentLinkIndex=-1,\n childBodyUniqueId=part_id,\n childLinkIndex=-1,\n jointType=p.JOINT_POINT2POINT,\n jointAxis=(0, 0, 0),\n parentFramePosition=parent_frame,\n childFramePosition=(0, 0, 0))\n p.changeConstraint(constraint_id, maxForce=max_force)\n\n if (i > 0) and (i < num_parts - 1):\n p.changeVisualShape(part_id, -1, rgbaColor=color)\n elif i == num_parts - 1:\n p.changeVisualShape(part_id, -1, rgbaColor=color_end)\n\n # The usual for tracking IDs. Four things to add.\n self.cable_bead_IDs.append(part_id)\n self._IDs[part_id] = f'cable_part_{str(part_id).zfill(2)}'\n env.objects.append(part_id)\n self.object_points[part_id] = np.float32((0, 0, 0)).reshape(3, 1)\n\n # Get target placing positions for each cable bead, if applicable.\n if self._name == 'cable-shape' or self._name == 'cable-shape-notarget' or \\\n self._name == 'cable-line-notarget':\n # ----------------------------------------------------------- #\n # Here, zone_pose = square_pose, unlike Ravens cable, where the\n # zone_pose is shifted so that its center matches the straight\n # line segment center. For `true_position`, we use `zone_pose`\n # but apply the correct offset to deal with the sides. Note\n # that `length` is the size of a fully smoothed cable, BUT we\n # made a rectangle with each side <= length.\n # ----------------------------------------------------------- #\n lx = info['lengthx']\n ly = info['lengthy']\n r = radius\n\n if info['nb_sides'] == 1:\n # Here it's just a straight line on the 'lx' side.\n x_coord = lx / 2 - (distance * i)\n y_coord = 0\n true_position = (x_coord - r, y_coord, 0)\n\n elif info['nb_sides'] == 2:\n # Start from lx side, go 'left' to the pivot point, then on\n # the ly side, go 'upwards' but offset by `i`. For radius\n # offset, I just got this by tuning. XD\n if i < info['cutoff']:\n x_coord = lx / 2 - (distance * i)\n y_coord = -ly / 2\n true_position = (x_coord - r, y_coord, 0)\n else:\n x_coord = -lx / 2\n y_coord = -ly / 2 + (distance * (i - info['cutoff']))\n true_position = (x_coord, y_coord + r, 0)\n\n elif info['nb_sides'] == 3:\n # Start from positive lx, positive ly, go down to first\n # pivot. Then go left to the second pivot, then up again.\n # For v1, division by two is because we assume BOTH of the\n # 'ly edges' were divided by two.\n v1 = (self.num_parts - info['cutoff']) / 2\n v2 = self.num_parts - v1\n if i < v1:\n x_coord = lx / 2\n y_coord = ly / 2 - (distance * i)\n true_position = (x_coord, y_coord - r, 0)\n elif i < v2:\n x_coord = lx / 2 - (distance * (i - v1))\n y_coord = -ly / 2\n true_position = (x_coord - r, y_coord, 0)\n else:\n x_coord = -lx / 2\n y_coord = -ly / 2 + (distance * (i - v2))\n true_position = (x_coord, y_coord + r, 0)\n\n elif info['nb_sides'] == 4:\n # I think this is similar to the 2-side case: we start in\n # the same direction and go counter-clockwise.\n v1 = info['cutoff'] / 2\n v2 = num_parts / 2\n v3 = (num_parts + info['cutoff']) / 2\n if i < v1:\n x_coord = lx / 2 - (distance * i)\n y_coord = -ly / 2\n true_position = (x_coord, y_coord, 0)\n elif i < v2:\n x_coord = -lx / 2\n y_coord = -ly / 2 + (distance * (i - v1))\n true_position = (x_coord, y_coord, 0)\n elif i < v3:\n x_coord = -lx / 2 + (distance * (i - v2))\n y_coord = ly / 2\n true_position = (x_coord, y_coord, 0)\n else:\n x_coord = lx / 2\n y_coord = ly / 2 - (distance * (i - v3))\n true_position = (x_coord, y_coord, 0)\n\n # Map true_position onto the workspace from zone_pose.\n true_position = self.apply(self.zone_pose, true_position)\n\n # See `cable.py`: just get the places and steps set.\n self.goal['places'][part_id] = (true_position, (0, 0, 0, 1.))\n symmetry = 0\n self.goal['steps'][0][part_id] = (symmetry, [part_id])\n\n # Debugging target zones.\n if self.target_debug_markers:\n sq_pose = ((true_position[0], true_position[1], 0.002), (0,0,0,1))\n sq_template = 'assets/square/square-template-allsides-blue.urdf'\n replace = {'DIM': (0.003,), 'HALF': (0.003 / 2,)}\n urdf = self.fill_template(sq_template, replace)\n env.add_object(urdf, sq_pose, fixed=True)\n os.remove(urdf)\n else:\n print(f'Warning, env {self._name} will not have goals.')","def drawShapes(self):\n self.draw_polygon(self.poly3.get_points() , color = \"#000\")\n self.draw_polygon(self.poly2.get_points() , color = \"#000\")\n self.draw_polygon(self.poly1.get_points() , color = \"#000\")\n self.draw_rect(0, 0, self.width, self.height, color= \"#000\")\n \"\"\"These statements are used to determine if a point is inside any of the\n 3 polygons and if so changes the point's color\"\"\"\n if (self.poly2.point_inside_polygon(self.p1) or self.poly1.point_inside_polygon(self.p1)\n or self.poly3.point_inside_polygon(self.p1)):\n color = \"#0F0\"\n else:\n color = \"#F00\"\n self.fill_oval(self.p1.x, self.p1.y, 7, 7, color)\n\n if (self.poly2.point_inside_polygon(self.p2) or self.poly1.point_inside_polygon(self.p2)\n or self.poly3.point_inside_polygon(self.p2)):\n color = \"#0F0\"\n else:\n color = \"#F00\"\n self.fill_oval(self.p2.x, self.p2.y, 7, 7, color)\n if (self.poly2.point_inside_polygon(self.p3) or self.poly1.point_inside_polygon(self.p3)\n or self.poly3.point_inside_polygon(self.p3)):\n color = \"#0F0\"\n else:\n color = \"#F00\"\n self.fill_oval(self.p3.x, self.p3.y, 7, 7, color)","def ring(radius = 10, width = 0.5, angle_resolution = 2.5, layer = 0):\n D = Device(name = 'ring')\n inner_radius = radius - width/2\n outer_radius = radius + width/2\n n = int(np.round(360/angle_resolution))\n t = np.linspace(0, 360, n+1) * pi/180\n inner_points_x = (inner_radius*cos(t)).tolist()\n inner_points_y = (inner_radius*sin(t)).tolist()\n outer_points_x = (outer_radius*cos(t)).tolist()\n outer_points_y = (outer_radius*sin(t)).tolist()\n xpts = inner_points_x + outer_points_x[::-1]\n ypts = inner_points_y + outer_points_y[::-1]\n D.add_polygon(points = (xpts, ypts), layer = layer)\n return D","def poly_enclose(points, color, inc=1.2, rad=0.3, lw=2):\n points = np.log(points)\n hull = ConvexHull(points)\n\n cent = np.mean(points, 0)\n pts = []\n for pt in points[hull.simplices]:\n pts.append(pt[0].tolist())\n pts.append(pt[1].tolist())\n \n pts.sort(key=lambda p: np.arctan2(p[1] - cent[1],\n p[0] - cent[0]))\n pts = pts[0::2] # Deleting duplicates\n pts.insert(len(pts), pts[0])\n \n \n verts = inc*(np.array(pts)- cent) + cent\n verts2 = np.zeros((3*verts.shape[0]-2,2))\n verts2[0::3] = verts\n verts2[1::3,:] = (1-rad)*verts[0:-1,:] + rad*verts[1:,:]\n verts2[2::3,:] = rad*verts[0:-1,:] + (1-rad)*verts[1:,:]\n verts2[0:-1] = verts2[1:]\n verts2[-1] = verts2[0]\n\n\n \n codes = [Path.MOVETO, Path.LINETO, Path.CURVE3,]\n for j in range(len(pts)-2):\n codes.extend([Path.CURVE3, Path.LINETO, Path.CURVE3,])\n codes.append(Path.CURVE3)\n \n \n path = Path(verts2, codes)\n patch = patches.PathPatch(path, facecolor=color, lw=0, alpha=0.2)\n edge = patches.PathPatch(path, edgecolor=color, facecolor='none', lw=lw)\n patch._path._vertices = np.exp(patch._path._vertices)\n return patch, edge","def boundaries_and_initialize():\n greenLower = (29, 86, 6) # define the lower and upper boundaries of the \"green\"\n greenUpper = (64, 255, 255)\n pts = [((200,300),(255,255,255), 0)]\n blanks = []\n linecolor = (0,0,0)\n counter = 1\n radius = 11\n return greenLower, greenUpper, pts, linecolor, counter, blanks, radius","def create_ring(self):\n\t\tself.north_coords = numpy.add(self.center, self.north)\n\t\tself.northeast_coords = numpy.add(self.center, self.northeast)\n\t\tself.east_coords = numpy.add(self.center, self.east)\n\t\tself.southeast_coords = numpy.add(self.center, self.southeast)\n\t\tself.south_coords = numpy.add(self.center, self.south)\n\t\tself.southwest_coords = numpy.add(self.center, self.southwest)\n\t\tself.west_coords = numpy.add(self.center, self.west)\n\t\tself.northwest_coords = numpy.add(self.center, self.northwest)","def store_horiz_points_clean(self, ring_points, display_opt):\n plane_colors = [(0, 255, 0), (0, 0, 255), (0.9100, 0.4100, 0.1700)] #4,2,3\n\n num_ring_pts = len(ring_points)\n\n # declare arrays for storage ..\n landmarks = []\n landmarks_2chs = []\n landmarks_4chs = []\n\n y = []\n y_2ch = []\n y_4ch = []\n\n # find top and low pts for the 2ch and 4ch views at the ideal angles\n _, _, highest_2ch_orig, _ = self.find_top_low_pts3([self.orig_cut_poly_array[1][0],self.orig_cut_poly_array[1][1]])\n _, _, highest_4ch_orig, _ = self.find_top_low_pts3([self.orig_cut_poly_array[0][0],self.orig_cut_poly_array[0][1]])\n\n for (i, offset_2ch) in enumerate(ring_points):\n offset_pt_2ch = np.asarray(offset_2ch)\n\n two_ch_view_plane_normal = find_plane_eq(offset_pt_2ch, highest_2ch_orig[0], highest_2ch_orig[1])\n\n cutPoly_2ch, _ = self.get_edges_strips(two_ch_view_plane_normal, offset_pt_2ch,\n \"2ch ring_pt index = \" + str(i), self.plane_colors[1])\n\n lowest_point_2ch, lowest_point_2ch_idx, highest_points_2ch, sorted_pts_endo_epi = self.find_top_low_pts3([cutPoly_2ch[0], cutPoly_2ch[1]])\n\n horiz_2ch_a, horiz_2ch_b = self.get_landmarks(sorted_pts_endo_epi[0], lowest_point_2ch_idx, 0)\n\n landmarks_3D = np.concatenate((horiz_2ch_a, np.flip(horiz_2ch_b, 0)))\n\n # remember to add the lowest point\n current_np = len(landmarks_3D)\n idx = int(np.floor(current_np/2.0)) # find middle index\n landmarks_3D = np.insert(landmarks_3D, idx, lowest_point_2ch, axis=0)\n landmarks_2D = project_onto_xy_plane(landmarks_3D)\n landmarks_2chs.append(landmarks_2D)\n\n # now assess volume for labels\n horiz_2ch_dists, horiz_4ch_dists = self.compute_horizontal_distances(horiz_2ch_a, horiz_2ch_b,\n self.ideal_horiz_4ch_a,\n self.ideal_horiz_4ch_b)\n\n # set L = length of LV cavity (choose longest from 2ch or 4ch)\n L = get_length_of_LV_cavity(horiz_2ch_a, horiz_2ch_b,\n self.ideal_horiz_4ch_a, self.ideal_horiz_4ch_b,\n lowest_point_2ch, self.ideal_lowest_point_4ch)\n\n # compute percentage error\n vol = self.Simpson_bp(horiz_2ch_dists, horiz_4ch_dists, L)\n abs_error_vol = np.abs(vol - self.ideal_vol) # make all errors positive\n perc_err = 100.0*(abs_error_vol/self.ideal_vol)\n\n if perc_err > 5.0:\n y_2ch.append(int(1))\n else:\n y_2ch.append(int(0))\n\n landmarks.append(landmarks_2chs)\n y.append(y_2ch)\n\n for (i, offset_4ch) in enumerate(ring_points):\n offset_pt_4ch = np.asarray(offset_4ch)\n\n four_ch_view_plane_normal = find_plane_eq(offset_pt_4ch, highest_4ch_orig[0], highest_4ch_orig[1])\n\n cutPoly_4ch, _ = self.get_edges_strips(four_ch_view_plane_normal, offset_pt_4ch,\n \"4ch = \" + str(i), plane_colors[0])\n\n lowest_point_4ch, lowest_point_4ch_idx, highest_points_4ch, sorted_pts_endo_epi = self.find_top_low_pts3([cutPoly_4ch[0], cutPoly_4ch[1]])\n\n horiz_4ch_a, horiz_4ch_b = self.get_landmarks(sorted_pts_endo_epi[0], lowest_point_4ch_idx, 0)\n\n landmarks_3D = np.concatenate((horiz_4ch_a, np.flip(horiz_4ch_b, 0)))\n\n # dont forget to add the type I landmarks (lowest points)\n current_np = len(landmarks_3D)\n idx = int(np.floor(current_np/2.0))\n landmarks_3D = np.insert(landmarks_3D, idx, lowest_point_4ch, axis=0)\n landmarks_2D = project_onto_xy_plane(landmarks_3D)\n landmarks_4chs.append(landmarks_2D)\n\n # now asssess volume for labels\n horiz_2ch_dists, horiz_4ch_dists = self.compute_horizontal_distances(self.ideal_horiz_2ch_a,\n self.ideal_horiz_2ch_b,\n horiz_4ch_a,\n horiz_4ch_b)\n\n # set L = length of LV cavity (choose longest from 2ch or 4ch)\n L = get_length_of_LV_cavity(self.ideal_horiz_2ch_a, self.ideal_horiz_2ch_b,\n horiz_4ch_a, horiz_4ch_b,\n self.ideal_lowest_point_2ch, lowest_point_4ch)\n\n # compute percentage error\n vol = self.Simpson_bp(horiz_2ch_dists, horiz_4ch_dists, L)\n abs_error_vol = np.abs(vol - self.ideal_vol) # make all errors positive\n perc_err = 100.0*(abs_error_vol/self.ideal_vol)\n\n if perc_err > 5.0:\n y_4ch.append(int(1))\n else:\n y_4ch.append(int(0))\n\n landmarks.append(landmarks_4chs)\n y.append(y_4ch)\n\n return landmarks, y","def flattener(image, pts, w, h):\n temp_rect = np.zeros((4,2), dtype = \"float32\")\n \n s = np.sum(pts, axis = 2)\n\n tl = pts[np.argmin(s)]\n br = pts[np.argmax(s)]\n\n diff = np.diff(pts, axis = -1)\n tr = pts[np.argmin(diff)]\n bl = pts[np.argmax(diff)]\n\n if w <= 0.8 * h: # If card is vertically oriented\n temp_rect[0] = tl\n temp_rect[1] = tr\n temp_rect[2] = br\n temp_rect[3] = bl\n\n if w >= 1.2 * h: # If card is horizontally oriented\n temp_rect[0] = bl\n temp_rect[1] = tl\n temp_rect[2] = tr\n temp_rect[3] = br\n\n if w > 0.8 * h and w < 1.2 * h: #If card is diamond oriented\n # If furthest left point is higher than furthest right point,\n # card is tilted to the left.\n if pts[1][0][1] <= pts[3][0][1]:\n # If card is titled to the left, approxPolyDP returns points\n # in this order: top right, top left, bottom left, bottom right\n temp_rect[0] = pts[1][0] # Top left\n temp_rect[1] = pts[0][0] # Top right\n temp_rect[2] = pts[3][0] # Bottom right\n temp_rect[3] = pts[2][0] # Bottom left\n\n # If furthest left point is lower than furthest right point,\n # card is tilted to the right\n if pts[1][0][1] > pts[3][0][1]:\n # If card is titled to the right, approxPolyDP returns points\n # in this order: top left, bottom left, bottom right, top right\n temp_rect[0] = pts[0][0] # Top left\n temp_rect[1] = pts[3][0] # Top right\n temp_rect[2] = pts[2][0] # Bottom right\n temp_rect[3] = pts[1][0] # Bottom left\n \n # Create destination array, calculate perspective transform matrix,\n # and warp card image\n dst = np.array([[0, 0], [MAXWIDTH - 1, 0], [MAXWIDTH - 1, MAXHEIGHT - 1], [0, MAXHEIGHT - 1]], np.float32)\n M = cv2.getPerspectiveTransform(temp_rect, dst)\n warp = cv2.warpPerspective(image, M, (MAXWIDTH, MAXHEIGHT))\n\n return warp","def createCone( basePoint=(0,-1,0), tipPoint=(0,1,0), radius = 1.0, colour=(0.6,0.6,0.6), samples = 20 ):\r\n \r\n basePoint = PyUtils.toPoint3d(basePoint)\r\n tipPoint = PyUtils.toPoint3d(tipPoint)\r\n baseToTipVector = Vector3d(basePoint,tipPoint)\r\n if baseToTipVector.isZeroVector() :\r\n raise ValueError( 'Invalid points for cylinder: base and tip are equal!' )\r\n baseToTipUnitVector = baseToTipVector.unit()\r\n xUnitVector = baseToTipUnitVector.crossProductWith( Vector3d(0,0,1) )\r\n if xUnitVector.length() < 0.5 :\r\n xUnitVector = baseToTipUnitVector.crossProductWith( Vector3d(0,-1,0) )\r\n xUnitVector.toUnit()\r\n yUnitVector = baseToTipUnitVector.crossProductWith( Vector3d(-1,0,0) )\r\n if yUnitVector.length() < 0.5 :\r\n yUnitVector = baseToTipUnitVector.crossProductWith( Vector3d(0,1,0) )\r\n yUnitVector.toUnit()\r\n\r\n vertices = []\r\n for i in range(samples):\r\n theta = i * 2 * math.pi / float(samples)\r\n vertices.append( basePoint + xUnitVector * math.cos(theta) * radius + yUnitVector * math.sin(theta) * radius )\r\n for i in range(samples):\r\n theta = i * 2 * math.pi / float(samples)\r\n vertices.append( basePoint + xUnitVector * math.cos(theta) * radius + yUnitVector * math.sin(theta) * radius )\r\n vertices.append( tipPoint )\r\n \r\n faces = [ range(0,samples) ]\r\n for i in range(0,samples) :\r\n base = samples\r\n size = samples\r\n faces.append( (base+i, base+(i+1)%size, 2*samples ) )\r\n \r\n return create( vertices, faces, colour )","def isValidPcbShape(g):\n return g.GetShape() != pcbnew.S_SEGMENT or g.GetLength() > 0","def make_hollow(\n self,\n p1: Vec,\n p2: Vec,\n thick: float = 16,\n mat: str = 'tools/toolsnodraw',\n inner_mat: str = '',\n ) -> List['Solid']:\n if not inner_mat:\n inner_mat = mat\n b_min, b_max = Vec.bbox(p1, p2)\n\n top = self.make_prism(\n Vec(b_min.x, b_min.y, b_max.z),\n Vec(b_max.x, b_max.y, b_max.z + thick),\n mat,\n )\n\n bottom = self.make_prism(\n Vec(b_min.x, b_min.y, b_min.z),\n Vec(b_max.x, b_max.y, b_min.z - thick),\n mat,\n )\n\n west = self.make_prism(\n Vec(b_min.x - thick, b_min.y, b_min.z),\n Vec(b_min.x, b_max.y, b_max.z),\n mat,\n )\n\n east = self.make_prism(\n Vec(b_max.x, b_min.y, b_min.z),\n Vec(b_max.x + thick, b_max.y, b_max.z),\n mat\n )\n\n north = self.make_prism(\n Vec(b_min.x, b_max.y, b_min.z),\n Vec(b_max.x, b_max.y + thick, b_max.z),\n mat,\n )\n\n south = self.make_prism(\n Vec(b_min.x, b_min.y - thick, b_min.z),\n Vec(b_max.x, b_min.y, b_max.z),\n mat,\n )\n\n top.bottom.mat = bottom.top.mat = inner_mat\n east.west.mat = west.east.mat = inner_mat\n north.south.mat = south.north.mat = inner_mat\n\n return [\n north.solid, south.solid,\n east.solid, west.solid,\n top.solid, bottom.solid,\n ]","def checkRing(self, verbose = 0):\n angleSum = self.tfs.ANGLE.sum()\n if self.verbose: print (\"check\")\n print (\"---------------------------------- \\n Checking, if ring is closed: \\n\", \"angleSum = \", angleSum)\n twoPi = 2*pi\n \n if angleSum != twoPi:\n fudge = 2*pi - angleSum\n print (\" ** Ring not closed - offset of: \", fudge)","def obj_bounding_shape(obj_class,\n # length,\n width):\n # Given the visualized object a shape\n if obj_class == 'Truck':\n length = 12\n elif obj_class == 'Motorcycle':\n length = 2\n elif obj_class == 'Car':\n length = 5\n else:\n length = 3\n\n if width == 0:\n if obj_class == 'Truck':\n width = 4\n elif obj_class == 'Motorcycle':\n width = 1\n elif obj_class == 'Car':\n width = 2\n else:\n width = 3\n\n return np.transpose(np.array([length, width]))","def empty_diff_walls():\n\t# 4 side walls are absorptive\n\troom_materials = [pra.Material(energy_absorption=0.1, scattering=None)] * 4\n\t# floor and ceiling are reflective\n\troom_materials.extend([pra.Material(energy_absorption=0.98, scattering=None)] * 2)\n\t\n\troom_faces = make_polygon(\n\t\tcentre=[0,0,2.5],\n\t\tradius=10,\n\t\theight=5,\n\t\tN=4,\n\t\trpy=[0,0,np.pi/4]\n\t)\n\n\t# create room\n\twalls = []\n\twalls.extend(create_walls(room_faces, room_materials))\n\n\troom = pra.Room(walls, fs=fs, max_order=3, ray_tracing=False, air_absorption=False)\n\n\troom.add_source([-5, 2, 2.])\n\troom.add_microphone([1, 0, 2.])\n\n\t# compute rir\n\troom.image_source_model()\n\troom.compute_rir()\n\n\treturn room","def plot_rings(self,x_shift,y_shift):\n\n if not self.rings: return # Bounce if option not selected\n\n patches = []\n colours = []\n for ring in self.ring_crds:\n ring[:,0] += x_shift*self.pbc[0]\n ring[:,1] += y_shift*self.pbc[1]\n patches.append(Polygon(np.array(ring), True))\n colours.append(self.ring_colours[ring[:,0].size])\n ring[:,0]-=x_shift*self.pbc[0]\n ring[:,1]-=y_shift*self.pbc[1]\n self.ax.add_collection(PatchCollection(patches,facecolor=colours,linewidths=self.lw,edgecolor=\"k\",zorder=0))\n\n patches = []\n for ring in self.perimeter_ring_crds:\n ring[:,0] += x_shift*self.pbc[0]\n ring[:,1] += y_shift*self.pbc[1]\n patches.append(Polygon(np.array(ring), True))\n ring[:,0]-=x_shift*self.pbc[0]\n ring[:,1]-=y_shift*self.pbc[1]\n self.ax.add_collection(PatchCollection(patches,facecolor=(0,0,0,0),linewidths=self.lw*3,edgecolor=\"orange\",zorder=0))","def bc_is_solid(bc):\n solid = BCProp(int(bc_solid[bc.xlb]),\n int(bc_solid[bc.xrb]),\n int(bc_solid[bc.ylb]),\n int(bc_solid[bc.yrb]))\n return solid","def rigid_rings(self):\n raise NotImplementedError","def make_shape_ccw(self):\n\n if not(self.closed):\n return\n\n # Optimization for closed shapes\n # Start value for the first sum\n\n if self.isDirectionOfGeosCCW(self.geos):\n self.reverse()\n logger.debug(self.tr(\"Had to reverse the shape to be CW\"))\n self.cw = True","def HollowCylinder(self,center=(0,0,0),inner_radius=1.0,outer_radius=2.,\n element_type='hex',isotropic=True,nrad=5,ncirc=10, nlong=20,length=10):\n\n if element_type != \"hex\":\n raise NotImplementedError('Generating {} mesh of cylinder is not supported yet'.format(element_type))\n\n if not isinstance(center,tuple):\n raise ValueError(\"The center for the base of the cylinder should be given in a tuple with three elements (x,y,z)\")\n\n self.__reset__()\n\n nlong = int(nlong)\n if nlong==0:\n nlong = 1\n\n mesh = Mesh()\n mesh.HollowCircle(center=(center[0],center[1]), inner_radius=inner_radius,\n outer_radius=outer_radius, element_type=\"quad\",\n isotropic=isotropic, nrad=nrad, ncirc=ncirc)\n\n self.Extrude(base_mesh=mesh, length=length, nlong=nlong)\n self.points += center[2]","def special_corner() -> None:\r\n if example[1, 1] == 0: # NW\r\n if conflict_space[0, 0] == conflict_space[0, 2] and conflict_space[2, 0] == conflict_space[0, 0] \\\r\n and conflict_space[0, 0] != 0:\r\n example[0, 0] = 0\r\n safeboard[0, 0] = 0\r\n progress_handler(False, True)\r\n \r\n if example[1, shape-2] == 0: # NE\r\n if conflict_space[0, shape-1] == conflict_space[0, shape-3] and \\\r\n conflict_space[2, shape-1] == conflict_space[0, shape-1] and conflict_space[0, shape-1] != 0:\r\n example[0, shape-1] = 0\r\n safeboard[0, shape-1] = 0\r\n progress_handler(False, True)\r\n \r\n if example[shape-2, shape-2] == 0: # SE\r\n if conflict_space[shape-1, shape-1] == conflict_space[shape-1, shape-3] and \\\r\n conflict_space[shape-1, shape-1] == conflict_space[shape-3, shape-1] \\\r\n and conflict_space[shape-1, shape-1] != 0:\r\n example[shape-1, shape-1] = 0\r\n safeboard[shape-1, shape-1] = 0\r\n progress_handler(False, True)\r\n \r\n if example[shape-2, 1] == 0: # SW\r\n if conflict_space[shape-1, 0] == conflict_space[shape-1, 2] and \\\r\n conflict_space[shape-1, 0] == conflict_space[shape-3, 0] and conflict_space[shape-1, 0] != 0:\r\n example[shape-1, 0] = 0\r\n safeboard[shape-1, 0] = 0\r\n progress_handler(False, True)\r\n if progress_handler(True, False):\r\n conflict_check()","def make_path(self, loop):\n path=Path(closed=True)\n for c in range(0,len(loop)):\n connection=loop[c]\n nextConnection = loop[(c+1)%len(loop)]\n lastConnection = loop[(c-1)%len(loop)]\n if self.dontFill(connection, nextConnection, lastConnection):\n return False\n cp = self.corner_pos(connection, nextConnection, lastConnection)\n corner_offset = cp[0]\n corner_dir = cp[1]\n # catch case when it is the end of a single rod\n if type(corner_offset) is list:\n endpoints = corner_offset\n corner_offset = endpoints[0]\n else:\n endpoints = False\n if connection.other.radius is not None and ( corner_offset.length() < connection.other.radius or corner_dir >0):\n # catch case when it is the end of a single rod\n if endpoints:\n para=(connection.this.pos-connection.other.pos).normalize()\n d = math.sqrt(connection.other.radius**2 - corner_offset.length()**2)\n path.add_point(PSharp(connection.other.pos + corner_offset + d*para))\n path.add_point(PArc(connection.other.pos, radius=connection.other.radius, direction='cw'))\n path.add_point(PSharp(connection.other.pos - corner_offset+d*para))\n else:\n path.add_point(PAroundcurve(connection.other.pos + corner_offset, centre=connection.other.pos, radius=connection.other.radius, direction='cw'))\n\n elif self.get_intRadius(connection, connection.other) is not None:\n # path.add_point(PIncurve(connection.other.pos + corner_offset, radius=self.get_intRadius(connection, connection.other)))\n # path.add_point(PIncurve(connection.other.pos - corner_offset, radius=self.get_intRadius(connection, connection.other)))\n # path.add_point(PIncurve(connection.other.pos - corner_offset, radius=self.get_intRadius(connection, connection.other)))\n path.add_point(PIncurve(connection.other.pos + corner_offset, radius=self.get_intRadius(connection, connection.other)))\n else:\n cornerpos = self.corner_pos(connection, nextConnection, lastConnection)\n if type(cornerpos) is list:\n path.add_point(PSharp(connection.other.pos + cornerpos[0]))\n path.add_point(PSharp(connection.other.pos + cornerpos[1]))\n else:\n path.add_point(PSharp(connection.other.pos + cornerpos))#self.corner_pos(connection, nextConnection, lastConnection)))\n # path.add_point(PSharp(connection.other.pos - cornerpos))#self.corner_pos(connection, nextConnection, lastConnection)))\n if connection.other.holeRad is not None:\n if type(connection.other.holeRad) is int or type(connection.other.holeRad) is float:\n self.otherpaths.append(Circle(connection.other.pos, rad=connection.other.holeRad, side='in'))\n else:\n t=copy.deepcopy(connection.other.holeRad)\n t.translate(connection.other.pos)\n self.otherpaths.append(t)\n return path","def hecken_taper(length = 200, B = 4.0091, dielectric_thickness = 0.25,\n eps_r = 2, Lk_per_sq = 250e-12, Z1 = None, Z2 = None,\n width1 = None, width2 = None, num_pts = 100, layer = 0):\n if width1 is not None: Z1 = _microstrip_Z_with_Lk(\n width1*1e-6,\n dielectric_thickness*1e-6,\n eps_r, Lk_per_sq\n )\n if width2 is not None: Z2 = _microstrip_Z_with_Lk(\n width2*1e-6,\n dielectric_thickness*1e-6,\n eps_r, Lk_per_sq\n )\n # Normalized length of the wire [-1 to +1]\n xi_list = np.linspace(-1, 1, num_pts)\n Z = [np.exp(0.5*log(Z1*Z2) + 0.5*log(Z2/Z1)*_G(xi, B)) for xi in xi_list]\n widths = np.array([_find_microstrip_wire_width(\n z, dielectric_thickness*1e-6,\n eps_r, Lk_per_sq\n )*1e6 for z in Z])\n x = ((xi_list/2)*length)\n\n # Compensate for varying speed of light in the microstrip by shortening\n # and lengthening sections according to the speed of light in that section\n v = np.array([_microstrip_v_with_Lk(w*1e-6, dielectric_thickness*1e-6,\n eps_r, Lk_per_sq) for w in widths])\n dx = np.diff(x)\n dx_compensated = dx*v[:-1]\n x_compensated = np.cumsum(dx_compensated)\n x = np.hstack([0, x_compensated])/max(x_compensated) * length\n\n # Create blank device and add taper polygon\n D = Device('hecken')\n xpts = np.concatenate([x, x[::-1]])\n ypts = np.concatenate([widths/2, -widths[::-1]/2])\n D.add_polygon((xpts, ypts), layer = layer)\n D.add_port(name = 1, midpoint = (0, 0), width = widths[0],\n orientation = 180)\n D.add_port(name = 2, midpoint = (length, 0), width = widths[-1],\n orientation = 0)\n\n # Add meta information about the taper\n D.info['num_squares'] = np.sum(np.diff(x)/widths[:-1])\n D.info['width1'] = widths[0]\n D.info['width2'] = widths[-1]\n D.info['Z1'] = Z[0]\n D.info['Z2'] = Z[-1]\n # Note there are two values for v/c (and f_cutoff) because the speed of\n # light is different at the beginning and end of the taper\n D.info['w'] = widths\n D.info['x'] = x\n D.info['Z'] = Z\n D.info['v/c'] = v/3e8\n D.info['time_length'] = np.sum(np.diff(D.info['x']*1e-6) \\\n / (D.info['v/c'][:-1]*3e8))\n BetaLmin = sqrt(B**2 + 6.523)\n D.info['f_cutoff'] = 1/(2*D.info['time_length'])\n D.info['length'] = length\n\n return D","def make_shape(type, name, divisions):\n\n if type == 'cube':\n mc.polyCube(n=name, sx=divisions, sy=divisions, sz=divisions)\n elif type == 'cone':\n mc.polyCone(n=name, sx=divisions, sy=divisions, sz=divisions)\n elif type == 'cylinder':\n mc.polyCylinder(n=name, sx=divisions, sy=divisions, sz=divisions)\n elif type == 'plane':\n mc.polyPlane(n=name, sx=divisions, sy=divisions)\n elif type == 'torus':\n mc.polyTorus(n=name, sx=divisions, sy=divisions)\n elif type == 'sphere':\n mc.polySphere(n=name, sx=divisions, sy=divisions)\n else:\n mc.polySphere()","def tail_joiner(self):\n\n # Fusing Right Horizontal Tail:\n shape_in_r = Fused(shape_in=self.stabilizer_h.solid, tool=self.stabilizer_vright.solid)\n shape_out_r = Fused(shape_in=shape_in_r, tool=self.connector_right)\n\n # Fusing Left Horizontal Tail:\n shape_in_l = Fused(shape_in=self.stabilizer_h.ht_mirror, tool=self.stabilizer_vleft.solid)\n shape_out_l = Fused(shape_in=shape_in_l, tool=self.connector_left)\n\n shape_out = Fused(shape_in=shape_out_r, tool=shape_out_l)\n\n return shape_out","def check_win(self):\n\n # Sets rings initially to False\n black_ring = False\n white_ring = False\n\n # Gets board\n board = self._game_board.get_board_area()\n\n # Iterate through stone-holding points\n for i in range(1, 19):\n for j in range(1, 19):\n # Get the surroundings of each point\n surround = {board[i+1][j], board[i-1][j], board[i+1][j+1], board[i+1][j-1], board[i-1][j],\n board[i-1][j-1], board[i-1][j+1], board[i][j-1]}\n\n # If the point is empty and surrounded by \"B\", there's a black ring\n if board[i][j] == \" \" and surround == {\"B\"}:\n black_ring = True\n\n # If the point is empty and surrounded by \"W\", there's a white ring\n if board[i][j] == \" \" and surround == {\"W\"}:\n white_ring = True\n\n if not black_ring:\n return \"WHITE_WON\"\n\n if not white_ring:\n return \"BLACK_WON\"\n\n return \"UNFINISHED\"","def CreateShapesWithStyle(self):\r\n\r\n useAero = (GetManager(self.GetParent()).GetAGWFlags() & AUI_MGR_AERO_DOCKING_GUIDES) != 0\r\n useWhidbey = (GetManager(self.GetParent()).GetAGWFlags() & AUI_MGR_WHIDBEY_DOCKING_GUIDES) != 0\r\n\r\n self._useAero = 0\r\n if useAero:\r\n self._useAero = 1\r\n elif useWhidbey:\r\n self._useAero = 2\r\n \r\n if useAero:\r\n sizeX, sizeY = aeroguideSizeX, aeroguideSizeY\r\n elif useWhidbey:\r\n sizeX, sizeY = whidbeySizeX, whidbeySizeY \r\n else:\r\n sizeX, sizeY = guideSizeX, guideSizeY\r\n\r\n rectLeft = wx.Rect(0, sizeY, sizeY, sizeX)\r\n rectTop = wx.Rect(sizeY, 0, sizeX, sizeY)\r\n rectRight = wx.Rect(sizeY+sizeX, sizeY, sizeY, sizeX)\r\n rectBottom = wx.Rect(sizeY, sizeX + sizeY, sizeX, sizeY)\r\n rectCenter = wx.Rect(sizeY, sizeY, sizeX, sizeX)\r\n \r\n if not self._useAero:\r\n\r\n self.targetLeft = AuiDockingGuideWindow(self, rectLeft, wx.LEFT, True, useAero)\r\n self.targetTop = AuiDockingGuideWindow(self, rectTop, wx.TOP, True, useAero)\r\n self.targetRight = AuiDockingGuideWindow(self, rectRight, wx.RIGHT, True, useAero)\r\n self.targetBottom = AuiDockingGuideWindow(self, rectBottom, wx.BOTTOM, True, useAero)\r\n self.targetCenter = AuiDockingGuideWindow(self, rectCenter, wx.CENTER, True, useAero)\r\n\r\n \r\n # top-left diamond\r\n tld = [wx.Point(rectTop.x, rectTop.y+rectTop.height-8),\r\n wx.Point(rectLeft.x+rectLeft.width-8, rectLeft.y),\r\n rectTop.GetBottomLeft()]\r\n # bottom-left diamond\r\n bld = [wx.Point(rectLeft.x+rectLeft.width-8, rectLeft.y+rectLeft.height),\r\n wx.Point(rectBottom.x, rectBottom.y+8),\r\n rectBottom.GetTopLeft()]\r\n # top-right diamond\r\n trd = [wx.Point(rectTop.x+rectTop.width, rectTop.y+rectTop.height-8),\r\n wx.Point(rectRight.x+8, rectRight.y),\r\n rectRight.GetTopLeft()] \r\n # bottom-right diamond\r\n brd = [wx.Point(rectRight.x+8, rectRight.y+rectRight.height),\r\n wx.Point(rectBottom.x+rectBottom.width, rectBottom.y+8),\r\n rectBottom.GetTopRight()]\r\n\r\n self._triangles = [tld[0:2], bld[0:2],\r\n [wx.Point(rectTop.x+rectTop.width-1, rectTop.y+rectTop.height-8),\r\n wx.Point(rectRight.x+7, rectRight.y)],\r\n [wx.Point(rectRight.x+7, rectRight.y+rectRight.height),\r\n wx.Point(rectBottom.x+rectBottom.width-1, rectBottom.y+8)]]\r\n \r\n region = wx.Region()\r\n region.UnionRect(rectLeft)\r\n region.UnionRect(rectTop)\r\n region.UnionRect(rectRight)\r\n region.UnionRect(rectBottom)\r\n region.UnionRect(rectCenter)\r\n region.UnionRegion(wx.RegionFromPoints(tld))\r\n region.UnionRegion(wx.RegionFromPoints(bld))\r\n region.UnionRegion(wx.RegionFromPoints(trd))\r\n region.UnionRegion(wx.RegionFromPoints(brd))\r\n\r\n elif useAero:\r\n\r\n self._aeroBmp = aero_dock_pane.GetBitmap()\r\n region = wx.RegionFromBitmap(self._aeroBmp)\r\n\r\n self._allAeroBmps = [aero_dock_pane_left.GetBitmap(), aero_dock_pane_top.GetBitmap(),\r\n aero_dock_pane_right.GetBitmap(), aero_dock_pane_bottom.GetBitmap(),\r\n aero_dock_pane_center.GetBitmap(), aero_dock_pane.GetBitmap()]\r\n self._deniedBitmap = aero_denied.GetBitmap()\r\n self._aeroRects = [rectLeft, rectTop, rectRight, rectBottom, rectCenter]\r\n self._valid = True\r\n\r\n elif useWhidbey:\r\n\r\n self._aeroBmp = whidbey_dock_pane.GetBitmap()\r\n region = wx.RegionFromBitmap(self._aeroBmp)\r\n\r\n self._allAeroBmps = [whidbey_dock_pane_left.GetBitmap(), whidbey_dock_pane_top.GetBitmap(),\r\n whidbey_dock_pane_right.GetBitmap(), whidbey_dock_pane_bottom.GetBitmap(),\r\n whidbey_dock_pane_center.GetBitmap(), whidbey_dock_pane.GetBitmap()]\r\n self._deniedBitmap = whidbey_denied.GetBitmap()\r\n self._aeroRects = [rectLeft, rectTop, rectRight, rectBottom, rectCenter]\r\n self._valid = True\r\n \r\n \r\n self.region = region","def toShapely(ring, geometryList):\n outline = []\n for idxA, idxB in zip(ring, ring[1:] + ring[:1]):\n shape = geometryList[idxA].GetShape()\n if shape in [STROKE_T.S_ARC, STROKE_T.S_CIRCLE]:\n outline += approximateArc(geometryList[idxA],\n commonEndPoint(geometryList[idxA], geometryList[idxB]))\n elif shape in [STROKE_T.S_CURVE]:\n outline += approximateBezier(geometryList[idxA],\n commonEndPoint(geometryList[idxA], geometryList[idxB]))\n elif shape in [STROKE_T.S_RECT]:\n assert idxA == idxB\n outline += geometryList[idxA].GetRectCorners()\n elif shape in [STROKE_T.S_POLYGON]:\n # Polygons are always closed, so they should appear as stand-alone\n assert len(ring) in [1, 2]\n return shapePolyToShapely(geometryList[idxA].GetPolyShape())\n elif shape in [STROKE_T.S_SEGMENT]:\n outline.append(commonEndPoint(geometryList[idxA], geometryList[idxB]))\n else:\n raise RuntimeError(f\"Unsupported shape {shape} in outline\")\n return Polygon(outline)","def test_cliches_write_good_basic(self):\n assert chk.check_cliches_write_good(\"\"\"No cliches here.\"\"\") == []\n # use one of the example cliches to verify basic functionality\n assert chk.check_cliches_write_good(self.l_write_good) != []\n assert \"cliches.write_good\" in chk.check_cliches_write_good(\n self.l_write_good)[0]","def geoshapes(c = False, r = False, t = False):\n if c == True:\n circle = plt.Circle((0,0), radius = 3, fill = None, edgecolor = 'y')\n plt.gca().add_patch(circle)\n elif r == True:\n rectangle = plt.Rectangle((0, 0), 5, 5, fill = None, edgecolor='r')\n plt.gca().add_patch(rectangle)\n elif t == True:\n points = [[0,0], [0,3], [3,3]]\n triangle = plt.Polygon(points, fill = None, edgecolor = 'r')\n plt.gca().add_patch(triangle)\n else:\n print('Error: please input a True value for either c, r , or t')","def __init__(self, workplane, measures):\n\n cq.Workplane.bracket = utilities.bracket\n cq.Workplane.transformedWorkplane = utilities.transformedWorkplane\n cq.Workplane.bolt = utilities.bolt\n cq.Workplane.cutEachAdaptive = utilities.cutEachAdaptive\n\n self.model = workplane\n self.debug = False\n self.measures = measures\n m = self.measures\n\n # The bracket lengths are measured at the outside, but the construction actually uses a \n # central cuboid block with two attached brackets. Adapting the measures accordingly.\n m.center_block = Measures(\n # Naming is as seen from the horizontal leg.\n width = max(m.horizontal_leg.width, m.vertical_leg.width),\n depth = m.vertical_leg.height,\n height = m.horizontal_leg.height\n )\n m.horizontal_leg.depth -= m.center_block.depth\n m.vertical_leg.depth -= m.center_block.height\n\n # Create hole specs which combine the other hole measures in the format expected by bolthole().\n m.horizontal_leg.hole_specs = [\n {\n \"diameter\": m.horizontal_leg.hole_diameters[i] if isinstance(m.horizontal_leg.hole_diameters, list) else m.horizontal_leg.hole_diameters,\n \"clamp_length\": m.horizontal_leg.clamp_lengths[i] if isinstance(m.horizontal_leg.clamp_lengths, list) else m.horizontal_leg.clamp_lengths, \n \"nuthole_size\": m.horizontal_leg.nuthole_sizes[i] if isinstance(m.horizontal_leg.nuthole_sizes, list) else m.horizontal_leg.nuthole_sizes, \n \"nuthole_depth\": 1.1 * m.vertical_leg.depth # Just choose something large enough for cutting. \n }\n for i in range(m.horizontal_leg.hole_count)\n ]\n m.vertical_leg.hole_specs = [\n {\n \"diameter\": m.vertical_leg.hole_diameters[i] if isinstance(m.vertical_leg.hole_diameters, list) else m.vertical_leg.hole_diameters,\n \"clamp_length\": m.vertical_leg.clamp_lengths[i] if isinstance(m.vertical_leg.clamp_lengths, list) else m.vertical_leg.clamp_lengths, \n \"nuthole_size\": m.vertical_leg.nuthole_sizes[i] if isinstance(m.vertical_leg.nuthole_sizes, list) else m.vertical_leg.nuthole_sizes, \n \"nuthole_depth\": 1.1 * m.horizontal_leg.depth # Just choose something large enough for cutting. \n }\n for i in range(m.vertical_leg.hole_count)\n ]\n\n # TODO: Initialize missing measures with defaults.\n\n self.build()","def test_absolute_shape_volume(self):\n\n assert self.test_shape.solid is not None\n assert self.test_shape.volume() == pytest.approx(math.pi * (10**2) * 30)","def ring_forming_scission(rct_zmas, prd_zmas):\n ret = None\n rct_zmas, rct_gras = shifted_standard_zmas_graphs(\n rct_zmas, remove_stereo=True)\n prd_zmas, prd_gras = shifted_standard_zmas_graphs(\n prd_zmas, remove_stereo=True)\n tras, _, _ = automol.graph.reac.ring_forming_scission(rct_gras, prd_gras)\n if tras:\n tra = tras[0]\n brk_bnd_key, = automol.graph.trans.broken_bond_keys(tra)\n frm_bnd_key, = automol.graph.trans.formed_bond_keys(tra)\n ts_zma = rct_zmas[0]\n\n # set up radical atom, leaving atom, newly formed radical atom\n # also set up chain between radical atom and newly formed radical atom\n ts_gra = automol.zmatrix.graph(ts_zma)\n rad_atm = list(automol.graph.sing_res_dom_radical_atom_keys(ts_gra))[0]\n for atm in brk_bnd_key:\n if atm not in frm_bnd_key:\n leave_atm = atm\n else:\n new_rad_atm = atm\n\n chain_between = automol.zmatrix.chain_between(ts_zma, new_rad_atm, rad_atm)\n\n tors_names = automol.zmatrix.torsion_coordinate_names(ts_zma)\n coo_dct = automol.zmatrix.coordinates(ts_zma)\n ang_90 = numpy.pi/2.\n ts_tors_names = []\n const_tors_names = []\n # (i) set torsion from rad atom towards chain to 90\n for tors_name in tors_names:\n axis = coo_dct[tors_name][0][1:3]\n # (ii) remove torsions in chain_between from final torsion sampling list\n if ((axis[0] not in chain_between) or (axis[1] not in chain_between)):\n ts_tors_names.append(tors_name)\n if ((rad_atm == axis[0] and axis[1] in chain_between) or\n (rad_atm == axis[1] and axis[0] in chain_between)):\n ts_zma_p = automol.zmatrix.set_values(ts_zma, {tors_name: ang_90})\n # const_tors_names.append(tors_name)\n\n # (iii) vary torsions in chain_between to minimize distance from rad_atm to new_rad_atm\n preopt_tors_names = []\n for tors_name in tors_names:\n axis = coo_dct[tors_name][0][1:3]\n if ((axis[0] in chain_between) and (axis[1] in chain_between) and\n (rad_atm not in axis) and (new_rad_atm not in axis)):\n preopt_tors_names.append(tors_name)\n # add any ring forming torsions to constraints to ensure 0 dihedrals for the ring\n const_tors_names.append(tors_name)\n\n angles = [0., 2.*numpy.pi/3, 4.*numpy.pi/3]\n # angles = [0., numpy.pi/3., 2.*numpy.pi/3, 3.*numpy.pi/3., 4.*numpy.pi/3, 5*numpy.pi/3.]\n trial_zmas = [ts_zma_p]\n for preopt_tors_name in preopt_tors_names:\n new_trial_zmas = []\n for zma_i in trial_zmas:\n for ang in angles:\n new_trial_zmas.append(\n automol.zmatrix.set_values(\n zma_i, {preopt_tors_name: ang}))\n trial_zmas = new_trial_zmas\n\n dist_min = 1.0e30\n for trial_zma in trial_zmas:\n geo_i = automol.zmatrix.geometry(trial_zma)\n dist = automol.geom.distance(geo_i, rad_atm, new_rad_atm)\n if dist < dist_min:\n dist_min = dist\n ts_zma = trial_zma\n\n ang_stp = 2.*numpy.pi/6.\n # (iv) vary torsion from new_rad_atm to leaving atom so that leave_atm is far from rad_atm\n for tors_name in tors_names:\n ang = -ang_stp\n axis = coo_dct[tors_name][0][1:3]\n if ((new_rad_atm == axis[0] and axis[1] in chain_between) or\n (new_rad_atm == axis[1] and axis[0] in chain_between)):\n dist_max = 0.0\n for _ in range(6):\n ang += ang_stp\n ts_zma_i = automol.zmatrix.set_values(ts_zma, {tors_name: ang})\n geo_i = automol.zmatrix.geometry(ts_zma_i)\n dist = automol.geom.distance(geo_i, rad_atm, leave_atm)\n if dist > dist_max:\n dist_max = dist\n ts_zma_max = ts_zma_i\n const_tors_names.append(tors_name)\n # set up ts torsions - remove ones with axis in the chain between new and old rad atoms\n if ((axis[0] not in chain_between) or (axis[1] not in chain_between)):\n ts_tors_names.append(tors_name)\n # elif (axis[0] in chain_between) and (axis[1] in chain_between):\n # if tors_name not in const_tors_names:\n # const_tors_names.append(tors_name)\n\n ts_zma = ts_zma_max\n\n # (v) vary angles to decrease rad_atm to new_rad_atm to < 2.25 Ang\n dist_thresh = 4.25\n # dist_thresh = 4.\n ang_names = automol.zmatrix.central_angle_names(ts_zma)\n ring_angs = []\n const_angs_names = []\n for ang_name in ang_names:\n ang_atms = coo_dct[ang_name][0]\n if ((ang_atms[0] in chain_between) and (ang_atms[1] in chain_between) and\n (ang_atms[2] in chain_between)):\n ring_angs.append(ang_name)\n const_angs_names.append(ang_name)\n dist = 1.e30\n ang_stp = numpy.pi/360.\n # ang_stp = 0.5 degrees\n counter = 0\n while ((dist > dist_thresh) and (counter < 30)):\n counter += 1\n values = automol.zmatrix.values(ts_zma)\n for ang_name in ring_angs:\n ang = values[ang_name] - ang_stp\n ts_zma = automol.zmatrix.set_values(ts_zma, {ang_name: ang})\n geo_i = automol.zmatrix.geometry(ts_zma)\n dist = automol.geom.distance(geo_i, rad_atm, new_rad_atm)\n\n brk_dist_name = automol.zmatrix.bond_key_from_idxs(ts_zma, brk_bnd_key)\n\n # Build the reactants graph\n rcts_gra = automol.graph.union_from_sequence(rct_gras)\n\n # Set the indices for the const coords\n\n ret = (ts_zma, brk_dist_name, brk_bnd_key,\n tuple(const_tors_names), tuple(ts_tors_names),\n tuple(const_angs_names), rcts_gra)\n\n return ret","def circular_punching(cls, nb_points,outer_rad, position):\n\n rad1= outer_rad\n rad2 = 0.1*rad1\n rad3 = 0.02*rad1\n points1 = rad1*np.transpose(np.concatenate(([np.cos(2*np.pi*np.arange(0,nb_points+1)/nb_points)],[np.sin(2*np.pi*np.arange(0,nb_points+1)/nb_points)]),axis=0))\n curv = 0*np.ones(points1.shape[0])\n curv[0] = 0\n curv[-1] = 0\n punching_circ = Feature.define_tube(points1,curv,rad3)\n points2 = rad2*np.transpose(np.concatenate(([np.cos(2*np.pi*np.arange(0,nb_points+1)/nb_points)],[np.sin(2*np.pi*np.arange(0,nb_points+1)/nb_points)]),axis=0))\n sectors = [np.concatenate(([points2[x,:]],[((rad1-rad3)/rad1)*points1[x,:]],[((rad1-rad3)/rad1)*points1[x+1,:]],[points2[x+1,:]]),axis=0) for x in range(0,nb_points,2)]\n\n punching = [punching_circ.coord[0],points2]\n\n for x in range(len(sectors)):\n punching.append(sectors[x])\n\n for x in range(len(punching)):\n for y in range(punching[x].shape[0]):\n punching[x][y,:]=punching[x][y,:]+position\n\n punching_obj = cls()\n punching_obj.coord = punching\n return punching_obj","def checkSubClass(self, checkSub:bool=True):\n lines = self.edges()\n slope = [x.slope() for x in lines]\n length = [x.length() for x in lines]\n\n if (\n abs(slope[0]- slope[2]) < Drawable._comparisonLimit and\n abs(slope[3] - slope[1]) < Drawable._comparisonLimit\n ):\n from Drawables.Parallelogram import Parallelogram\n rectangle = abs((slope[1] * slope[2]) +1) < Drawable._comparisonLimit\n rhombus = abs(length[1] - length[2]) < Drawable._comparisonLimit\n if rectangle and rhombus:\n from Drawables.Square import Square\n new = Square()\n elif rectangle:\n from Drawables.Rectangle import Rectangle\n new = Rectangle()\n elif rhombus:\n from Drawables.Rhombus import Rhombus\n new = Rhombus()\n else:\n new = Parallelogram()\n new.vertices = self.vertices\n new.size = self.size\n new.clockwise = self.clockwise\n return new\n if (\n abs(slope[0] - slope[2]) < Drawable._comparisonLimit or\n abs(slope[3] - slope[1]) < Drawable._comparisonLimit\n ):\n from Drawables.Trapezoid import Trapezoid\n new = Trapezoid()\n new.vertices = self.vertices\n new.size = self.size\n new.clockwise = self.clockwise\n return new\n if (\n (\n abs(length[0] - length[1]) < Drawable._comparisonLimit and \n abs(length[2] - length[3]) < Drawable._comparisonLimit\n ) or\n (\n abs(length[0] - length[3]) < Drawable._comparisonLimit and \n abs(length[1] - length[2]) < Drawable._comparisonLimit\n )\n ):\n from Drawables.Kite import Kite\n new = Kite()\n new.vertices = self.vertices\n new.size = self.size\n new.clockwise = self.clockwise\n return new\n return self","def test_flatten_requirement(self, space_each_type):\n tspace = build_required_space(space_each_type, shape_requirement=\"flattened\")\n\n # 1 integer + 1 categorical + 1 * (3, 2) shapes\n assert len(tspace) == 1 + 1 + 3 * (3 * 2)\n assert str(tspace).count(\"View\") == 3 * (3 * 2) + 1\n\n i = 0\n\n assert tspace[i].type == \"categorical\"\n i += 1\n\n assert tspace[i].type == \"integer\"\n i += 1\n\n for _ in range(3 * 2):\n assert tspace[i].type == \"real\"\n i += 1\n\n for _ in range(3 * 2):\n assert tspace[i].type == \"integer\"\n i += 1\n\n for _ in range(3 * 2):\n assert tspace[i].type == \"real\"\n i += 1\n\n tspace = build_required_space(\n space_each_type, shape_requirement=\"flattened\", type_requirement=\"real\"\n )\n\n # 1 integer + 4 categorical + 1 * (3, 2) shapes\n assert len(tspace) == 1 + 4 + 3 * (3 * 2)\n assert str(tspace).count(\"View\") == 4 + 3 * (3 * 2) + 1","def test_cut_volume(self):\n\n shape_with_cut = ExtrudeCircleShape(points=[(30, 0)], radius=20, distance=40, cut=self.test_shape)\n\n assert shape_with_cut.volume() == pytest.approx((math.pi * (20**2) * 40) - (math.pi * (10**2) * 30))","def _makeBlockPinPatches(block, cold):\n patches = []\n data = []\n names = []\n if isinstance(block.spatialGrid, grids.HexGrid):\n largestPitch, comp = block.getPitch(returnComp=True)\n\n elif isinstance(block.spatialGrid, grids.ThetaRZGrid):\n raise TypeError(\n \"This plot function is not currently supported for ThetaRZGrid grids.\"\n )\n else:\n largestPitch, comp = block.getPitch(returnComp=True)\n if block.getPitch()[0] != block.getPitch()[1]:\n raise ValueError(\"Only works for blocks with equal length and width.\")\n\n sortedComps = sorted(block, reverse=True)\n\n derivedComponents = block.getComponentsOfShape(DerivedShape)\n if len(derivedComponents) == 1:\n derivedComponent = derivedComponents[0]\n sortedComps.remove(derivedComponent)\n cName = derivedComponent.name\n\n if isinstance(derivedComponent.material, custom.Custom):\n material = derivedComponent.p.customIsotopicsName\n else:\n material = derivedComponent.material.name\n\n location = comp.spatialLocator\n if isinstance(location, grids.MultiIndexLocation):\n location = location[0]\n x, y, _ = location.getLocalCoordinates()\n if isinstance(comp, Hexagon):\n derivedPatch = matplotlib.patches.RegularPolygon(\n (x, y), 6, largestPitch / math.sqrt(3)\n )\n elif isinstance(comp, Square):\n derivedPatch = matplotlib.patches.Rectangle(\n (x - largestPitch[0] / 2, y - largestPitch[0] / 2),\n largestPitch[0],\n largestPitch[0],\n )\n else:\n raise TypeError(\n \"Shape of the pitch-defining element is not a Square or Hex it is {}, cannot plot for this type of block\".format(\n comp.shape\n )\n )\n patches.append(derivedPatch)\n data.append(material)\n names.append(cName)\n for component in sortedComps:\n locs = component.spatialLocator\n if not isinstance(locs, grids.MultiIndexLocation):\n # make a single location a list to iterate.\n locs = [locs]\n for loc in locs:\n x, y, _ = loc.getLocalCoordinates()\n\n # goes through each location\n # want to place a patch at that location\n blockPatches = _makeComponentPatch(component, (x, y), cold)\n for element in blockPatches:\n patches.append(element)\n\n if isinstance(component.material, custom.Custom):\n material = component.p.customIsotopicsName\n else:\n material = component.material.name\n\n data.append(material)\n names.append(component.name)\n\n return patches, data, names","def circlePrimitive(self):\n\n def drawWireframe(self):\n\n # Draw line\n glFT.glBegin(OpenMayaRender.MGL_LINE_STRIP)\n\n # Get Color\n # self.getColor(\"edge\")\n\n def_circle = 100\n for idx in range(def_circle + 1):\n\n theta = 2 * 3.141592 * idx / def_circle\n x = self.shape_size * math.cos(theta)\n z = self.shape_size * math.sin(theta)\n\n point = OpenMaya.MVector(x, 0.0, z)\n point = self.setUpAxis(point)\n point = self.addOffsetRotation(point)\n point = self.addOffsetPosition(point)\n self.getBoundingBoxSize(point)\n\n glFT.glVertex3f(point.x, point.y, point.z)\n\n glFT.glEnd()\n \n def drawShaded(self):\n\n # Draw quad\n glFT.glBegin(OpenMayaRender.MGL_POLYGON)\n\n # Get Color\n # self.getColor(\"polygon\")\n\n def_circle = 100\n for idx in range(def_circle + 1):\n\n theta = 2 * 3.141592 * idx / def_circle\n x = self.shape_size * math.cos(theta)\n z = self.shape_size * math.sin(theta)\n\n point = OpenMaya.MVector(x, 0.0, z)\n point = self.setUpAxis(point)\n point = self.addOffsetRotation(point)\n point = self.addOffsetPosition(point)\n self.getBoundingBoxSize(point)\n\n glFT.glVertex3f(point.x, point.y, point.z)\n\n glFT.glEnd()\n\n glFT.glNewList(self.vList_id, OpenMayaRender.MGL_COMPILE)\n\n # Draw lines\n if self.draw_type == 0 or self.draw_type == 2:\n drawWireframe(self)\n \n # Draww Polygons\n if self.draw_type == 1 or self.draw_type == 2:\n drawShaded(self)\n\n glFT.glEndList()","def shape(self, rootsequence, side, image, option=0):\n\n left_points = self.get_points(\n side=0,\n imgnumber=image)\n\n leftX, leftY, leftZ = self.separate_points_by_coordinate(left_points)\n\n right_points = self.get_points(\n side=1,\n imgnumber=image)\n\n rightX, rightY, rightZ = self.separate_points_by_coordinate(right_points)\n\n if option == 1:\n lalpha_shapes = self.alpha_shapes(\n X=leftX,\n Y=leftY,\n Z=leftZ,\n alpha=5,\n # color='#A91818',\n color='#808080',\n opacity=1.0)\n\n ralpha_shapes = self.alpha_shapes(\n X=rightX,\n Y=rightY,\n Z=rightZ,\n alpha=5,\n # color='#FF3232',\n color='#808080',\n opacity=1.0)\n\n return [lalpha_shapes, ralpha_shapes]\n\n elif option == 2:\n lpoint_cloud = self.point_cloud(\n X=leftX,\n Y=leftY,\n Z=leftZ,\n legend='RIGHT LUNG',\n size=1,\n # color='#FF3232',\n # bordercolor='#FF3232',\n color='#999999',\n bordercolor='#999999',\n width=0.5,\n opacity=1.0)\n\n rpoint_cloud = self.point_cloud(\n X=rightX,\n Y=rightY,\n Z=rightZ,\n legend='LEFT LUNG',\n size=1,\n # color='#701700',\n # bordercolor='#701700',\n color='#999999',\n bordercolor='#999999',\n width=0.5,\n opacity=1.0)\n\n lalpha_shapes = self.alpha_shapes(\n X=leftX,\n Y=leftY,\n Z=leftZ,\n alpha=5,\n color='rgba(255, 0, 0, 0.1)',\n # color='#808080',\n opacity=1.0)\n\n ralpha_shapes = self.alpha_shapes(\n X=rightX,\n Y=rightY,\n Z=rightZ,\n alpha=5,\n color='rgba(255, 0, 0, 0.1)',\n # color='#808080',\n opacity=1.0)\n\n return [lpoint_cloud, rpoint_cloud, lalpha_shapes, ralpha_shapes]\n\n else:\n lpoint_cloud = self.point_cloud(\n X=leftX,\n Y=leftY,\n Z=leftZ,\n legend='RIGHT LUNG',\n size=1,\n # color='#FF3232',\n # bordercolor='#FF3232',\n color='#999999',\n bordercolor='#999999',\n width=0.5,\n opacity=1.0)\n\n rpoint_cloud = self.point_cloud(\n X=rightX,\n Y=rightY,\n Z=rightZ,\n legend='LEFT LUNG',\n size=1,\n color='#999999',\n bordercolor='#999999',\n # color='#701700',\n # bordercolor='#701700',\n width=0.5,\n opacity=1.0)\n\n return [lpoint_cloud, rpoint_cloud]","def checkForCircle(self, points, tangents):\n if len(points)<10:\n return False, 0\n\n if all(points[0]==points[-1]): # last exactly equals the first.\n # Ignore last point for this check\n points = points[:-1]\n tangents = tangents[:-1]\n #print 'Removed last ', points\n xmin,ymin, w, h = computeBox( points)\n diag2=(w*w+h*h)\n \n diag = sqrt(diag2)*0.5\n norms = numpy.sqrt(numpy.sum( tangents**2, 1 ))\n\n angles = numpy.arctan2( tangents[:,1], tangents[:,0] ) \n #debug( 'angle = ', repr(angles))\n N = len(angles)\n \n deltas = points[1:] - points[:-1] \n deltasD = numpy.concatenate([ [D(points[0],points[-1])/diag], numpy.sqrt(numpy.sum( deltas**2, 1 )) / diag] )\n\n # locate and avoid the point when swicthing\n # from -pi to +pi. The point is around the minimum\n imin = numpy.argmin(angles)\n debug(' imin ',imin)\n angles = numpy.roll(angles, -imin)\n deltasD = numpy.roll(deltasD, -imin)\n n=int(N*0.1)\n # avoid fluctuations by removing points around the min\n angles=angles[n:-n]\n deltasD=deltasD[n:-n]\n deltasD = deltasD.cumsum()\n N = len(angles)\n\n # smooth angles to avoid artificial bumps\n angles = smoothArray(angles, n=max(int(N*0.03),2) )\n\n deltaA = angles[1:] - angles[:-1]\n deltasDD = (deltasD[1:] -deltasD[:-1])\n deltasDD[numpy.where(deltasDD==0.)] = 1e-5*deltasD[0]\n dAdD = abs(deltaA/deltasDD)\n belowT, count = True,0\n for v in dAdD:\n if v>6 and belowT:\n count+=1\n belowT = False\n belowT= (v<6)\n\n self.temp = (deltasD,angles, tangents, dAdD )\n fracStraight = numpy.sum(deltasDD[numpy.where(dAdD<0.3)])/(deltasD[-1]-deltasD[0])\n curveLength = deltasD[-1]/3.14\n #print \"SSS \",count , fracStraight\n if curveLength> 1.4 or fracStraight>0.4 or count > 6:\n isCircle =False\n else: \n isCircle= (count < 4 and fracStraight<=0.3) or \\\n (fracStraight<=0.1 and count<5)\n\n if not isCircle:\n return False, 0\n \n # It's a circle !\n radius = points - numpy.array([xmin+w*0.5,ymin+h*0.5])\n radius_n = numpy.sqrt(numpy.sum( radius**2, 1 )) # normalize\n\n mini = numpy.argmin(radius_n) \n rmin = radius_n[mini]\n maxi = numpy.argmax(radius_n) \n rmax = radius_n[maxi]\n # void points around maxi and mini to make sure the 2nd max is found\n # on the \"other\" side\n n = len(radius_n)\n radius_n[maxi]=0 \n radius_n[mini]=0 \n for i in range(1,n/8+1):\n radius_n[(maxi+i)%n]=0\n radius_n[(maxi-i)%n]=0\n radius_n[(mini+i)%n]=0\n radius_n[(mini-i)%n]=0\n radius_n_2 = [ r for r in radius_n if r>0]\n rmax_2 = max(radius_n_2)\n rmin_2 = min(radius_n_2) # not good !!\n anglemax = numpy.arccos( radius[maxi][0]/rmax)*numpy.sign(radius[maxi][1])\n return True, (xmin+w*0.5,ymin+h*0.5, 0.5*(rmin+rmin_2), 0.5*(rmax+rmax_2), anglemax)","def drawBrick(res_num1, atom1, res_num2, atom2, **kwargs):\n\n chain1 = str(kwargs.pop(\"chain1\", \"A\")).strip()\n chain2 = str(kwargs.pop(\"chain2\", \"A\")).strip()\n res_num1 = int(res_num1)\n res_num2 = int(res_num2)\n offset1 = str2array(kwargs.pop(\"offset1\", \"(0,0,0)\"))\n offset2 = str2array(kwargs.pop(\"offset2\", \"(0,0,0)\"))\n\n boxname = kwargs.pop(\"boxname\", \"brick\")\n selname = kwargs.pop(\"name\", \"(sel)\")\n p1 = get_selection_first_coord(\"///%(chain1)s/`%(res_num1)d/%(atom1)s\" % vars(), selname)\n p2 = get_selection_first_coord(\"///%(chain2)s/`%(res_num2)d/%(atom2)s\" % vars(), selname)\n\n #print \"lower_left: %r\" % lower_left\n #print \"offset1: %r\" % offset1\n\n p1 += offset1\n p2 += offset2\n\n lower_left = numpy.where(p1 < p2, p1, p2)\n upper_right = numpy.where(p1 < p2, p2, p1)\n\n print \"--> lower left front corner: %(lower_left)r\" % vars()\n print \"--> upper right back corner: %(upper_right)r\" % vars()\n\n boxCGO = box(lower_left, upper_right, **kwargs)\n cmd.load_cgo(boxCGO, boxname)\n return boxname","def ring_forming_scission_ts_geometry(rxn, rct_geos,\n max_dist_err=2e-1, log=False):\n assert rxn.class_ == ReactionClass.Typ.RING_FORM_SCISSION\n assert rxn.has_standard_keys()\n frm_bnd_key, = ts.forming_bond_keys(rxn.forward_ts_graph)\n brk_bnd_key, = ts.breaking_bond_keys(rxn.forward_ts_graph)\n frm_bnd_dist = 2.0\n brk_bnd_dist = 1.5\n d1234 = 180.\n\n dist_dct = automol.geom.ts.distances(rct_geos, angstrom=True)\n dist_dct[frm_bnd_key] = frm_bnd_dist\n dist_dct[brk_bnd_key] = brk_bnd_dist\n\n # Note that this will not set the angle to exactly 180, because we don't\n # yet know the 1-3 and 2-4 distances.\n chain_keys = ring_forming_scission_chain(rxn)\n key1, key2, key3, key4 = chain_keys[:4]\n dih_dct = {(key1, key2, key3, key4): (d1234, None)}\n\n gra = ts.reactants_graph(rxn.forward_ts_graph)\n dist_range_dct = automol.graph.embed.distance_ranges_from_coordinates(\n gra, dist_dct, dih_dct=dih_dct, degree=True, angstrom=True)\n\n geo_init, = rct_geos\n relax_ang = True\n relax_tors = True\n\n geo = _geometry_from_info(\n gra, rct_geos, geo_init, dist_range_dct,\n relax_ang=relax_ang, relax_tors=relax_tors,\n max_dist_err=max_dist_err, log=log)\n\n # Rerun the optimization, enforcing planarity on the ring\n dist_dct = automol.geom.ts.distances([geo], angstrom=True)\n dist_dct[frm_bnd_key] = frm_bnd_dist\n dist_dct[brk_bnd_key] = brk_bnd_dist\n pla_dct = {}\n for key1, key2, key3, key4 in mit.windowed(chain_keys, 4):\n pla_dct[(key1, key2, key3, key4)] = (0.0, 0.0)\n\n gra = ts.reactants_graph(rxn.forward_ts_graph)\n dist_range_dct = automol.graph.embed.distance_ranges_from_coordinates(\n gra, dist_dct, degree=True, angstrom=True)\n\n geo = _geometry_from_info(\n gra, [geo], geo, dist_range_dct,\n relax_ang=relax_ang, relax_tors=relax_tors,\n pla_dct=pla_dct,\n max_dist_err=max_dist_err, log=log)\n\n return geo","def graphCut(img, center, radius, temp, edge, count, editPoints, padList, theta_width, phi_width):\r\n\r\n\r\n \"\"\"Important note. The labeled image is referred to as temp, or self.temp in the interface.\r\n This stands for template. The previously labled image is fed back into the graphcut\"\"\"\r\n \r\n \"\"\"create polar images and cost arrays\"\"\"\r\n \r\n print \"RUNNING GRAPHCUT!\"\r\n img= padImage(img, padList)\r\n temp= padImage(temp, padList)\r\n edge= padImage(edge, padList)\r\n center= padCenter(center, padList)\r\n \r\n polar_img= img2polar(img, center, radius, theta_width=theta_width, phi_width=phi_width)\r\n\r\n \r\n \r\n polar_grad, y, x = np.gradient(np.array(polar_img, dtype='float'))\r\n \"\"\"Lockett 100416 replacement line below to not use gradient when the image has a surface label\"\"\"\r\n \"\"\"polar_grad = -1 * np.array(polar_img, dtype='float')\"\"\"\r\n \r\n \r\n polar_cost = -1 * np.ones(polar_img.shape)\r\n for r in range(1,radius):\r\n polar_cost[r]= polar_grad[r]-polar_grad[r-1]\r\n\r\n \r\n \r\n \"\"\"\r\n flip the cost image upside down. This is so that the base set is at the bottom of the array\r\n since the graphcut cuts from top to bottom, this inversion is necessary.\r\n \"\"\"\r\n polar_cost_inv=polar_cost[::-1,:,:]\r\n\r\n print \"CONSTRUCTING GRAPH EDGES... \"\r\n \r\n \"\"\"construct the graph using PyMaxFlow\"\"\"\r\n g=maxflow.GraphFloat()\r\n nodeids=g.add_grid_nodes(polar_img.shape)\r\n structure=np.zeros((3,3,3))\r\n structure[2]= np.array([[0,10000,0],[10000, 10000, 10000],[0, 10000, 0]])\r\n g.add_grid_edges(nodeids, structure=structure, symmetric=False)\r\n\r\n \r\n \"\"\"convert the previously labeled image (temp) into a polar transform image. Take the labels and\r\n give them high cost edge weights so the segmentation avoids previously labeled objects\"\"\"\r\n polar_lbl_img= img2polar(temp, center, radius, theta_width=theta_width, phi_width=phi_width)\r\n polar_lbl_img_inv= polar_lbl_img[::-1,:]\r\n \r\n lbl_caps= polar_lbl_img_inv>0\r\n self_caps= (polar_lbl_img_inv==count)\r\n lbl_caps-=self_caps\r\n lbl_source_caps= np.zeros(lbl_caps.shape)\r\n lbl_sink_caps= lbl_caps*10000\r\n g.add_grid_tedges(nodeids, lbl_source_caps, lbl_sink_caps)\r\n \r\n structure2= 10000*np.array([[0,0,0],[0,0,1],[0,1,0]])\r\n g.add_grid_edges(nodeids[radius-1], structure=structure2, symmetric=True)\r\n\r\n \"\"\"add terminal edges using two arrays whose elemnts are the costs of the edges from the source and to the\r\n sink\"\"\"\r\n print \"CONSTRUCTING GRAPH TEDGES...\"\r\n sinkcaps= polar_cost_inv * (polar_cost_inv>=0)\r\n sourcecaps = -1 * polar_cost_inv * (polar_cost_inv<0)\r\n g.add_grid_tedges(nodeids, sourcecaps, sinkcaps)\r\n\r\n \r\n\r\n \r\n \"\"\"accounts for edit points. Takes every point in the edit point list, converts it to its spherical coordinate, and adds high cost\r\n edges in the column of that edit point inverts the x and y coordinates of the center\"\"\"\r\n center= np.array((center[0], center[2], center[1]))\r\n if len(editPoints)!=0:\r\n for coords in editPoints:\r\n\r\n \r\n rad= math.sqrt((center[0]-coords[0])**2+ (center[1]-coords[2])**2 + (center[2]-coords[1])**2) \r\n theta= math.atan2(center[2]-coords[1], coords[2]-center[1])\r\n print str((coords[0]-center[0])/(rad+1))\r\n phi=math.acos(float(coords[0]-center[0])/(rad+1))\r\n if theta<0:\r\n theta=2*math.pi+ theta\r\n theta= theta_width- theta_width*theta/(2*math.pi)-1\r\n phi= phi_width*phi/(math.pi)-1\r\n rad= radius- rad\r\n print \"POLAR COORDS: \" + str((rad, theta, phi))\r\n\r\n for r in range(0, radius):\r\n if r<=rad:\r\n g.add_tedge(nodeids[r, theta, phi], 0, 10000)\r\n \r\n else:\r\n g.add_tedge(nodeids[r, theta, phi], 10000, 0) \r\n\r\n\r\n\r\n\r\n print \"CUTTING GRAPH...\"\r\n g.maxflow()\r\n\r\n \"\"\"s-t mincut of graph. This is converted to cartesian coordinates with the function img2cart. The\r\n images are also closed to eliminate spotty areas\"\"\"\r\n \r\n print \"STARTING CARTESIAN TRANSFORM...\"\r\n polar_img_seg= np.invert(g.get_grid_segments(nodeids)[::-1,:,:])\r\n\r\n \r\n edge_img= np.zeros(img.shape)\r\n seg_img= ndimage.binary_closing(img2cart(img, polar_img_seg, center, radius, theta_width, phi_width))\r\n \r\n \r\n \"\"\"create an edge image of the segmented object\"\"\"\r\n strel=np.ones((3,3,3))\r\n erode_img=ndimage.binary_erosion(seg_img, strel)\r\n edge_img=np.logical_xor(seg_img, erode_img)\r\n \r\n\r\n \"\"\"shears the segmentation image and edge if padding was applied\"\"\"\r\n \r\n\r\n \"\"\"add the object back on to the template image (and the edge image back on the template edge)\r\n If there was an editpoint involved, remove the previous segmentation of that object and add back\r\n on the edited object\"\"\"\r\n if len(editPoints)!=0:\r\n del_img= (temp==count)*count\r\n temp-=del_img\r\n\r\n del_edge_img= (edge==count)*count\r\n edge-= del_edge_img\r\n\r\n\r\n temp+=seg_img*count\r\n edge+=edge_img*count\r\n\r\n temp= shearImage(temp, padList)\r\n edge= shearImage(edge, padList)\r\n \r\n \r\n\r\n print \"FINISHED!\"\r\n \r\n return temp, edge","def showSimpleCylinders(self): \n #from morphforge.morphology.util import TriMeshBuilderVerySimple\n import sys\n sys.path.append('/usr/share/pyshared/')\n \n #import morphforge\n from morphforge.morphology.mesh import MeshBuilderRings\n MonkeyPatchMayaVi()\n #import enthought.mayavi.mlab as mlab\n from mayavi import mlab\n \n assert len(self.morphs)==1\n mesh = MeshBuilderRings().build(self.morphs[0])\n \n \n @mlab.show\n def _showSimpleCylinders():\n\t \n #c = TriMeshBuilderVerySimple(self.morphs[0])\n #mlab.triangular_mesh(c.x, c.y, c.z, c.triangles, colormap=self.colormap)\n mlab.triangular_mesh(mesh.vertices[:,0], mesh.vertices[:,1], mesh.vertices[:,2], mesh.triangles, colormap=self.colormap)\n \n _showSimpleCylinders()","def __fill_lip_solid(self, outer, inner):\n inner[0].reverse()\n inner[1].reverse()\n outer_curve = zip(outer[0], outer[1])\n inner_curve = zip(inner[0], inner[1])\n points = []\n for point in outer_curve:\n points.append(np.array(point, dtype=np.int32))\n for point in inner_curve:\n points.append(np.array(point, dtype=np.int32))\n points = np.array(points, dtype=np.int32)\n self.red_l = int(self.red_l)\n self.green_l = int(self.green_l)\n self.blue_l = int(self.blue_l)\n cv2.fillPoly(self.image, [points], (self.red_l, self.green_l, self.blue_l))","def grow_surface(initial_shell_point, initial_screen_point, screen_normal, principal_ray, process_pool, stop_flag, on_new_patch):\n \n max_angle = FOV/2.0\n angle_step = math.fabs(math.atan(optics.globals.LIGHT_RADIUS / initial_shell_point[2]))\n \n #a simple queue of requests in the form of arguments to pass to create_patch\n patch_requests = []\n \n all_patches = []\n patch_grid = {}\n def grid_index(patch):\n \"\"\"\n Returns a (mu, rho) integer pair representing the patch. For easy indexing and tracking which have been created.\n \"\"\"\n mu = round(math.fabs(patch.mu_start_plane.angle) / angle_step)\n if patch.mu_end_plane.angle < 0:\n if patch.mu_start_plane.angle == 0.0:\n mu = -1\n else:\n mu += 2\n mu *= -1\n rho = round(math.fabs(patch.rho_start_plane.angle) / angle_step)\n if patch.rho_end_plane.angle < 0:\n if patch.rho_start_plane.angle == 0.0:\n rho = -1\n else:\n rho += 2\n rho *= -1\n return (mu, rho)\n \n def _create_patch_for_index(index):\n \"\"\"\n Create a patch at a given index. Assumes that any required previous patches exist.\n \"\"\"\n mu_idx, rho_idx = index\n prev_rho_patch = None\n prev_mu_patch = None\n if mu_idx == 0 and rho_idx == 0:\n shell_point = initial_shell_point\n screen_point = initial_screen_point\n mu_start_plane = optics.arcplane.ArcPlane(mu=0.0)\n mu_end_plane = optics.arcplane.ArcPlane(mu=angle_step)\n rho_start_plane = optics.arcplane.ArcPlane(rho=0.0)\n rho_end_plane = optics.arcplane.ArcPlane(rho=angle_step)\n else:\n if mu_idx != 0:\n if mu_idx > 0:\n prev_mu_idx = mu_idx - 1\n else:\n prev_mu_idx = mu_idx + 1\n prev_mu_patch = patch_grid[(prev_mu_idx, rho_idx)]\n mu_start_plane = prev_mu_patch.mu_end_plane\n if mu_idx > 0:\n mu_end_plane = optics.arcplane.ArcPlane(mu=angle_step * (mu_idx+1))\n else:\n mu_end_plane = optics.arcplane.ArcPlane(mu=angle_step * mu_idx)\n else:\n mu_start_plane = optics.arcplane.ArcPlane(mu=0.0)\n mu_end_plane = optics.arcplane.ArcPlane(mu=angle_step)\n if rho_idx != 0:\n if rho_idx > 0:\n prev_rho_idx = rho_idx - 1\n else:\n prev_rho_idx = rho_idx + 1\n prev_rho_patch = patch_grid[(mu_idx, prev_rho_idx)]\n rho_start_plane = prev_rho_patch.rho_end_plane\n if rho_idx > 0:\n rho_end_plane = optics.arcplane.ArcPlane(rho=angle_step * (rho_idx+1))\n else:\n rho_end_plane = optics.arcplane.ArcPlane(rho=angle_step * rho_idx)\n else:\n rho_start_plane = optics.arcplane.ArcPlane(rho=0.0)\n rho_end_plane = optics.arcplane.ArcPlane(rho=angle_step)\n prev_patches = [patch for patch in (prev_mu_patch, prev_rho_patch) if patch != None]\n \n #figure out the screen and shell point\n shell_point = get_shell_point(prev_patches, mu_start_plane.angle, rho_start_plane.angle)\n screen_point = get_focal_point(prev_patches, shell_point)\n \n return optics.patch.create_patch(\n shell_point,\n screen_point,\n mu_start_plane,\n mu_end_plane,\n rho_start_plane,\n rho_end_plane,\n prev_mu_patch,\n prev_rho_patch\n )\n \n def on_patch_completed(patch):\n \"\"\"\n Figures out which new patch requests to create and add to the list of requests\n \"\"\"\n on_new_patch(patch)\n all_patches.append(patch)\n \n #stick them into a grid (because we need to know when adjacent ones have been enabled)\n (mu, rho) = grid_index(patch)\n patch_grid[(mu, rho)] = patch\n for offset_mu, offset_rho in (\n ( 1, 1),\n ( 1, -1),\n (-1, -1),\n (-1, 1),\n ):\n if (mu+offset_mu, rho+offset_rho) not in patch_grid:\n if (mu+offset_mu, rho) in patch_grid and (mu, rho+offset_rho) in patch_grid:\n patch_requests.append((mu+offset_mu, rho+offset_rho))\n \n #enable horizontal and vertical arcs\n if patch.mu_start_plane.angle == 0.0 and math.fabs(patch.mu_start_plane.angle) < max_angle:\n if (mu, rho-1) not in patch_grid:\n patch_requests.append((mu, rho-1))\n if (mu, rho+1) not in patch_grid:\n patch_requests.append((mu, rho+1))\n if patch.rho_start_plane.angle == 0.0 and math.fabs(patch.rho_start_plane.angle) < max_angle:\n if (mu-1, rho) not in patch_grid:\n patch_requests.append((mu-1, rho))\n if (mu+1, rho) not in patch_grid:\n patch_requests.append((mu+1, rho))\n\n #start off the process with the first patch\n central_patch = _create_patch_for_index((0.0, 0.0))\n on_patch_completed(central_patch)\n \n #continuously process new patches while there are any remaining requests\n while len(patch_requests) > 0:\n request = patch_requests.pop(0)\n on_patch_completed(_create_patch_for_index(request))\n \n return all_patches","def make_nsided(edges, continuity=\"C0\", points=None):\n fill = BRepFill_Filling()\n\n # A helper function to convert strings to Geom_Abs_ enums\n def str_to_continuity(string):\n if string == \"C0\":\n return GeomAbs_C0\n elif string == \"C1\":\n return GeomAbs_C1\n elif string == \"G1\":\n return GeomAbs_G1\n elif string == \"C2\":\n return GeomAbs_C2\n elif string == \"G2\":\n return GeomAbs_G2\n elif string == \"C3\":\n return GeomAbs_C3\n\n if isinstance(continuity, str):\n assert continuity in (\"C0\", \"C1\", \"C2\")\n occ_continuity = str_to_continuity(continuity)\n for edg in edges:\n fill.Add(edg.topods_shape(), occ_continuity)\n elif isinstance(continuity, list):\n assert len(edges) == len(continuity), \"Continuity should be provided for each edge\"\n for edg, cont in zip(edges, continuity):\n occ_cont = str_to_continuity(cont)\n fill.Add(edg.topods_shape(), occ_cont)\n\n # Add points to contrain shape if provided\n if points:\n for pt in points:\n fill.Add(geom_utils.to_gp_pnt(pt))\n fill.Build()\n face = fill.Face()\n return Face(face)","def walls_cc(lenght, width, wall_height=3, roof_height=4):\n a = min(0.1*lenght, 0.1*width, 0.4*(wall_height+0.5*roof_height))\n trian = 0.5*width*roof_height\n trian_5 = 0.5*a*a*(wall_height/roof_height)\n # trian_4 = trian - 2*trian_5\n\n area = (lenght + width)*2*wall_height + 2*trian\n area_5 = 8*a*wall_height + 4*trian_5\n area_4 = area - area_5\n\n return area, area_4, area_5","def test_400_swift_backed_image_create(self):\n u.log.debug('Checking swift objects and containers with a '\n 'swift-backed glance image...')\n\n # Create swift-backed glance image\n img_new = u.create_cirros_image(self.glance, \"cirros-image-1\")\n img_id = img_new.id\n img_md5 = img_new.checksum\n img_size = img_new.size\n\n # Validate that swift object's checksum/size match that from glance\n headers, containers = self.swift.get_account()\n if len(containers) != 1:\n msg = \"Expected 1 swift container, found {}\".format(\n len(containers))\n amulet.raise_status(amulet.FAIL, msg=msg)\n\n container_name = containers[0].get('name')\n\n headers, objects = self.swift.get_container(container_name)\n if len(objects) != 1:\n msg = \"Expected 1 swift object, found {}\".format(len(objects))\n amulet.raise_status(amulet.FAIL, msg=msg)\n\n swift_object_size = objects[0].get('bytes')\n swift_object_md5 = objects[0].get('hash')\n\n if img_size != swift_object_size:\n msg = \"Glance image size {} != swift object size {}\".format(\n img_size, swift_object_size)\n amulet.raise_status(amulet.FAIL, msg=msg)\n\n if img_md5 != swift_object_md5:\n msg = \"Glance image hash {} != swift object hash {}\".format(\n img_md5, swift_object_md5)\n amulet.raise_status(amulet.FAIL, msg=msg)\n\n # Cleanup\n u.delete_resource(self.glance.images, img_id, msg=\"glance image\")\n u.log.info('OK')","def calculate_shape(self):\n\n # error handling\n if self.radius <= 0: raise ValueError(\"Radius must be positive.\")\n if self.inner_radius < 0: raise ValueError(\"Inner radius must not be negative\")\n if self.inner_radius > self.radius: raise ValueError(\"Inner radius must be smaller than radius\")\n if self.thickness <= 0: raise ValueError(\"Thickness must be positive\")\n\n self.area = pi * self.radius ** 2\n self.area -= pi * self.inner_radius ** 2\n\n self.volume = self.area * self.thickness","def smear_coolant_wirewrap(info):\n height = info[0]\n fuel_radius = info[1] / 2\n wirewrap_radius = info[2] / 2\n wire_wrap_axial_pitch = info[3]\n fuel_pitch = info[4]\n coolant_material = info[5]\n clad_material = info[6]\n fuel_volume = utilities.get_cylinder_volume(fuel_radius, height)\n wire_wrap_volume = utilities.get_toroidal_volume(fuel_radius, wirewrap_radius, wire_wrap_axial_pitch, height)\n pin_hexagonal_universe_volume = utilities.get_hexagonal_prism_volume(fuel_pitch, height)\n coolant_volume = pin_hexagonal_universe_volume - fuel_volume - wire_wrap_volume\n total_coolant_wire_wrap_volume = coolant_volume + wire_wrap_volume\n wire_wrap_volume_percent = wire_wrap_volume / total_coolant_wire_wrap_volume\n coolant_volume_percent = coolant_volume / total_coolant_wire_wrap_volume\n smeared_material_dict = {clad_material: wire_wrap_volume_percent, coolant_material: coolant_volume_percent}\n return smeared_material_dict","def test_create_polygon_with_bad_poly_data_fails(self, api_client):\n url = self.base_url + \"/polygons/\"\n prov = baker.make(Provider)\n data = {\n \"name\": \"NRB\",\n \"price\": 930,\n \"provider\": prov.id,\n \"poly\": \"-98.503358 -29.335668, -98.503086 29.335668, -98.503086 29.335423, -98.503358 29.335423, -98.503358 29.335668\" # noqa\n }\n response = api_client().post(url, data)\n assert response.status_code == 400\n assert 'Points of LinearRing do not form a closed linestring.' in response.data['poly']","def cmd_cb():\n cmds = []\n #cmds.append(\"r_m[0.0,-1,1]\")\n cmds.append(\"r_m[0.0]\")\n cmds.append('r_a[1.7,0,10]')\n cmds.append('r_n[1.5,0,10]')\n cmds.append(\"r_s[2.5,0,10]\")\n cmds.append('RooCBShape::res(x,r_m,r_s,r_a,r_n)')\n return cmds","def stokes_right_circular():\n return np.array([1, 0, 0, 1])","def oss_stacked(block, cut, laser):\r\n\tx0_1, x1_1, z0_1, taper_x_1, taper_y_1, layers_1, pyramid_angle_1 = oss_helper(block, cut, laser, cut[\"final_dimension_x\"]/2)\r\n\tx0_2, x1_2, z0_2, taper_x_2, taper_y_2, layers_2, pyramid_angle_2 = oss_helper(block, cut, laser, cut[\"final_dimension_y\"]/2)\r\n\tangle = math.radians(laser[\"kerf_angle\"]/2)\r\n\tgap = math.tan(pyramid_angle_1) * (cut[\"final_dimension_x\"]/2) + cut[\"gap_size\"]\r\n\tunit_length = gap + cut[\"base_height\"]\r\n\tmax_slices = math.floor(block[\"thickness\"]/unit_length)\r\n\ttaper_straight = math.tan(angle)*(laser[\"z_spacing\"])\r\n\r\n\tif cut[\"core\"] == \"yes\":\r\n\t\tcutlist = json.loads(vertical_core(block,cut,laser))\r\n\t\tcutlist.pop()\r\n\t\tcutlist.pop(0)\r\n\telse:\r\n\t\tcutlist = []\r\n\r\n\ta0 = -(90 + math.degrees(angle))\r\n\r\n\tz_shift = (cut[\"base_height\"] + gap) * math.sin(angle)\r\n\tx_shift = (cut[\"base_height\"] + gap) * math.cos(angle)\r\n\r\n\tx_delta = math.sin(angle) * block[\"origin_x\"]\r\n\ty_delta = math.sin(angle) * block[\"origin_y\"]\r\n\tz1_delta = math.cos(angle) * block[\"origin_x\"]\r\n\tz2_delta = math.cos(angle) * block[\"origin_y\"]\r\n\r\n\tcutlist.append([\"a_abs\",f\"{a0:.6f}\"])\r\n\tcutlist.append([\"c_abs\",str(block[\"physical_rotation\"])])\r\n\tcutlist.append([\"z_abs\",str(z0_1 + z2_delta)])\r\n\r\n\tif pyramid_angle_1 >= angle and pyramid_angle_2 >= angle:\r\n\r\n\t\tif cut[\"num_of_seeds\"] == \"max\":\r\n\t\t\tnum_slices = max_slices\r\n\t\telse:\r\n\t\t\tnum_slices = cut[\"num_of_seeds\"] + 1\r\n\t\t\r\n\t\tfor i in range(num_slices):\r\n\t\t\tcutlist = (cutlist\r\n\t\t\t\t\t\t + pyramid_slice(cut[\"final_dimension_y\"]/2 - block[\"origin_x\"],x0_1 + y_delta,-cut[\"final_dimension_y\"]/2 - block[\"origin_x\"],x1_1 + y_delta,z0_1 + block[\"origin_y\"],laser[\"xy_spacing\"], laser[\"z_spacing\"], taper_x_1,taper_y_1,taper_straight,layers_1)\r\n\t\t\t\t\t\t + [[\"z_abs\",str(z0_2 + z1_delta)]] + [[\"c_abs\",\"90\"]]\r\n\t\t\t\t\t\t + pyramid_slice(cut[\"final_dimension_x\"]/2 + block[\"origin_y\"],x0_2 + x_delta,-cut[\"final_dimension_x\"]/2 + block[\"origin_y\"],x1_2 + x_delta,z0_2 + block[\"origin_x\"],laser[\"xy_spacing\"], laser[\"z_spacing\"], taper_x_2,taper_y_2,taper_straight,layers_2)\r\n\t\t\t\t\t\t + [[\"z_abs\",str(z0_1 - z2_delta)]] + [[\"c_abs\",\"180\"]]\r\n\t\t\t\t\t\t + pyramid_slice(cut[\"final_dimension_y\"]/2 + block[\"origin_x\"],x0_1 - y_delta,-cut[\"final_dimension_y\"]/2 + block[\"origin_x\"],x1_1 - y_delta,z0_1 - block[\"origin_y\"],laser[\"xy_spacing\"], laser[\"z_spacing\"], taper_x_1,taper_y_1,taper_straight,layers_1)\r\n\t\t\t\t\t\t + [[\"z_abs\",str(z0_2 - z1_delta)]] + [[\"c_abs\",\"270\"]]\r\n\t\t\t\t\t\t + pyramid_slice(cut[\"final_dimension_x\"]/2 - block[\"origin_y\"],x0_2 - x_delta,-cut[\"final_dimension_x\"]/2 - block[\"origin_y\"],x1_2 - x_delta,z0_2 - block[\"origin_x\"],laser[\"xy_spacing\"], laser[\"z_spacing\"], taper_x_2,taper_y_2,taper_straight,layers_2)\r\n\t\t\t\t\t\t )\r\n\t\t\tz0_1 = z0_1 + z_shift\r\n\t\t\tz0_2 = z0_2 + z_shift\r\n\t\t\tx0_1, x1_1, x0_2, x1_2 = x0_1 - x_shift, x1_1 - x_shift, x0_2 - x_shift, x1_2 - x_shift\r\n\t\t\tcutlist.append([\"c_abs\",str(block[\"physical_rotation\"])])\r\n\t\t\tcutlist.append([\"z_abs\",str(z0_1 + z2_delta)])\t\r\n\telse:\r\n\t\traise Exception(\"Pyramid angle too small\")\r\n\r\n\tcutlist.insert(0, [\"set_trigger4\", \"1\", \"0\", \"7\", \"8\", \"45\"])\r\n\tcutlist.append([\"stop_trigger\"])\r\n\treturn json.dumps(cutlist)","def test_QuadTreeStructureSingleRing(self):\n ring_texas = Ring([\n (-105.99835968, 31.3938179016), (-106.212753296, 31.4781284332), (-106.383041382, 31.7337627411),\n (-106.538970947, 31.7861976624), (-106.614440918, 31.8177280426), (-106.615577698, 31.8446350098),\n (-106.643531799, 31.8951015472), (-106.633201599, 31.9139976501), (-106.63205719, 31.9721183777),\n (-106.649513245, 31.9802284241), (-106.623077393, 32.0009880066), (-106.377845764, 32.0006446838),\n (-106.002708435, 32.0015525818), (-104.921798706, 32.0042686462), (-104.850563049, 32.0031509399),\n (-104.018814087, 32.0072784424), (-103.980895996, 32.0058898926), (-103.728973389, 32.0061035156),\n (-103.332092285, 32.0041542053), (-103.05796814, 32.0018997192), (-103.05519104, 32.0849952698),\n (-103.059547424, 32.5154304504), (-103.048835754, 32.9535331726), (-103.042602539, 33.3777275085),\n (-103.038238525, 33.5657424927), (-103.03276062, 33.8260879517), (-103.029144287, 34.3077430725),\n (-103.022155762, 34.7452659607), (-103.024749756, 34.964717865), (-103.025650024, 35.1772079468),\n (-103.02179718, 35.6236038208), (-103.022117615, 35.7422866821), (-103.02355957, 36.0560264587),\n (-103.026802063, 36.4915657043), (-102.996917725, 36.4923439026), (-102.165222168, 36.4902076721),\n (-102.034210205, 36.4929542542), (-101.620315552, 36.4920043945), (-101.089668274, 36.4880218506),\n (-100.95690918, 36.4896087646), (-100.549415588, 36.4894485474), (-100.006866455, 36.4938774109),\n (-100.001144409, 36.4925193787), (-99.9971542358, 36.0575485229), (-99.9977264404, 35.8837928772),\n (-100.0, 35.6188087463), (-99.994354248, 35.424571991), (-99.9971847534, 35.182182312),\n (-99.9960708618, 35.03099823), (-99.998878479, 34.7471847534), (-99.99609375, 34.5623207092),\n (-99.9720993042, 34.5618629456), (-99.9447402954, 34.5795707703), (-99.9319076538, 34.5791091919),\n (-99.8805999756, 34.5481758118), (-99.8605728149, 34.5186271667), (-99.8299331665, 34.5017776489),\n (-99.7776870728, 34.4439926147), (-99.6849060059, 34.3774452209), (-99.6014480591, 34.3685569763),\n (-99.5852203369, 34.3848571777), (-99.5778503418, 34.4089126587), (-99.5538635254, 34.4151802063),\n (-99.5021362305, 34.4040679932), (-99.4794387817, 34.3835220337), (-99.4383773804, 34.3647041321),\n (-99.4099578857, 34.3691062927), (-99.3941574097, 34.3967437744), (-99.392791748, 34.4289932251),\n (-99.3642044067, 34.4501953125), (-99.3232955933, 34.4127082825), (-99.2671737671, 34.3982849121),\n (-99.2541046143, 34.3682136536), (-99.2054901123, 34.331993103), (-99.1963043213, 34.3051223755),\n (-99.2045974731, 34.255645752), (-99.1904830933, 34.2237358093), (-99.1761550903, 34.2127304077),\n (-99.1279449463, 34.2014694214), (-99.0784301758, 34.2083587646), (-99.0352172852, 34.1989212036),\n (-98.9961929321, 34.2094955444), (-98.952507019, 34.1945648193), (-98.8913421631, 34.1608200073),\n (-98.8110656738, 34.1459350586), (-98.7785339355, 34.1319618225), (-98.705291748, 34.1307144165),\n (-98.6822128296, 34.1499977112), (-98.6617202759, 34.1470375061), (-98.6259918213, 34.1584358215),\n (-98.6072463989, 34.1513977051), (-98.5763320923, 34.1419296265), (-98.5575790405, 34.1053352356),\n (-98.4995193481, 34.0664138794), (-98.4481887817, 34.0543746948), (-98.4213409424, 34.0658302307),\n (-98.4071350098, 34.0824546814), (-98.390953064, 34.0872306824), (-98.3842544556, 34.1157798767),\n (-98.350402832, 34.1421203613), (-98.3204879761, 34.1394195557), (-98.2770004272, 34.1228713989),\n (-98.1728439331, 34.1153678894), (-98.1368637085, 34.1384315491), (-98.1148681641, 34.1489868164),\n (-98.0941238403, 34.1345558167), (-98.1106872559, 34.0698204041), (-98.0862045288, 34.0053138733),\n (-98.055557251, 33.9897994995), (-98.0234909058, 33.9869842529), (-97.9826812744, 34.001285553),\n (-97.9502258301, 33.9711608887), (-97.9477539062, 33.9597511292), (-97.9629974365, 33.9486503601),\n (-97.9506835938, 33.9325180054), (-97.9761276245, 33.9120521545), (-97.9763793945, 33.9025039673),\n (-97.9547348022, 33.883480072), (-97.9090652466, 33.8740234375), (-97.8697509766, 33.8551139832),\n (-97.8525466919, 33.8570709229), (-97.7902069092, 33.8904571533), (-97.756362915, 33.9320983887),\n (-97.729019165, 33.9392929077), (-97.7042617798, 33.9715461731), (-97.6710662842, 33.9886131287),\n (-97.6001815796, 33.9694366455), (-97.5923538208, 33.9178848267), (-97.575668335, 33.9025306702),\n (-97.5545883179, 33.9039039612), (-97.5182037354, 33.9167709351), (-97.4775314331, 33.9077072144),\n (-97.4627609253, 33.902381897), (-97.4570617676, 33.8904304504), (-97.4527359009, 33.8362121582),\n (-97.410118103, 33.8207092285), (-97.363319397, 33.8310241699), (-97.3418045044, 33.8619155884),\n (-97.314956665, 33.8703918457), (-97.3140869141, 33.8958396912), (-97.272277832, 33.8725738525),\n (-97.2639083862, 33.8587303162), (-97.2506866455, 33.8729705811), (-97.2460632324, 33.8942375183),\n (-97.2113342285, 33.9056892395), (-97.1877670288, 33.8992042542), (-97.1641693115, 33.8631477356),\n (-97.1685943604, 33.8477935791), (-97.1950149536, 33.8361587524), (-97.2083206177, 33.8196487427),\n (-97.189163208, 33.7527694702), (-97.1524734497, 33.7286682129), (-97.115562439, 33.725933075),\n (-97.0904998779, 33.7316703796), (-97.0834655762, 33.7424125671), (-97.0876693726, 33.8075714111),\n (-97.0500259399, 33.8234481812), (-97.0782470703, 33.8378105164), (-97.0821762085, 33.8511009216),\n (-97.0708999634, 33.8567276001), (-97.0255966187, 33.8405609131), (-97.0058517456, 33.8505134583),\n (-96.9877090454, 33.8764228821), (-96.9878616333, 33.9442024231), (-96.9681854248, 33.9373207092),\n (-96.9362030029, 33.9478492737), (-96.9295654297, 33.9617729187), (-96.8984527588, 33.9500274658),\n (-96.882850647, 33.9245910645), (-96.8789367676, 33.8840026855), (-96.8610153198, 33.8616790771),\n (-96.8440093994, 33.8580322266), (-96.8141174316, 33.8717689514), (-96.7975921631, 33.8699493408),\n (-96.7488250732, 33.8317375183), (-96.7116775513, 33.8338699341), (-96.6933822632, 33.8479042053),\n (-96.6777038574, 33.9043235779), (-96.6662368774, 33.9135437012), (-96.584487915, 33.8961448669),\n (-96.6141662598, 33.8628997803), (-96.6011962891, 33.842956543), (-96.5621337891, 33.8254203796),\n (-96.5105743408, 33.8156852722), (-96.5007476807, 33.7880897522), (-96.4873733521, 33.7781295776),\n (-96.4194641113, 33.7883262634), (-96.3708190918, 33.7403945923), (-96.3475875854, 33.7055282593),\n (-96.3162765503, 33.7018013), (-96.3007888794, 33.714050293), (-96.289680481, 33.761932373),\n (-96.2780761719, 33.7733879089), (-96.2125473022, 33.756690979), (-96.1870269775, 33.7585830688),\n (-96.1688156128, 33.7693557739), (-96.161315918, 33.7982292175), (-96.141418457, 33.8203201294),\n (-96.1545181274, 33.8239440918), (-96.1807250977, 33.8084335327), (-96.1831283569, 33.8157920837),\n (-96.1692047119, 33.8289833069), (-96.1489639282, 33.8355903625), (-96.1094436646, 33.8292579651),\n (-96.0915222168, 33.8445777893), (-96.0479736328, 33.8412780762), (-96.0267486572, 33.8560218811),\n (-96.0140686035, 33.8442077637), (-96.0017929077, 33.8569793701), (-96.0026168823, 33.8733901978),\n (-95.9942092896, 33.875377655), (-95.977394104, 33.8579521179), (-95.9587631226, 33.8650398254),\n (-95.943069458, 33.8899726868), (-95.9330749512, 33.8905296326), (-95.8465576172, 33.8410377502),\n (-95.8259735107, 33.8430252075), (-95.7954788208, 33.8646736145), (-95.7685165405, 33.8514022827),\n (-95.764251709, 33.8790054321), (-95.7606964111, 33.8934402466), (-95.7468643188, 33.9033966064),\n (-95.6997070312, 33.8948249817), (-95.6334915161, 33.9201049805), (-95.6129837036, 33.9202384949),\n (-95.6148300171, 33.9366912842), (-95.6060714722, 33.9445533752), (-95.5627746582, 33.9360733032),\n (-95.5463180542, 33.9040336609), (-95.5195770264, 33.9066429138), (-95.5267333984, 33.8978157043),\n (-95.547492981, 33.893157959), (-95.5440368652, 33.8857421875), (-95.5128860474, 33.8977355957),\n (-95.4988555908, 33.8817176819), (-95.4681243896, 33.8864326477), (-95.4516067505, 33.8657531738),\n (-95.330039978, 33.8709182739), (-95.336227417, 33.8971138), (-95.3019561768, 33.8866233826),\n (-95.2864303589, 33.8869018555), (-95.2773513794, 33.9179382324), (-95.2636184692, 33.8978004456),\n (-95.2509918213, 33.9050216675), (-95.2512893677, 33.9364433289), (-95.2340393066, 33.9648628235),\n (-95.1483154297, 33.9435462952), (-95.1279678345, 33.9408683777), (-95.1266784668, 33.9171447754),\n (-95.1192245483, 33.9122810364), (-95.0953598022, 33.9217376709), (-95.0822677612, 33.9184532166),\n (-95.0897140503, 33.8969154358), (-95.0836029053, 33.8884620667), (-95.0634765625, 33.9176483154),\n (-95.0631408691, 33.8966941833), (-95.0428619385, 33.8844451904), (-95.037361145, 33.8664512634),\n (-95.0127716064, 33.8699455261), (-94.9892807007, 33.8561820984), (-94.9687042236, 33.8662147522),\n (-94.9599075317, 33.8480758667), (-94.9398880005, 33.8408241272), (-94.9403991699, 33.8158073425),\n (-94.9182357788, 33.8161964417), (-94.9085464478, 33.803478241), (-94.9138793945, 33.7895965576),\n (-94.8816375732, 33.7749633789), (-94.8578796387, 33.7493209839), (-94.8191604614, 33.7494049072),\n (-94.8032226562, 33.7395820618), (-94.7835083008, 33.7532615662), (-94.764175415, 33.7528419495),\n (-94.7820281982, 33.7422676086), (-94.7831573486, 33.7336654663), (-94.7497711182, 33.73670578),\n (-94.7627182007, 33.716796875), (-94.7421112061, 33.7190475464), (-94.7544784546, 33.7077713013),\n (-94.7416534424, 33.7012672424), (-94.6909866333, 33.6902885437), (-94.6684570312, 33.6965370178),\n (-94.6554794312, 33.6922912598), (-94.6443252563, 33.6776504517), (-94.6679534912, 33.671459198),\n (-94.6694259644, 33.6660614014), (-94.6585388184, 33.6637382507), (-94.6387634277, 33.6701049805),\n (-94.6317367554, 33.6838989258), (-94.600944519, 33.6656074524), (-94.585105896, 33.678981781),\n (-94.5785064697, 33.6704711914), (-94.5607223511, 33.671913147), (-94.5652084351, 33.6630134583),\n (-94.5851593018, 33.6621322632), (-94.5883865356, 33.6554489136), (-94.576461792, 33.6521568298),\n (-94.5454177856, 33.6616210938), (-94.5419311523, 33.6482467651), (-94.5621948242, 33.642829895),\n (-94.5621490479, 33.6355361938), (-94.5501937866, 33.6326942444), (-94.5179901123, 33.6430091858),\n (-94.5250549316, 33.6210212708), (-94.510559082, 33.6308097839), (-94.5006103516, 33.623046875),\n (-94.4764862061, 33.6319656372), (-94.4359130859, 33.6364440918), (-94.4363327026, 33.6168441772),\n (-94.4515533447, 33.604347229), (-94.4433288574, 33.5965042114), (-94.4284667969, 33.5971412659),\n (-94.4065704346, 33.5734863281), (-94.3934173584, 33.5749588013), (-94.3791122437, 33.5933265686),\n (-94.3706283569, 33.5900421143), (-94.3723068237, 33.5726623535), (-94.3952636719, 33.5603027344),\n (-94.3707580566, 33.5476837158), (-94.3287506104, 33.573135376), (-94.3023834229, 33.5569343567),\n (-94.2988204956, 33.5798530579), (-94.2789840698, 33.5893325806), (-94.2720794678, 33.5846061707),\n (-94.2745437622, 33.5617370605), (-94.2372360229, 33.5924224854), (-94.2230377197, 33.5857200623),\n (-94.2353668213, 33.5615348816), (-94.2108840942, 33.5579872131), (-94.2053451538, 33.5850791931),\n (-94.1595153809, 33.5937728882), (-94.155166626, 33.5670852661), (-94.0987014771, 33.5729980469),\n (-94.0866546631, 33.5839538574), (-94.0614318848, 33.5772132874), (-94.0359268188, 33.5559120178),\n (-94.0365066528, 33.270324707), (-94.0387496948, 33.0232887268), (-94.0416030884, 32.8823471069),\n (-94.0401992798, 32.6948127747), (-94.0352325439, 32.3892250061), (-94.0347671509, 32.1994476318),\n (-94.0350646973, 31.994512558), (-94.0098876953, 31.9891338348), (-94.0043945312, 31.9779415131),\n (-93.9772109985, 31.9461593628), (-93.9699859619, 31.9231643677), (-93.9357299805, 31.9094562531),\n (-93.9179229736, 31.909702301), (-93.9234619141, 31.8925933838), (-93.8992614746, 31.8944549561),\n (-93.8925247192, 31.8700656891), (-93.8812637329, 31.8714199066), (-93.8774032593, 31.850112915),\n (-93.8648223877, 31.8172721863), (-93.8343276978, 31.8020172119), (-93.8220672607, 31.7746372223),\n (-93.831161499, 31.7532806396), (-93.8099899292, 31.7303524017), (-93.8149490356, 31.7123508453),\n (-93.8087692261, 31.7075653076), (-93.7922668457, 31.7113952637), (-93.8118438721, 31.6745662689),\n (-93.806427002, 31.6537666321), (-93.8147277832, 31.6479663849), (-93.8195877075, 31.6180915833),\n (-93.8355789185, 31.6151885986), (-93.8326187134, 31.5901832581), (-93.8163223267, 31.5771102905),\n (-93.8105163574, 31.5590629578), (-93.780128479, 31.5337352753), (-93.7633056641, 31.5307235718),\n (-93.747543335, 31.5377178192), (-93.7316589355, 31.5218772888), (-93.7057952881, 31.5205688477),\n (-93.7189941406, 31.4954032898), (-93.7504348755, 31.4905567169), (-93.7512435913, 31.4855003357),\n (-93.7267837524, 31.4594745636), (-93.6984176636, 31.4614582062), (-93.7019271851, 31.4462509155),\n (-93.6870040894, 31.4381313324), (-93.6961288452, 31.4277362823), (-93.694442749, 31.4159221649),\n (-93.6874923706, 31.406129837), (-93.6640167236, 31.3983287811), (-93.6610717773, 31.3723945618),\n (-93.6348571777, 31.3738269806), (-93.6770401001, 31.3283863068), (-93.6815872192, 31.3126792908),\n (-93.6561279297, 31.2866706848), (-93.6455917358, 31.2902622223), (-93.6308288574, 31.2739028931),\n (-93.6164550781, 31.2758045197), (-93.6118774414, 31.2700328827), (-93.611000061, 31.2421875),\n (-93.5905456543, 31.2296867371), (-93.6029205322, 31.1990661621), (-93.5939407349, 31.1801986694),\n (-93.5769424438, 31.1721401215), (-93.5505905151, 31.1909294128), (-93.5289230347, 31.1857738495),\n (-93.5269317627, 31.1780757904), (-93.5370178223, 31.1763401031), (-93.5283279419, 31.1629428864),\n (-93.5441894531, 31.1591663361), (-93.5375061035, 31.132440567), (-93.5280914307, 31.1259250641),\n (-93.5350875854, 31.116071701), (-93.556678772, 31.1093425751), (-93.5599822998, 31.1005363464),\n (-93.5431213379, 31.094751358), (-93.5441055298, 31.0823726654), (-93.516998291, 31.0746707916),\n (-93.5257415771, 31.0569801331), (-93.5072174072, 31.0389080048), (-93.5471191406, 31.0141410828),\n (-93.5649414062, 31.0180625916), (-93.5678939819, 31.0129241943), (-93.5708465576, 30.9972705841),\n (-93.5609512329, 30.991689682), (-93.5724563599, 30.9761772156), (-93.5486755371, 30.9701900482),\n (-93.5373382568, 30.9568843842), (-93.5321884155, 30.9607315063), (-93.5256195068, 30.9358196259),\n (-93.5299835205, 30.9269714355), (-93.549621582, 30.9248847961), (-93.5465164185, 30.9053344727),\n (-93.5644760132, 30.9019317627), (-93.5684967041, 30.8862342834), (-93.5608444214, 30.8718795776),\n (-93.5528030396, 30.8602828979), (-93.566444397, 30.8451480865), (-93.5556411743, 30.8423423767),\n (-93.5506820679, 30.8283443451), (-93.5818710327, 30.8020401001), (-93.5851745605, 30.7721843719),\n (-93.6184539795, 30.7457885742), (-93.6076507568, 30.7320098877), (-93.6177902222, 30.73254776),\n (-93.612411499, 30.7103290558), (-93.6176071167, 30.6868019104), (-93.6599884033, 30.6728591919),\n (-93.6779708862, 30.6396923065), (-93.6928787231, 30.6400413513), (-93.6845855713, 30.62342453),\n (-93.6926956177, 30.6157951355), (-93.671585083, 30.5978317261), (-93.6934204102, 30.5988349915),\n (-93.7178115845, 30.5873794556), (-93.717880249, 30.5681533813), (-93.7353057861, 30.5455169678),\n (-93.7054595947, 30.522857666), (-93.7146377563, 30.5051136017), (-93.7072753906, 30.4962406158),\n (-93.7148513794, 30.4886283875), (-93.6979751587, 30.4700469971), (-93.7034225464, 30.46251297),\n (-93.6965713501, 30.4426326752), (-93.721534729, 30.4329795837), (-93.7425613403, 30.4088230133),\n (-93.7549438477, 30.3817882538), (-93.747833252, 30.3674106598), (-93.7593383789, 30.35414505),\n (-93.7591781616, 30.3408718109), (-93.7297744751, 30.3049163818), (-93.6992111206, 30.2973880768),\n (-93.707359314, 30.2393722534), (-93.71484375, 30.2203063965), (-93.7043609619, 30.1808605194),\n (-93.6961669922, 30.1756763458), (-93.6996612549, 30.1508083344), (-93.6831436157, 30.1482315063),\n (-93.6859588623, 30.1412525177), (-93.698638916, 30.1412258148), (-93.6969223022, 30.1179294586),\n (-93.7083816528, 30.1147403717), (-93.7158584595, 30.0956687927), (-93.7124786377, 30.0605201721),\n (-93.7602005005, 30.0059642792), (-93.8572769165, 29.9906539917), (-93.8563308716, 29.9646015167),\n (-93.9517669678, 29.8183631897), (-93.8349609375, 29.6745700836), (-94.0654067993, 29.6740760803),\n (-94.3569946289, 29.5599002838), (-94.3770065308, 29.5519695282), (-94.6825180054, 29.4329051971),\n (-94.7665481567, 29.363992691), (-94.7852478027, 29.3832607269), (-94.6819152832, 29.4751110077),\n (-94.5726928711, 29.5330524445), (-94.5012817383, 29.5175228119), (-94.4697952271, 29.5567798615),\n (-94.5108108521, 29.5451469421), (-94.5336990356, 29.5539836884), (-94.5644378662, 29.5789985657),\n (-94.7880859375, 29.5385570526), (-94.7064208984, 29.6585159302), (-94.7002792358, 29.7545681),\n (-94.7357254028, 29.7929859161), (-94.8294143677, 29.7598571777), (-94.8871612549, 29.6685390472),\n (-94.9325866699, 29.6822090149), (-95.0882644653, 29.8039798737), (-95.040397644, 29.7115783691),\n (-94.9893341064, 29.6797008514), (-95.0141220093, 29.5592651367), (-94.9111557007, 29.500333786),\n (-94.9828109741, 29.46052742), (-94.9437561035, 29.4646816254), (-94.952507019, 29.4242343903),\n (-94.913444519, 29.4201126099), (-94.9169921875, 29.4478225708), (-94.8911361694, 29.3993244171),\n (-94.8153533936, 29.3709316254), (-94.8914718628, 29.3938312531), (-94.8987884521, 29.3087749481),\n (-94.951133728, 29.3259220123), (-95.066368103, 29.1958770752), (-95.1605224609, 29.2000312805),\n (-95.1647796631, 29.1175479889), (-95.1973419189, 29.105222702), (-95.2484054565, 28.9783916473),\n (-95.5265808105, 28.8032417297), (-95.6830291748, 28.7269535065), (-95.6713180542, 28.7526817322),\n (-95.7863540649, 28.7388706207), (-95.9373092651, 28.690454483), (-95.9561462402, 28.6226730347),\n (-95.7021484375, 28.7189865112), (-96.2065811157, 28.4883861542), (-95.991645813, 28.5964241028),\n (-95.9837493896, 28.6531333923), (-96.2375869751, 28.5713214874), (-96.2390289307, 28.5971164703),\n (-96.1574707031, 28.6112308502), (-96.2404556274, 28.6348590851), (-96.1510620117, 28.7626724243),\n (-96.2121734619, 28.6867198944), (-96.2859725952, 28.6617240906), (-96.2703781128, 28.7089805603),\n (-96.3261566162, 28.6340885162), (-96.3641586304, 28.617980957), (-96.3917770386, 28.6702518463),\n (-96.3927307129, 28.7260284424), (-96.4270858765, 28.7120132446), (-96.4496765137, 28.7550354004),\n (-96.432258606, 28.6972484589), (-96.4033966064, 28.719493866), (-96.4187850952, 28.6386642456),\n (-96.3753967285, 28.6100883484), (-96.4912033081, 28.5569438934), (-96.4371566772, 28.5969905853),\n (-96.4543838501, 28.6559333801), (-96.4832687378, 28.5980548859), (-96.5118942261, 28.6081809998),\n (-96.5117340088, 28.6495418549), (-96.5703964233, 28.6362667084), (-96.5705566406, 28.6918411255),\n (-96.5722122192, 28.8081741333), (-96.5764846802, 28.6906890869), (-96.5914993286, 28.7173595428),\n (-96.6465148926, 28.7141418457), (-96.6600112915, 28.6790752411), (-96.6067047119, 28.6236343384),\n (-96.6103439331, 28.5589408875), (-96.5667037964, 28.574098587), (-96.486579895, 28.5062217712),\n (-96.5631942749, 28.4696273804), (-96.5185012817, 28.4608268738), (-96.4765014648, 28.4994544983),\n (-96.3907241821, 28.4340591431), (-96.6613082886, 28.30626297), (-96.7023620605, 28.3401966095),\n (-96.7038116455, 28.3958854675), (-96.7407684326, 28.4034576416), (-96.7870941162, 28.4775066376),\n (-96.8238754272, 28.449640274), (-96.7883377075, 28.4462547302), (-96.7591018677, 28.4109115601),\n (-96.7753601074, 28.3916301727), (-96.8534927368, 28.4049968719), (-96.788230896, 28.3524703979),\n (-96.7862701416, 28.3128585815), (-96.7933349609, 28.2713718414), (-96.7779312134, 28.2293491364),\n (-96.8036880493, 28.2114467621), (-96.9509048462, 28.1143550873), (-96.9127197266, 28.2567977905),\n (-96.9753036499, 28.2107505798), (-96.9410705566, 28.1867713928), (-96.9751052856, 28.1150455475),\n (-97.0336151123, 28.1373977661), (-97.0235671997, 28.1997966766), (-97.1318359375, 28.1304264069),\n (-97.1354141235, 28.1618099213), (-97.1679916382, 28.1594600677), (-97.1570587158, 28.1163806915),\n (-97.2602844238, 28.0647239685), (-97.2412338257, 28.0486526489), (-97.2702941895, 28.025932312),\n (-97.2362136841, 28.0405197144), (-97.1230773926, 28.054265976), (-97.0264053345, 28.107749939),\n (-97.0238037109, 28.020236969), (-97.1146240234, 27.9153862), (-97.1954650879, 27.8122196198),\n (-97.2470245361, 27.8223190308), (-97.2133407593, 27.8311100006), (-97.2834854126, 27.8711452484),\n (-97.3610458374, 27.8399543762), (-97.3456192017, 27.8731784821), (-97.4793548584, 27.8529624939),\n (-97.4966812134, 27.8754692078), (-97.521697998, 27.8636264801), (-97.4995346069, 27.8432426453),\n (-97.4798126221, 27.8202819824), (-97.3885421753, 27.8314266205), (-97.3965606689, 27.7708396912),\n (-97.3177947998, 27.7122249603), (-97.3495101929, 27.7153282166), (-97.3200149536, 27.6906337738),\n (-97.3533630371, 27.6408004761), (-97.3992156982, 27.6331863403), (-97.3475036621, 27.631439209),\n (-97.309211731, 27.707862854), (-97.2497940063, 27.6888313293), (-97.3314590454, 27.5623207092),\n (-97.4122619629, 27.321023941), (-97.5004348755, 27.3196678162), (-97.5075378418, 27.4392147064),\n (-97.5283813477, 27.3441009521), (-97.600112915, 27.3001346588), (-97.7500762939, 27.4196662903),\n (-97.6800079346, 27.2943725586), (-97.7847442627, 27.2877197266), (-97.5481567383, 27.2302074432),\n (-97.4272155762, 27.2651329041), (-97.5035018921, 27.0815410614), (-97.4789962769, 26.9965076447),\n (-97.5685653687, 26.9778575897), (-97.558052063, 26.8460521698), (-97.4955749512, 26.7937812805),\n (-97.4516983032, 26.6009845734), (-97.4258575439, 26.5182247162), (-97.4747085571, 26.4768047333),\n (-97.4211883545, 26.3850593567), (-97.3686981201, 26.3590602875), (-97.3533630371, 26.1824493408),\n (-97.2531204224, 26.068315506), (-97.2763214111, 26.0022754669), (-97.2130966187, 26.0090675354),\n (-97.1722259521, 25.9545688629), (-97.307144165, 25.9651241302), (-97.30443573, 25.9386634827),\n (-97.3809890747, 25.9170207977), (-97.3856430054, 25.8453617096), (-97.4343490601, 25.8451976776),\n (-97.5900878906, 25.9332313538), (-97.5749359131, 25.9541721344), (-97.6129226685, 25.9620018005),\n (-97.6479721069, 26.0234451294), (-97.8674316406, 26.0601406097), (-98.0400695801, 26.0593948364),\n (-98.0763473511, 26.0346260071), (-98.0832138062, 26.0657577515), (-98.2006912231, 26.0553760529),\n (-98.2919464111, 26.0981044769), (-98.2713546753, 26.1208953857), (-98.2922744751, 26.1328086853),\n (-98.3279342651, 26.1116466522), (-98.3471908569, 26.1586799622), (-98.3845214844, 26.1560306549),\n (-98.4533920288, 26.220911026), (-98.4885177612, 26.201543808), (-98.5999679565, 26.2604541779),\n (-98.6779174805, 26.2420558929), (-98.8198318481, 26.3750705719), (-98.9088973999, 26.3603286743),\n (-98.9392700195, 26.3953094482), (-99.1067276001, 26.4195308685), (-99.1014709473, 26.4883403778),\n (-99.1686782837, 26.5457286835), (-99.1658172607, 26.5798892975), (-99.2855224609, 26.8573608398),\n (-99.3905181885, 26.9466304779), (-99.3927154541, 26.9955501556), (-99.4550628662, 27.0286483765),\n (-99.4371566772, 27.1991977692), (-99.4652709961, 27.2698841095), (-99.543586731, 27.3186531067),\n (-99.4904937744, 27.4907550812), (-99.5267410278, 27.504283905), (-99.5491867065, 27.6126270294),\n (-99.7144927979, 27.6615581512), (-99.8157272339, 27.7801074982), (-99.8747329712, 27.7976856232),\n (-99.9418563843, 27.9868812561), (-99.993309021, 28.0034599304), (-100.096923828, 28.1542816162),\n (-100.214073181, 28.2019348145), (-100.223464966, 28.2414569855), (-100.297920227, 28.2803535461),\n (-100.292892456, 28.3203601837), (-100.351570129, 28.3941822052), (-100.37677002, 28.4786510468),\n (-100.345802307, 28.5008106232), (-100.419532776, 28.5441913605), (-100.403175354, 28.5897331238),\n (-100.497909546, 28.660987854), (-100.589790344, 28.8942222595), (-100.647224426, 28.9223499298),\n (-100.668769836, 29.080072403), (-100.768608093, 29.1665706635), (-100.796989441, 29.2425022125),\n (-101.009056091, 29.373254776), (-101.067359924, 29.4735527039), (-101.261428833, 29.526473999),\n (-101.254585266, 29.6287498474), (-101.308929443, 29.580909729), (-101.305862427, 29.652431488),\n (-101.368400574, 29.6571617126), (-101.416099548, 29.7454338074), (-101.401275635, 29.7699050903),\n (-101.448425293, 29.7605857849), (-101.470466614, 29.788690567), (-101.538345337, 29.7630176544),\n (-101.543952942, 29.8101196289), (-101.581489563, 29.7651500702), (-101.639671326, 29.7569599152),\n (-101.759094238, 29.7871665955), (-101.805206299, 29.7799987793), (-101.819099426, 29.814125061),\n (-101.924224854, 29.7885017395), (-101.973320007, 29.8187732697), (-102.063995361, 29.784570694),\n (-102.324333191, 29.880115509), (-102.36756134, 29.8452892303), (-102.384796143, 29.7679462433),\n (-102.503097534, 29.7854557037), (-102.551948547, 29.7495002747), (-102.576499939, 29.7782478333),\n (-102.637611389, 29.7323379517), (-102.676361084, 29.7442245483), (-102.804725647, 29.5301456451),\n (-102.82220459, 29.4118442535), (-102.883010864, 29.3533706665), (-102.908325195, 29.269203186),\n (-102.866172791, 29.2290363312), (-102.988098145, 29.1908626556), (-103.153465271, 28.9786815643),\n (-103.266586304, 29.0074539185), (-103.280349731, 28.9863739014), (-103.335517883, 29.0503387451),\n (-103.375450134, 29.0321083069), (-103.474075317, 29.0721340179), (-103.526237488, 29.1466464996),\n (-103.720314026, 29.1906318665), (-103.739852905, 29.230348587), (-103.782157898, 29.2297954559),\n (-103.76776123, 29.2812404633), (-103.786994934, 29.2672595978), (-104.045631409, 29.328119278),\n (-104.164382935, 29.4007148743), (-104.204734802, 29.484041214), (-104.377593994, 29.550611496),\n (-104.535247803, 29.6794662476), (-104.577560425, 29.8079357147), (-104.674369812, 29.9092826843),\n (-104.696495056, 30.057302475), (-104.674758911, 30.1489639282), (-104.702613831, 30.238489151),\n (-104.813957214, 30.3504695892), (-104.806472778, 30.3764476776), (-104.852996826, 30.3922634125),\n (-104.890678406, 30.5705566406), (-104.986930847, 30.6413249969), (-104.997543335, 30.6843338013),\n (-105.060562134, 30.6878700256), (-105.21434021, 30.8120861053), (-105.25818634, 30.7976531982),\n (-105.287597656, 30.831949234), (-105.313781738, 30.8165073395), (-105.390312195, 30.8530807495),\n (-105.409065247, 30.9025096893), (-105.554382324, 30.9982852936), (-105.603218079, 31.0864276886),\n (-105.769729614, 31.1707801819), (-105.99835968, 31.3938179016)\n ])\n qtssr_texas = QuadTreeStructureSingleRing(ring_texas)\n points = [\n [-96.83201838665211, 30.43633054583931, True], [-94.97179271816618, 30.46609834459278, True],\n [-96.87911915799319, 29.002783392404453, True], [-104.03817768478906, 26.080885130466065, False],\n [-101.05107033713017, 26.110092672074, False], [-101.90984946051287, 30.2673660562615, True],\n [-104.2666097673043, 26.638892954348243, False], [-99.00209313228278, 29.312408039204637, True],\n [-96.76821760997925, 26.53415999513266, False], [-103.60734801725461, 25.989562175464958, False],\n [-105.52663947372852, 35.59616356954213, False], [-99.73190928401823, 36.34065757158246, False],\n [-94.28455658519579, 30.510396248421543, True], [-98.287902523108, 32.42446924695663, True],\n [-98.36319041112684, 26.836620743656326, True], [-100.58823300352246, 28.287422480123738, False],\n [-106.09575378559609, 29.647073739534953, False], [-96.03197805726944, 34.67673925196511, False],\n [-106.13189503506499, 28.293328347459486, False], [-105.6163099497765, 34.642876249285806, False],\n [-102.1699840394609, 32.64792829807019, True], [-102.19213396201079, 31.137813785847744, True],\n [-96.8832056156457, 33.584067733298724, True], [-105.47157574361026, 33.89108923934286, False],\n [-101.53889206881809, 27.73095057942401, False], [-95.0730796759137, 26.09464277833887, False],\n [-96.45795032815394, 30.22238046821291, True], [-99.47479689046119, 27.519862201810025, True],\n [-104.95530088407097, 34.46894379454478, False], [-99.64935392553515, 27.166719715093752, False],\n [-101.8740013838435, 35.11537675606412, True], [-99.07039344683601, 33.64951303142618, True],\n [-106.60595918307385, 29.64471250102584, False], [-97.20030616424087, 32.31820772186446, True],\n [-96.23784236099425, 27.638993220475054, False], [-105.93765675735541, 35.89412147712274, False],\n [-97.17726496423283, 28.55515333886519, True], [-101.41972932590615, 26.609185193916016, False],\n [-101.84272804452128, 31.047193869577697, True], [-95.92485433657428, 33.9254034938182, False],\n [-98.09279175575493, 31.486295362051568, True], [-100.77512720701931, 34.5423023937584, True],\n [-105.99024440024378, 32.444411669816, False], [-101.4742991680627, 36.37442042029491, True],\n [-99.91406680649878, 30.44981434916269, True], [-106.59351726840352, 27.830675040946844, False],\n [-100.50108029331473, 28.08692086210316, False], [-106.22266727042927, 28.257938478160245, False],\n [-99.16766510789698, 34.05594801235725, True], [-98.81327349833023, 34.53578673189781, False],\n [-95.75835434832825, 35.97127466623442, False], [-95.87872844572516, 34.1792497663974, False],\n [-97.67138045660111, 28.85228239075667, True], [-103.7493116963675, 29.910102031100415, True],\n [-97.9552991722866, 35.50168101442732, False], [-101.99173352350167, 33.16196427356835, True],\n [-99.69108575797604, 26.58570279334035, False], [-96.1383698450465, 30.01380467777652, True],\n [-96.65345956191142, 28.13722809686032, False], [-102.19812919352621, 27.653939350819577, False],\n [-106.17852559635664, 34.30676459237532, False], [-97.12171059588019, 32.98547742358788, True],\n [-97.63495481018265, 31.052912731492313, True], [-103.04179423578454, 32.565022698580854, True],\n [-99.7663361476778, 33.93929224333747, True], [-93.96695034930963, 33.64792052285788, False],\n [-106.43489898416725, 27.00081934085768, False], [-98.61144241454609, 26.091546414019007, False],\n [-97.62297026159148, 29.91547499019296, True], [-102.81093959843548, 31.775967846663903, True],\n [-98.92280973197468, 34.706031694183864, False], [-105.82454817097681, 33.60768142292876, False],\n [-104.1703913008495, 26.30423978112628, False], [-97.03821689475404, 25.891523519897085, False],\n [-95.96948383690238, 28.06242640122303, False], [-96.20743197977514, 32.96986917934692, True],\n [-101.84781525566628, 30.91982689926289, True], [-96.31807840035235, 31.527410535260906, True],\n [-100.8781500555231, 34.8227970125657, True], [-94.26355042343864, 30.94843753499924, True],\n [-97.3429146102502, 34.73686841121185, False], [-98.07753472284375, 29.552925455931927, True],\n [-105.04690710593536, 27.132667240961553, False], [-99.87850355720977, 32.06195375035851, True],\n [-96.53670297300587, 26.908808751199025, False], [-101.25665086243849, 34.48897040535931, True],\n [-97.62841641211763, 34.510828859444, False], [-98.26146628715239, 29.30444627019776, True],\n [-94.0424931438063, 34.024181902771446, False], [-95.32764174246178, 29.026516144561093, True],\n [-94.79487469005772, 34.064778827088944, False], [-96.8217807635728, 32.9449205143214, True],\n [-102.65783000325504, 31.187142262599163, True], [-102.73499640672506, 28.241956569934032, False],\n [-106.57423647984751, 26.21365468361891, False], [-101.18188053173569, 35.856064735642605, True],\n [-103.87152954646331, 26.239969281258677, False], [-105.21761650869897, 27.276124133480618, False],\n [-96.58824456554876, 36.01267677418892, False], [-99.10920560787146, 32.43164577872433, True],\n [-101.93795697189412, 31.620064217834788, True], [-105.78051688469152, 34.39769579781999, False],\n [-98.13520908953838, 28.15597786510518, True], [-103.44661785399717, 34.94625679402945, False],\n [-93.5839550242031, 27.799377395246868, False], [-103.09029902940127, 33.20610297263985, False],\n [-97.23285674761303, 28.03274042046823, True], [-95.34132538021933, 25.846590059853146, False],\n [-101.75354725398458, 29.976564072236787, True], [-102.8028884021146, 36.14653256975264, True],\n [-105.23453544451979, 35.083822581361105, False], [-95.02779486726217, 28.039905574389728, False],\n [-105.19965155638648, 29.896855738726387, False], [-105.04729708179732, 34.59962724881616, False],\n [-93.62110240741019, 32.29972687153207, False], [-101.91706806513982, 32.22042821274782, True],\n [-98.7507642387652, 28.373512157202324, True], [-98.67837171745543, 29.31049604748274, True],\n [-101.4835726546693, 35.24105797268996, True], [-99.61534262189332, 34.664146656697135, False],\n [-102.77162178290662, 31.477015077025758, True], [-98.14965646419336, 35.506326174334816, False],\n [-100.35687795352196, 36.428658182990375, True], [-93.75583478299006, 33.78374602526648, False],\n [-97.35272483145133, 36.14322026779398, False], [-104.13566843512568, 32.58780129504587, False],\n [-105.80951615950367, 30.548722565553994, False], [-106.36813961730384, 35.58713162312485, False],\n [-97.66809642868546, 34.13059807529114, False], [-97.61612010157164, 26.31880576825889, True],\n [-105.10689839575184, 27.13050661175676, False], [-94.42639614961973, 28.61525052001613, False],\n [-101.0258419742403, 29.912378788493154, True], [-100.85598848851129, 27.83703095635782, False],\n [-94.6443199603266, 29.977477497837175, True], [-101.16783935327581, 32.03976620169659, True],\n [-95.78686711235261, 34.37099939418539, False], [-100.59275869451973, 34.36381573902874, True],\n [-104.2707359051878, 33.43707298914277, False], [-102.69754715561436, 30.324718877958027, True],\n [-100.31772708579322, 36.03146883077079, True], [-93.84018528740714, 36.306249385961586, False],\n [-97.81378337323478, 25.848331371979896, False], [-104.37867619764027, 31.688609367477817, True],\n [-100.28100102840853, 36.18155424506788, True], [-106.48975872243628, 34.10471027956753, False],\n [-101.4453862294541, 28.535362387187064, False], [-100.05248503701085, 35.161646972337195, True],\n [-101.37197503092796, 27.85006417239032, False], [-95.00012601768513, 36.45104201985982, False],\n [-94.1618133883979, 34.189947778971074, False], [-100.9407537928131, 27.309175834366915, False],\n [-104.72991115996922, 27.3139116441178, False], [-98.59532436543168, 26.287325902961726, True],\n [-94.46884442680549, 35.68627263027676, False], [-105.31712494151611, 35.84472703216106, False],\n [-104.64932323670762, 28.699942778858926, False], [-100.34867007633471, 29.705706918470952, True],\n [-93.69561095836606, 32.456548936430266, False], [-98.12884276179193, 28.360889737226003, True],\n [-96.77862792020258, 28.586529000239178, True], [-106.1873382768634, 29.404306118606442, False],\n [-105.67789642420705, 31.716310454187514, True], [-96.00775542585319, 28.568996970414524, False],\n [-98.0904391114445, 33.41233020042991, True], [-93.82743788526335, 27.5659388943208, False],\n [-98.96755649758798, 31.32502880958104, True], [-96.55622361353764, 35.016203517682726, False],\n [-99.90454174449499, 34.88971778656889, False], [-93.92308221299953, 26.93602671682176, False],\n [-103.02775965216946, 27.526954568149137, False], [-101.70211609579965, 33.221705586015986, True],\n [-94.65140320779773, 30.12411725325112, True], [-105.48158850264392, 25.966083503119812, False],\n [-95.86092717890419, 30.257238607458746, True], [-94.78025397771191, 26.33573351642334, False],\n [-102.42306855603515, 31.528148123221925, True], [-101.11557151275859, 28.23290994001276, False],\n [-99.23764635246289, 34.03712892161272, True], [-97.18358117231713, 30.819652476530774, True],\n [-95.52114900196523, 33.71837984822948, True], [-94.80576475349369, 32.52595208303153, True],\n [-105.53353349524157, 33.10076381764996, False], [-104.45067861203503, 29.792014903132056, True],\n [-100.81552999585323, 31.13371713587459, True], [-98.10244603287715, 27.062939382372114, True],\n [-102.8183262272355, 31.63644201139868, True], [-105.48022791238954, 33.47054002907317, False],\n [-94.54700162806725, 33.3634517345777, True], [-103.52394717869927, 29.289585818953316, True],\n [-100.88024068589486, 28.00254322622369, False], [-105.13298501311634, 33.585842169513036, False],\n [-95.47745420853485, 34.33206192097545, False], [-93.75279262948008, 31.85387584406531, False],\n [-105.6408652118954, 33.38704981277846, False], [-102.68527628279271, 26.856854067490247, False],\n [-105.22798572254378, 34.52742324390015, False], [-94.25227485978478, 36.11993169557898, False],\n [-95.31071217313071, 30.450554401067357, True], [-104.32309381721137, 33.941981631972624, False],\n [-93.68344966428387, 28.25720980205315, False], [-103.11762381325748, 33.05126426779246, False],\n [-95.17637994183367, 36.37368703601287, False], [-101.09466869744112, 29.378868777118257, False],\n [-102.3244768566622, 29.25373813014635, False], [-105.6081974667763, 35.02231128438977, False],\n [-101.45129562213593, 27.250895271383474, False], [-97.77527080825567, 29.233601979476123, True],\n [-101.2708728240608, 30.929678610371226, True], [-101.17628088744974, 30.807932586287112, True],\n [-98.94314936681077, 28.962959058638244, True], [-97.5297094048325, 27.24629690610976, False],\n [-105.24649559460273, 31.68285402434288, True], [-95.38165074760121, 30.678277565962645, True],\n [-101.5405440205774, 35.75938014879534, True], [-106.30162345059492, 32.35717712927482, False],\n [-95.82698786035043, 31.471380696415473, True], [-97.58132229591222, 26.76823235412943, True],\n [-96.24754364311642, 29.148074667141763, True], [-101.60752835018079, 28.02378609076799, False],\n [-93.66280978876574, 34.36888263435238, False], [-97.04083533693894, 32.07693083540003, True],\n [-94.41534967058817, 34.30307828414252, False], [-94.51223027590078, 26.101565901379825, False],\n [-95.37877455769014, 32.91182889409107, True], [-97.02169748832533, 34.77231790184875, False],\n [-99.56938377454452, 27.98323188041011, True], [-104.71416427480177, 31.671590498127077, True],\n [-104.48037657157643, 28.020929009314624, False], [-101.46582277815409, 29.245030464171972, False],\n [-94.33289936897319, 29.433780707715577, False], [-102.65873114765344, 32.579375713461324, True],\n [-94.71197474752655, 29.919750259392565, True], [-100.56224887904757, 30.870441757396232, True],\n [-95.7680416447194, 33.381874464032556, True], [-101.30709319439809, 31.415698736346386, True],\n [-94.17706664281508, 30.20919168191223, True], [-105.1986310512293, 32.2767819705482, False],\n [-96.64520698321878, 32.53545316641808, True], [-101.27894696079863, 27.434282641130807, False],\n [-103.96823391756168, 36.206818702766164, False], [-102.61287825142863, 31.52883149992497, True],\n [-97.43688838995867, 35.35809331749178, False], [-106.3345282700814, 26.77898252396381, False],\n [-97.84563076948461, 28.326830633856254, True], [-97.10812201190659, 27.354066620755486, False],\n [-102.06625125192836, 31.959360067966703, True], [-94.77064907103171, 32.49772073548828, True],\n [-103.7070672713304, 26.993474458082765, False], [-104.63528508881744, 31.77175026283308, True],\n [-106.20330061641941, 28.71581603545491, False], [-102.93466353815762, 36.42712467119802, True],\n [-97.02548398973192, 26.47462461285108, False], [-97.92517027601997, 33.53006657932378, True],\n [-104.89676410831059, 32.03756980285575, False], [-95.02216317823846, 28.250092458391666, False],\n [-102.63731145928554, 30.78785522057966, True], [-101.9626891052094, 28.607495532359852, False],\n [-103.43019339494695, 33.757210152142996, False], [-95.52042729675107, 34.824713652167745, False],\n [-105.6806104213336, 28.64547500599634, False], [-105.01509606690256, 26.998326186544013, False],\n [-104.83729623744878, 28.111330049442206, False], [-99.30736722245813, 27.44271254179918, True],\n [-96.19450914007797, 26.5070841846474, False], [-96.93250711894682, 27.465441701127965, False],\n [-98.05769301004028, 33.34316222525198, True], [-101.70993094422322, 35.378824775340604, True],\n [-97.78065357281011, 30.791192214255453, True], [-103.85602296523946, 33.58813675270333, False],\n [-96.16754367241163, 27.82134326033623, False], [-93.84173858221502, 28.644678311847933, False],\n [-95.66361201153609, 33.1782437005781, True], [-96.18610593628335, 35.66871035791395, False],\n [-100.05778168598985, 34.34775700022905, True], [-105.3070646714683, 26.129506259811194, False],\n [-101.60474509803998, 28.301826427498735, False], [-94.05455083451157, 35.62737695624984, False],\n [-93.77022392951797, 33.35636018468855, False], [-99.9983492940202, 28.616796438006656, True],\n [-103.65327712041633, 35.68635542708576, False], [-94.18836108420525, 33.519234035329205, True],\n [-101.16524711825508, 35.21736886367663, True], [-106.63756507835402, 31.512711118486916, False],\n [-94.64418283641962, 32.24310968022579, True], [-98.48901518901792, 26.92275583383609, True],\n [-105.71495874564097, 30.37875836321371, False], [-103.59489508163908, 34.07565890645147, False],\n [-104.58617756264167, 34.7175307481461, False], [-94.94979738923941, 33.53027390298981, True],\n [-104.79237901545315, 33.643949242871386, False], [-103.6261849261433, 26.37203494674699, False],\n [-104.12072798260623, 34.037343854052246, False], [-99.3137876161763, 28.786746195806515, True],\n [-96.90701800480272, 26.83567175899895, False], [-105.91609848895729, 27.17006217234686, False],\n [-94.88867966602324, 29.0650764347025, False], [-99.09445254927051, 29.165294618392306, True],\n [-99.59646096585762, 31.547978010714818, True], [-100.35308616902222, 27.998071701955347, False],\n [-103.65741111414567, 29.929101550941933, True], [-95.56003645452608, 33.73354146467783, True],\n [-101.98380104745135, 27.741893994563817, False], [-100.28801029632858, 26.08376297941383, False],\n [-100.82876490121433, 27.203171781033483, False], [-99.00038368647441, 30.227734562748875, True],\n [-93.99273175213636, 33.172989756016705, False], [-103.28907886290975, 30.68354258877181, True],\n [-101.58265515547387, 34.05717966984305, True], [-93.61002560748278, 33.95079910028842, False],\n [-104.1322621794693, 31.037441969505064, True], [-94.90790561010023, 33.6667146192015, True],\n [-99.72772840949955, 28.57426803892259, True], [-96.76750823367423, 34.238866572662864, False],\n [-99.11285733031394, 29.297129143702183, True], [-95.34529541329582, 34.50122580606273, False],\n [-106.2015311076861, 33.04546069130247, False], [-106.6471763299225, 35.60222852490276, False],\n [-101.63138803719991, 27.93647861077147, False], [-99.67286004973847, 29.000600155646495, True],\n [-102.69661571801251, 30.438208192282016, True], [-96.47920563132686, 28.187453937378827, False],\n [-99.15701789001724, 28.754330049547363, True], [-103.63208677741055, 31.506299316322448, True],\n [-104.6247250325306, 34.777168030468545, False], [-94.50362320672285, 28.725533817363363, False],\n [-98.8088667387509, 29.719091220812984, True], [-104.66480293721597, 31.36766582422802, True],\n [-100.80243453385943, 29.56664951795082, True], [-104.3184052935018, 28.368505467940153, False],\n [-94.99687127078006, 29.056199158312214, False], [-99.18151980311957, 31.331306403933503, True],\n [-106.58306812961843, 33.83560030586354, False], [-102.34808248763466, 30.93213593104124, True],\n [-96.87905436496129, 31.63403473842953, True], [-101.88482545812973, 31.346536386676735, True],\n [-102.08612983365585, 33.94091937937585, True], [-97.59374438050571, 30.710749425390954, True],\n [-98.468759043241, 34.887864549188656, False], [-104.5600126294423, 30.769523820716284, True],\n [-105.63321064215583, 31.706723345643436, True], [-103.39803684928096, 31.205852663870417, True],\n [-103.74991694223343, 34.47243593420573, False], [-103.55735795090966, 29.368257266446264, True],\n [-100.53250901956653, 34.61994711930259, True], [-106.42290807028131, 29.47435749957574, False],\n [-100.61630496584333, 28.492897242114427, False], [-95.45897223676457, 34.99538998873486, False],\n [-100.80796423924814, 27.597779160448237, False], [-95.59903305812487, 33.53765968472729, True],\n [-102.71817656483864, 33.67774382239573, True], [-100.0519819831278, 31.720152603322795, True],\n [-101.86801670742807, 29.37988286278217, False], [-93.7251604108502, 33.63648932111699, False],\n [-93.50731366944763, 31.66131539976032, False], [-93.91408986252142, 31.91658143504109, False],\n [-99.1976965958281, 31.846542049263352, True], [-96.70181855090833, 27.823299476943752, False],\n [-99.05025751191671, 30.14722485144382, True], [-101.91786175888922, 33.662393020783334, True],\n [-97.18908214543966, 26.584467319788136, False], [-102.09768463635325, 27.745869776526586, False],\n [-105.03784779065376, 33.35089012727154, False], [-99.75443466868418, 32.340335779846406, True],\n [-102.53950776524619, 32.48219468369184, True], [-97.38249374177907, 31.70583501812896, True],\n [-100.23917371385507, 34.15552160975429, True], [-100.64584910978431, 33.08767497994276, True],\n [-95.54547414843782, 28.573393441826422, False], [-98.4400667166874, 29.169883280280335, True],\n [-101.85722555245049, 29.99952272227504, True], [-103.40127887731586, 35.954389606004995, False],\n [-106.49277204369605, 26.3739019521645, False], [-96.42482710450412, 25.935501811569573, False],\n [-96.49468755444158, 26.21429802291354, False], [-103.26280296149277, 36.42505933494076, False],\n [-103.23186132072851, 26.981602236536546, False], [-95.43868017247715, 26.795551518098133, False],\n [-104.95759598697946, 29.274620743768665, False], [-97.4627043038694, 31.264418590173566, True],\n [-99.40922174677335, 30.859355223178202, True], [-97.62450333069754, 31.860943195654983, True],\n [-103.28423668185653, 31.64625933078107, True], [-97.34347509751296, 32.39948448790623, True],\n [-104.78394662628456, 32.19069943780818, False], [-94.27543944274844, 28.45111869438522, False],\n [-105.41902431151755, 34.098705479256964, False], [-105.84856227788723, 34.401910854922086, False],\n [-105.76944559045042, 27.541157331410925, False], [-105.96625908843005, 34.60984823477864, False],\n [-100.45522585613661, 35.82958048104291, True], [-95.8227101752813, 26.40044772412707, False],\n [-98.14190854947867, 28.173726785556475, True], [-103.41079917326785, 33.17358912330205, False],\n [-106.21380947469507, 30.673049362200253, False], [-98.6181240681384, 31.57826052940466, True],\n [-105.52347449914703, 28.45331024338554, False], [-105.87199783454764, 29.269133017660426, False],\n [-95.72117392272776, 32.84521613150032, True], [-103.98103037156038, 29.39830154631861, True],\n [-98.84272856308685, 27.010603508995832, True], [-103.48528511610583, 32.292795962096, False],\n [-101.10764837358862, 34.44067771878632, True], [-99.90899218640438, 33.864602563342665, True],\n [-99.99425094006477, 29.632299612876448, True], [-104.19954114103936, 29.481293826903272, True],\n [-99.1617923467798, 27.24969812956527, True], [-93.94985771467012, 33.20509824852493, False],\n [-98.74589172711391, 26.59828162369087, True], [-100.74104498226976, 28.090884473461635, False],\n [-102.0941642949128, 29.40228872741179, False], [-103.71745434686355, 36.07717165565938, False],\n [-103.85504023598908, 35.797619278303934, False], [-98.3178181998277, 31.80247171895742, True],\n [-100.46831716774525, 26.395663970107364, False], [-96.6262432609301, 33.43258969257319, True],\n [-102.12872561318167, 30.9414684197057, True], [-96.10044267209415, 31.617205739677686, True],\n [-102.76040876099727, 30.02029055974793, True], [-100.28567173102832, 33.71564104661008, True],\n [-101.87455244042499, 35.45783748840937, True], [-103.80647075850555, 33.75958813400894, False],\n [-104.07465598182498, 29.829473718048853, True], [-96.80679641483542, 34.068109206459674, False],\n [-100.21922411687524, 35.55827610846517, True], [-102.18536576459445, 35.60838848797885, True],\n [-100.74818339320018, 32.46468922651053, True], [-98.89381745119253, 29.84927086885224, True],\n [-95.57772284816139, 34.03118772897132, False], [-102.19208387081574, 35.47422893590955, True],\n [-99.31176771742929, 28.159649775138398, True], [-95.08438010592444, 30.864384073337725, True],\n [-105.62858370011037, 36.04041710371988, False], [-99.50704661690466, 26.530069415053166, False],\n [-102.21328017280045, 28.123746616410187, False], [-93.82909083931759, 31.8346812474552, False],\n [-99.68311577900606, 33.37514101639904, True], [-93.88914553766337, 34.40543275268286, False],\n [-95.49031947037534, 36.15787562082431, False], [-94.04958126924683, 25.895718131012476, False],\n [-102.31183630727872, 26.195612345971853, False], [-99.74217764726765, 34.4866834996357, False],\n [-101.2273998455989, 31.012399597950438, True], [-93.7170401640232, 26.52296130239048, False],\n [-106.31856530763194, 30.254195818383003, False], [-93.54539750125572, 31.968279205890525, False],\n [-102.06176434040876, 35.96267638467066, True], [-102.21150807644786, 31.276020170678756, True],\n [-97.59134352614593, 27.758428418449625, True], [-105.6285777230377, 36.20035827010385, False],\n [-99.56855691529327, 27.565199944571845, False], [-93.95512959128524, 35.50257083074824, False],\n [-104.2068757288861, 25.983428900973824, False], [-104.1534590142076, 29.90389615149271, True],\n [-104.75891565225955, 26.17708478969608, False], [-96.34136547606607, 26.58259616840622, False],\n [-94.35505605596222, 31.363945882683545, True], [-100.75357998539742, 27.70797766258346, False],\n [-96.34206621365894, 29.195743358202087, True], [-96.44632535331706, 33.578167176287465, True],\n [-100.52062683482386, 28.935836235311534, True], [-103.59488192282778, 31.145329272683313, True],\n [-96.21513910038252, 26.71734433601959, False], [-97.74524155506616, 35.72544238150706, False],\n [-98.15072688652688, 29.65447185320712, True], [-102.94259657821668, 28.995860793431966, False],\n [-98.37049290964605, 28.992239589640803, True], [-101.9333665893231, 32.042668019418784, True],\n [-100.31205895270178, 28.542423199402116, True], [-102.7842119789965, 31.351234994650703, True],\n [-102.82118189131612, 25.936779514285522, False], [-105.06566909806352, 34.429600751175066, False],\n [-103.95414080936615, 30.5173184712075, True], [-96.41063716230997, 35.68425390782344, False],\n [-94.82668338005425, 34.10595925830741, False], [-105.42861829324059, 26.89985572905742, False],\n [-94.86003017402527, 32.72190652290611, True], [-96.69442705925057, 29.12593879172168, True],\n [-100.57898366779487, 35.697109012290476, True], [-105.77290660716999, 34.23468690232633, False],\n [-104.3849259560512, 31.337110429238777, True], [-95.21459964105358, 33.00732978946704, True],\n [-95.7332150421658, 27.704415504038284, False], [-104.50875122680036, 34.91526292458323, False],\n [-102.80833873160228, 31.875937580897503, True], [-104.53224880900562, 25.940603993388773, False],\n [-99.6884270626213, 31.04708806366109, True], [-95.76317485487704, 35.45517519387816, False],\n [-101.84342021439619, 35.834756908559946, True], [-104.04702349088515, 26.09752753366655, False],\n [-103.48123590122003, 34.55695985365465, False], [-101.90736610359222, 26.198871101374856, False],\n [-95.80852972334627, 26.4884711642595, False], [-106.49602165329638, 31.587480730479957, False],\n [-99.11540612418378, 28.76377389466793, True], [-98.81124442220992, 27.408954979897345, True],\n [-103.54081324519612, 28.238918914656047, False], [-102.8589030540497, 33.69752159861657, True],\n [-100.38962812985066, 36.259455441754405, True], [-100.60205967959344, 27.45237069505359, False],\n [-104.82116135978534, 33.90726029831255, False], [-95.25951953419671, 36.427532407586796, False],\n [-93.75127522006922, 31.774003703956872, False], [-106.50710079332187, 32.31418914724039, False],\n [-95.38754195058371, 27.686986329488576, False], [-103.48158704856718, 28.05982044881246, False],\n [-94.40123367677305, 32.13802908979801, True], [-98.37091796124368, 31.394805069115378, True],\n [-99.35199253682242, 29.364231843209286, True], [-100.6371809469257, 29.485414607179138, True],\n [-101.65847488152119, 33.055932161413, True], [-104.75073650330286, 35.477180164221664, False],\n [-100.70424003073441, 33.33233065367354, True], [-104.9829081950403, 33.49495185425366, False],\n [-96.28014091653374, 30.765109918972172, True], [-102.51312299795521, 34.973490202758846, True],\n [-106.4316820557197, 28.835022330467574, False], [-98.37035640871174, 29.15982666730043, True],\n [-103.81743393736278, 33.33070497195332, False], [-102.38044273457957, 27.128328755756332, False],\n [-105.83310224715474, 32.69799499508526, False], [-104.47875333696165, 33.08218160363957, False],\n [-105.08315111607386, 27.5499535808647, False], [-102.50315445382816, 32.952707100728176, True],\n [-106.34702977388169, 28.350530651265025, False], [-100.7324706006535, 28.110070428450136, False],\n [-98.89057718530617, 30.501635222091867, True], [-93.7973707158511, 30.332449685439883, True],\n [-100.50817745675471, 35.933620707046416, True], [-93.62331898394628, 28.011415151343442, False],\n [-102.40168198643366, 28.038346452109714, False], [-98.76386270364078, 32.824244011949546, True],\n [-98.63890075873523, 28.426721830307706, True], [-103.06753906192446, 27.182546407018886, False],\n [-103.5149916483893, 32.22702185824897, False], [-96.92704846269056, 33.56573720072518, True],\n [-98.59191146293448, 26.717454841499933, True], [-98.21728189059557, 30.499991381612325, True],\n [-98.96569953382873, 34.09349857812645, True], [-98.81645597171263, 31.538513035336027, True],\n [-103.99810746775411, 34.572232011339544, False], [-97.1971994402299, 33.01231694977086, True],\n [-97.35525400352937, 27.593348250877636, True], [-95.61047936363322, 32.915418129253844, True],\n [-105.77325410471146, 32.220934743164854, False], [-100.31130282858123, 31.053207323928227, True],\n [-94.27435346222804, 29.717111545751255, True], [-99.36518149272568, 29.81842676057489, True],\n [-102.4595465810425, 29.78052913717334, True], [-104.93563833675945, 36.1553390615043, False],\n [-96.67331825738593, 33.795256849340824, True], [-104.13912762449462, 28.90285335911741, False],\n [-99.85650514030851, 27.082576996579743, False], [-95.46433062216431, 26.31189218916502, False],\n [-100.84562917395462, 26.46339943905897, False], [-94.75077980314441, 30.746795428982928, True],\n [-98.38741630868877, 32.8939361913369, True], [-101.50339387491944, 33.409893596597634, True],\n [-102.8838322429055, 33.550509813464714, True], [-94.4241089162888, 29.987534160102904, True],\n [-96.97724045199526, 29.413237018802626, True], [-103.26463086689401, 35.69959960363469, False],\n [-104.22583858596425, 35.32625561149897, False], [-102.28802601849752, 35.31386927276366, True],\n [-101.0349738411682, 25.896953488838804, False], [-103.9839821999459, 33.2679016367904, False],\n [-105.01149642855964, 34.24130005689306, False], [-104.86876474825357, 35.97880497285345, False],\n [-98.95300311760788, 28.23951953232239, True], [-106.44607553528402, 28.99701327445984, False],\n [-97.15665622011281, 33.802655749490576, False], [-104.88728768211863, 26.19423408399297, False],\n [-98.2868092522052, 26.77958013643795, True], [-96.30475465159665, 25.886256031524383, False],\n [-93.96185258306615, 30.262131379160092, True], [-95.98431071502645, 34.074476976239524, False],\n [-99.34592870499611, 31.77796555029789, True], [-101.23448890900838, 35.02325060675137, True],\n [-96.60311950987519, 26.520767851753252, False], [-103.30098695011493, 33.95932432365544, False],\n [-97.20833874248723, 30.443771327358455, True], [-100.49276808544384, 30.563391121718663, True],\n [-106.00844672588474, 27.67304591354748, False], [-94.68045487444002, 28.380941225789602, False],\n [-106.32581808918103, 27.457360510530357, False], [-103.90944733413775, 33.75181119086094, False],\n [-96.62055409685594, 30.911602145241257, True], [-105.08332076154659, 35.84175548182445, False],\n [-106.46727840740928, 30.97311215593337, False], [-98.24608713290009, 26.87548489704331, True],\n [-99.99394976092111, 35.372523026676305, False], [-101.04275569324, 26.378571750355146, False],\n [-99.49808015597847, 29.0197284725707, True], [-100.04278394100143, 31.138487871928806, True],\n [-93.77580092670675, 28.679720562816012, False], [-105.69434962210484, 35.48380415396366, False],\n [-94.76833576200043, 34.77440737306939, False], [-93.55059692835445, 32.93611160385383, False],\n [-96.16637525156335, 35.14861120144762, False], [-102.57674991354982, 33.57167753159161, True],\n [-104.50984249707894, 27.845184825434426, False], [-102.46681259074438, 32.876290517890325, True],\n [-103.79635335230255, 34.68136206176115, False], [-97.37101719424614, 34.331617955613964, False],\n [-93.78338486646257, 29.1736195506313, False], [-98.653709287249, 30.255774672109183, True],\n [-104.78162076886001, 36.14023266162845, False], [-95.30745598333526, 26.15568755210897, False],\n [-96.19795914229807, 29.783289215723965, True], [-93.97200790057319, 30.34872478231179, True],\n [-102.75807129557354, 32.02568271699399, True], [-95.63613363239972, 30.17575679938203, True],\n [-95.74058254060239, 27.830132693387228, False], [-97.28993038017775, 33.34058580949793, True],\n [-94.782421253055, 26.37055251439716, False], [-99.01579664350437, 33.29078588254949, True],\n [-97.2079339911563, 27.123479789817104, False], [-96.66399830213123, 35.57917944458788, False],\n [-104.00378871415248, 33.03909098032557, False], [-98.18333736354995, 33.40304952690905, True],\n [-99.51409889042824, 28.352125049514296, True], [-96.39878389524632, 33.80913094147424, False],\n [-97.95457727578372, 31.304986453423908, True], [-105.41519123044006, 31.17900852073914, True],\n [-102.55823249490591, 28.227952215383333, False], [-105.22740902391834, 28.00912246742774, False],\n [-105.4327613051658, 30.42094293937215, False], [-99.8642636892311, 34.741799628413524, False],\n [-104.07069003771045, 30.561044257056018, True], [-105.71580939231154, 34.73255277750661, False],\n [-98.92331393934845, 34.757305489096225, False], [-95.1451471669803, 35.59262098012566, False],\n [-100.78929431916742, 35.83001258653612, True], [-106.15538551006625, 33.88884085609275, False],\n [-97.78557980515986, 33.9896913074551, False], [-94.43404183378551, 31.976310799398128, True],\n [-102.77500581970122, 30.636815025506447, True], [-105.67967176568628, 33.47402254839546, False],\n [-98.79160014376332, 32.79018812677753, True], [-102.84347322545034, 28.136203054123584, False],\n [-95.24784148052099, 34.22424254638486, False], [-106.31929728808254, 30.9825641984661, False],\n [-102.43296109133702, 32.532070674152855, True], [-105.92145087338875, 30.381356965114943, False],\n [-106.45282535347631, 35.54158851537021, False], [-95.04777932048988, 35.82906359730707, False],\n [-97.42369763037011, 34.37608618524585, False], [-104.57070459903527, 33.70875609054547, False],\n [-97.41632281711793, 32.92982657064401, True], [-94.66570627408036, 27.27007338775074, False],\n [-99.1743643002243, 27.247623481915483, True], [-104.68950862955154, 29.870865904293723, False],\n [-98.10816880312582, 28.162238589797898, True], [-93.64216163895259, 26.298614364258444, False],\n [-95.19102534541413, 33.389356010635154, True], [-96.62070599059086, 30.74805978317854, True],\n [-99.3386516464026, 27.906200841991534, True], [-100.8007152801228, 32.84683422029997, True],\n [-106.20302284683326, 32.380361469176044, False], [-94.23655356205708, 26.324497474351357, False],\n [-99.65954455695915, 35.474000933282724, False], [-94.31553240129878, 35.66875101369414, False],\n [-101.83519143957733, 25.873081120803842, False], [-99.97028199969046, 34.58909164776538, False],\n [-105.71652597027627, 31.489327979058995, True], [-105.79973754647258, 28.65472050301513, False],\n [-104.61884498465494, 31.131621852439807, True], [-102.57111696065307, 30.114279991888235, True],\n [-103.32297212967914, 35.236882653404706, False], [-100.4249645463674, 35.01412558025736, True],\n [-96.2664164425719, 27.27790820412447, False], [-95.49119347312927, 34.04880310368103, False],\n [-94.76867790780145, 30.68409383373247, True], [-97.33084948761977, 35.987707032142886, False],\n [-98.9375962329848, 27.590161796852268, True], [-100.24496746645461, 35.14003067100538, True],\n [-97.82265827697529, 29.12546410605067, True], [-103.60831990499707, 34.420657352069206, False],\n [-96.6211125945082, 33.06459177171514, True], [-99.74211708967393, 29.148959136838407, True],\n [-101.74939764896713, 34.474532089579476, True], [-94.34764438114355, 30.357142981363083, True],\n [-106.52546379307893, 30.041326961454715, False], [-101.2986640335862, 26.37652905898862, False],\n [-106.4580153687541, 29.87759744762145, False], [-100.89335102135293, 35.52499965140305, True],\n [-100.8248639994296, 33.40975770839312, True], [-103.93212196016398, 32.909497641552065, False],\n [-94.67932056126476, 35.15626837470808, False], [-106.02052521025293, 29.597198775376654, False],\n [-98.2893867410877, 29.93112729119841, True], [-99.89450058695091, 27.938220198829537, True],\n [-97.3506130624274, 29.943100560338415, True], [-102.20272670412375, 26.935152987528188, False],\n [-102.76414059461521, 27.054007916590372, False], [-106.0041901594681, 34.50108734620676, False],\n [-99.34960356247895, 30.765691636568544, True], [-93.90991359101918, 29.52415548605938, False],\n [-102.45068333144832, 29.498640082146757, False], [-93.52649708202873, 33.25384150278302, False],\n [-98.11359820029512, 32.661143218490004, True], [-93.64776248509527, 30.4684682460894, False],\n [-99.4498229748733, 27.335197692456124, True], [-106.3098030711422, 28.114811474983753, False],\n [-103.19744279212784, 29.761699794107464, True], [-98.04521749365168, 29.23374276253473, True],\n [-96.02905435107336, 30.127228292010795, True], [-98.51879935475141, 29.632065468973558, True],\n [-97.51304854653931, 31.509276424390762, True], [-103.29390200939619, 27.318075011416106, False],\n [-99.9824973213597, 30.110443559920434, True], [-99.50915156948314, 29.258458344281003, True],\n [-96.41505277249307, 27.81615410871556, False], [-104.15751695040154, 28.634566430199957, False],\n [-99.54546678775662, 30.628758593109584, True], [-94.501671157283, 26.690164729805314, False],\n [-99.5998715300248, 29.29963433926709, True], [-96.19407966991072, 26.583996951962845, False],\n [-94.18130561957514, 34.39183349747304, False], [-99.35457098320595, 29.19418372510661, True],\n [-103.2439668700228, 28.7415827836878, False], [-95.94946899471344, 26.094846437871187, False],\n [-96.29555855830898, 35.61463847091715, False], [-100.90818350967113, 32.81839948197739, True],\n [-103.19547298017221, 33.780381119513564, False], [-103.7311831715452, 34.51901410810771, False],\n [-104.9802204382533, 27.04133234378543, False], [-97.04516124978682, 26.74522583795225, False],\n [-99.54055674299795, 30.957712411033505, True], [-100.75291255499768, 34.98555626576464, True],\n [-103.08923082250261, 33.115219018353876, False], [-94.38102432053655, 33.1179055259896, True],\n [-102.03982643927137, 29.9838170230828, True], [-105.81904014957023, 28.79765172366808, False],\n [-96.65811064697854, 29.033441999230575, True], [-94.79391199397416, 32.26686772352405, True],\n [-94.05970729814709, 27.578098867203245, False], [-101.34732336260434, 31.621990539913554, True],\n [-104.3518957862908, 29.119881150805877, False], [-94.62935978446168, 30.4280012647268, True],\n [-94.4545353979626, 35.54695331314244, False], [-95.54556621919373, 36.13412073236616, False],\n [-95.35828131810126, 29.196029446685102, True], [-94.03367199299583, 29.998249298603696, True],\n [-106.36092437901962, 35.88480338683122, False], [-104.36739535175568, 34.44871919970392, False],\n [-101.23847775114616, 33.38670941589996, True], [-99.14984412490651, 33.42882053133658, True],\n [-103.57375420847947, 36.10822666498764, False], [-105.16720721276594, 35.376479016301516, False],\n [-97.83947903342955, 27.52109204805256, True], [-98.71405542652877, 35.7689674767476, False],\n [-103.06998061485356, 34.82880997682268, False], [-105.28204362921868, 28.400435333576176, False],\n [-94.15911792478674, 26.17595690168265, False], [-96.8089922559183, 28.576299745236, True],\n [-94.55012730211439, 35.965323310709934, False], [-102.35052435497836, 35.54979117991739, True],\n [-104.37005549234762, 27.1898216329847, False], [-95.68880266269171, 28.848538713723595, True],\n [-99.48796021732129, 33.879870610429656, True], [-101.00413095653694, 34.33763822793282, True],\n [-106.07730385091368, 29.134515491377414, False], [-103.45299952582074, 27.571405818685125, False],\n [-102.68769661036903, 35.0508397444369, True], [-102.12226125487027, 31.490531154286373, True],\n [-99.20157845594305, 31.551754104915446, True], [-102.55860273418811, 34.074770794654526, True],\n [-106.13595097934105, 30.66643783693412, False], [-106.62769073938416, 30.65343353159766, False],\n [-106.40940133512453, 29.82237466871204, False], [-102.1529566504516, 35.06622589749327, True],\n [-102.80724491463563, 34.7087445437067, True], [-97.64939497688633, 30.67928132241753, True],\n [-96.36801227272899, 27.90369756441311, False], [-94.09540454906752, 26.5340311979023, False],\n [-100.95868651879503, 29.489244579528528, True], [-99.00791521500773, 33.15713091296997, True],\n [-94.56949551831565, 29.097678237118387, False], [-104.30210679432342, 27.480997154392185, False],\n [-102.89216000521263, 28.618705789328487, False], [-96.97440058322412, 33.50865616454956, True],\n [-98.99276448264528, 33.16482908208919, True], [-104.83376414397748, 30.866597558655094, True],\n [-105.87523535009888, 26.94560046391572, False], [-99.29766049432588, 32.83368387034709, True],\n [-102.51690788569256, 33.11843291048262, True], [-95.8185042576338, 29.933635250495907, True],\n [-95.64639798097132, 29.81408328213472, True], [-95.27363238555648, 26.04686490238641, False],\n [-97.49469880046678, 28.7839351111114, True], [-102.55955572766781, 32.24579142286663, True],\n [-102.3259956134002, 29.68040823171017, False], [-97.73863157435005, 29.996562088019196, True],\n [-104.68631893564948, 32.01946765618769, False], [-95.04016163980175, 33.10637289096444, True],\n [-104.60749147021224, 34.68835575652551, False], [-103.65636297920052, 30.591031777106217, True],\n [-102.77020591146633, 28.84679685398533, False], [-93.68494562344958, 30.545382533660963, False],\n [-105.28442207266875, 35.066432824429576, False], [-96.25390521489425, 26.494829177985668, False],\n [-98.82250217338702, 27.932953025264148, True], [-101.74188578040746, 34.64776869635973, True],\n [-106.04404882060925, 28.594522513035013, False], [-93.67216964673989, 29.251042306696004, False],\n [-99.78759245690895, 33.06425606417031, True], [-98.40506092257863, 30.372595091544586, True],\n [-102.29051625332913, 32.71012257838102, True], [-103.71880332727147, 32.69104459346947, False],\n [-97.0545647773379, 30.76611952136734, True], [-96.38483633115239, 27.604532811233028, False],\n [-106.26518681815887, 30.011599887072457, False], [-96.29869292442771, 28.668280098851437, False],\n [-101.81643591481892, 26.171067127237418, False], [-99.84342847150265, 26.017698064471553, False],\n [-104.11331752582073, 29.654316762816297, True], [-99.97301004853021, 27.730105527140825, False],\n [-106.31647836713242, 32.17703231405249, False], [-105.53511133815337, 26.702440097120153, False],\n [-96.73532103327318, 35.78642691945332, False], [-99.1113903696459, 34.40215160301135, False],\n [-105.57490309093876, 36.00074957169259, False], [-96.91408056656418, 32.50309840505817, True],\n [-97.12004011524724, 26.947775539446376, False], [-104.31177621433217, 28.977811712282257, False],\n [-94.2821165561003, 30.71331882514141, True], [-98.29146997158631, 26.800066299911094, True],\n [-103.116290122766, 31.46742167424961, True], [-98.56811800705276, 29.888220960970425, True],\n [-98.08987891135445, 27.80577602559695, True], [-95.34430060625397, 35.0872381937164, False],\n [-97.29977470332764, 28.838558342329026, True], [-99.29340339460651, 32.1659999533891, True],\n [-98.45946176172794, 35.06767544568288, False], [-97.28077383253662, 30.77329811793486, True],\n [-103.2046478070315, 33.95113909648831, False], [-97.41533999785908, 32.08647437970406, True],\n [-106.24449926545937, 26.923081786350345, False], [-97.29470564456045, 36.18937223503928, False],\n [-97.66122972103732, 34.56870670469234, False], [-102.35020419742744, 27.349690061784784, False],\n [-93.77154189004054, 33.43617694637923, False], [-101.35103101345337, 29.463692272605073, False],\n [-101.62926979404627, 32.803732493055875, True], [-94.90780742661717, 27.023519182303016, False],\n [-106.20392742378257, 32.97382450322062, False], [-100.31113315995306, 29.431049347619815, True],\n [-101.26240055732195, 36.148817757576396, True], [-98.42727511780691, 27.460837740553018, True],\n [-98.57534771820664, 35.599414672044254, False], [-97.62020154014516, 26.369709082738453, True],\n [-103.2986841163323, 32.6157912851791, False], [-93.93578337162835, 34.486048529590185, False],\n [-93.64615854059947, 28.5736836659404, False], [-96.99391123102941, 28.896993703684423, True],\n [-102.45723986918175, 35.7010832684699, True], [-105.25314374574465, 26.38581255615052, False],\n [-100.2188547460063, 28.291673320576088, True], [-100.7877537462725, 34.49341196472571, True],\n [-106.45021897380575, 26.72924721086809, False], [-105.02103129126913, 30.757125052138996, True],\n [-98.53860937298697, 32.45578723025558, True], [-99.57879415297293, 33.96386507864504, True],\n [-93.7378357236408, 27.9626758279968, False], [-100.63489750669079, 35.38304941928768, True],\n [-106.59421404071085, 30.052955341162452, False], [-106.59172119923385, 35.689363691993364, False],\n [-97.34149801358657, 32.67880291850629, True], [-94.73963101360403, 27.850819649646564, False],\n [-100.94403277172583, 33.474538412919046, True], [-99.27226009251935, 27.468315184289615, True],\n [-100.4539129843546, 34.591160165118865, True], [-106.44494557869739, 28.035999053683224, False],\n [-94.23984184184754, 29.557288201626776, False], [-99.03587934877508, 26.59598428059316, True],\n [-99.74353348891233, 32.82386415542986, True], [-101.86634664448142, 35.898545381710065, True],\n [-104.82904170889573, 35.68593461490256, False], [-102.883660082079, 25.927764876566876, False],\n [-95.10167954830852, 29.132555432953012, False], [-104.16716765381528, 32.54432440506069, False],\n [-95.8001698490917, 30.554039020076594, True], [-98.25774265085879, 30.67468293710671, True],\n [-104.14549182637904, 36.13448211420454, False], [-100.79273106998009, 27.687205570475957, False],\n [-97.9031540972447, 34.04156602854073, False], [-99.48655188258273, 36.01928708820145, False],\n [-103.78885086741725, 26.649573815350735, False], [-97.54897028080592, 26.611495630090587, True],\n [-106.18533271033974, 26.521041809084632, False], [-102.04736124316179, 35.80143440960038, True],\n [-103.53014416761859, 35.94251011771925, False], [-106.37072741181773, 33.56020830971726, False],\n [-100.5087744739241, 33.68691572355519, True], [-103.14684873740707, 30.33159482347187, True],\n [-101.04498614381122, 34.01935100090506, True], [-99.23406810345234, 36.47780260248638, False],\n [-96.38309061733807, 28.10204238295031, False], [-106.04814322602003, 30.009165824440764, False],\n [-99.09937261770088, 36.27541704541078, False], [-94.9236280439113, 26.908216725432283, False],\n [-96.03138446605873, 29.48956628516225, True], [-101.79748242792357, 36.2396677016486, True],\n [-96.7954152001291, 28.981691254375008, True], [-95.95383982488345, 33.80047001504878, True],\n [-103.89568070095685, 26.027352965725004, False], [-104.33069038138268, 36.46092136221017, False],\n [-99.40487331382435, 33.362496703874385, True], [-98.0390467871466, 27.286158481267943, True],\n [-103.93051493329094, 36.21025032666974, False], [-100.89036166271175, 29.431712359982495, True],\n [-103.01093811284001, 28.951789475547162, False], [-105.6925789844033, 26.67611273491844, False],\n [-100.63232815476351, 35.18180560295863, True], [-95.84068243438212, 26.566440681951057, False],\n [-101.69166851142406, 27.58570691504354, False], [-96.39192036000713, 30.76580153991847, True],\n [-99.60575587904657, 32.844854917935244, True], [-99.88359268023875, 26.427305650516256, False],\n [-102.49870407406512, 35.670387195714135, True], [-99.02838249064023, 34.35433748751913, False],\n [-93.69511330973809, 28.964334494491123, False], [-102.77438414412866, 34.77587690396507, True],\n [-97.20637129262126, 28.62351031644859, True], [-97.20760493091282, 29.66509727888832, True],\n [-97.78279263302204, 28.650053248724216, True], [-105.10373645902229, 30.10605688088612, False],\n [-102.29320671455936, 34.913227698065626, True], [-102.08456452797166, 35.04888378920539, True],\n [-97.684013792577, 35.91610190976283, False], [-94.66766997135741, 28.388037123223707, False],\n [-93.51699445904997, 30.745955788402362, False], [-100.56415276925733, 27.122598143422042, False],\n [-105.51909002313077, 30.081775705006855, False], [-95.57290373716107, 26.724672719886662, False],\n [-103.50352867348445, 32.004206585428776, True], [-102.8747549124684, 32.8979077719816, True],\n [-94.54178731632837, 28.121556170094824, False], [-105.1852492618114, 34.57852818651511, False],\n [-101.56833897599279, 32.394936636984475, True], [-102.06612007055514, 30.0654558718264, True],\n [-104.27037065814437, 26.539037110206124, False], [-96.84449118726283, 34.303252013399494, False],\n [-100.21448448808589, 31.640102623719255, True], [-105.11541407363484, 32.59032999242083, False],\n [-102.47865996013053, 36.106193753181586, True], [-102.1982854302976, 30.87389402879236, True],\n [-103.75935920410515, 34.164405398206384, False], [-100.26058874460439, 29.97152621245525, True],\n [-99.98584687760041, 29.138422331875738, True], [-98.8136163575852, 31.471193466135066, True],\n [-98.2634703260477, 34.441857423457066, False], [-101.31389165577758, 26.67722696068761, False],\n [-105.25939274478021, 33.42397682936403, False], [-95.42401575533701, 36.38213160460099, False],\n [-93.7911156924766, 26.16919479726154, False], [-106.0793837632488, 32.0426040667038, False],\n [-101.67576371230456, 26.55813999428948, False], [-105.29328020590933, 33.317961711071874, False],\n [-106.6282733323151, 26.640651252579072, False], [-100.97693002993205, 29.778473204159543, True],\n [-99.81270323613123, 28.521657399940562, True], [-106.35993676923691, 32.47765856951956, False],\n [-98.6318807925877, 27.313103487591995, True], [-105.60269402006043, 33.9266565877851, False],\n [-96.50522425362368, 33.17862810486471, True], [-99.36585657273703, 27.918462376378407, True],\n [-102.71165541572611, 27.26977019467567, False], [-105.26203795210641, 33.50921690053216, False],\n [-105.45340320249285, 28.841949098625847, False], [-97.67986158008269, 31.45298937828147, True],\n [-95.42927279657806, 30.012853799790946, True], [-94.61186352922475, 30.990817003676423, True],\n [-98.75882027588506, 33.21933322666259, True], [-104.55525321655045, 36.35184775125859, False],\n [-97.39087680042095, 29.262712771446328, True], [-95.32479451597851, 32.558534263953774, True],\n [-96.17652314621081, 34.39156129414083, False], [-99.95318514227759, 29.206707699022903, True],\n [-105.32756527254323, 29.177591819396113, False], [-104.63110828519505, 35.14036164405956, False],\n [-101.75109732251778, 30.720543376919306, True], [-98.43013838260205, 28.14394272715192, True],\n [-97.0734335255207, 28.750007474412804, True], [-103.21154248047685, 32.22703974346086, False],\n [-102.39810543632244, 32.819942719538474, True], [-103.36259451330584, 27.176657526494928, False],\n [-103.66650593230085, 36.025520559005244, False], [-101.63539174258722, 27.803279475131447, False],\n [-96.34811589893562, 31.14578417358513, True], [-98.94976448687677, 31.767797366700666, True],\n [-97.38029827656692, 36.27728736453143, False], [-95.93103949592769, 28.74450380455483, True],\n [-98.8151117128684, 34.70259233670797, False], [-96.14623746963383, 30.48841309287015, True],\n [-101.46340647601903, 30.19511307273737, True], [-100.63602533061145, 31.749219881531914, True],\n [-101.63505098125265, 33.69021849156649, True], [-94.71406829659445, 31.90061330594235, True]\n ]\n for p in points:\n assert p[2] == qtssr_texas.contains_point((p[0], p[1]))","def bend_s(\n size: Float2 = (10.0, 2.0),\n nb_points: int = 99,\n with_cladding_box: bool = True,\n cross_section: CrossSectionFactory = strip,\n **kwargs\n) -> Component:\n dx, dy = size\n x = cross_section(**kwargs)\n width = x.info[\"width\"]\n layer = x.info[\"layer\"]\n\n c = Component()\n\n bend = bezier(\n width=width,\n control_points=[(0, 0), (dx / 2, 0), (dx / 2, dy), (dx, dy)],\n npoints=nb_points,\n layer=layer,\n )\n\n bend_ref = c << bend\n c.add_ports(bend_ref.ports)\n c.copy_child_info(bend)\n c.info[\"start_angle\"] = bend.info[\"start_angle\"]\n c.info[\"end_angle\"] = bend.info[\"end_angle\"]\n c.info[\"length\"] = bend.info[\"length\"]\n c.info[\"min_bend_radius\"] = bend.info[\"min_bend_radius\"]\n\n if with_cladding_box and x.info[\"layers_cladding\"]:\n layers_cladding = x.info[\"layers_cladding\"]\n cladding_offset = x.info[\"cladding_offset\"]\n points = get_padding_points(\n component=c,\n default=0,\n bottom=cladding_offset,\n top=cladding_offset,\n )\n for layer in layers_cladding or []:\n c.add_polygon(points, layer=layer)\n\n auto_rename_ports(c)\n return c","def create_partition(mesh,polygons,enforce_exact=False):","def circular_levelset(shape, center, sqradius, scalerow=1.0):\n grid = np.mgrid[list(map(slice, shape))].T - center\n phi = sqradius - np.sqrt(np.sum((grid.T)**2, 0))\n u = np.float_(phi > 0)\n return u","def test_flip_loop():\n conv = ToPointsAndSegments()\n ring = [ (0,0), (3,0), (3.8,2), (4,0), (6,0), (6.3, 2), (7,0), (10,0), (13,4), (10,5), (7,5), (6.5, 3), (6,5), (4,5), (3.5,3), (3,5), (0,5), (-2,2), (0,0)]\n conv.add_polygon([ring])\n skel = calc_skel(conv, pause=True, output=True)","def test_conv_full(self):\n\n points = np.array([[1, 4], [2, 1], [3, 2], [3, 3], [3, 5], [4, 2], [5, 1], [5, 3]]) # example of points \n \n cv_hull = convex_hull.convex_hull(points) # convex hull returned by the function \n\n right_conv_hull = np.array([[2, 1], [5, 1], [5, 3], [3, 5], [1, 4], [2, 1] ]) # right convex hull\n self.assertTrue((right_conv_hull == cv_hull).all())","def run(self, verbose=False, build_graph=False):\n from sage.combinat.crystals.letters import CrystalOfLetters\n letters = CrystalOfLetters(self.rigged_con.parent()._cartan_type.classical())\n\n # This is technically bad, but because the first thing we do is append\n # an empty list to ret_crystal_path, we correct this. We do it this\n # way so that we do not have to remove an empty list after the\n # bijection has been performed.\n ret_crystal_path = []\n\n for dim in self.rigged_con.parent().dims:\n ret_crystal_path.append([])\n\n # Check to see if we are a spinor\n if dim[0] == self.n:\n # Perform the spinor bijection by converting to type A_{2n-1}^{(2)}\n # doing the bijection there and pulling back\n\n from sage.combinat.rigged_configurations.bij_type_A2_odd import RCToKRTBijectionTypeA2Odd\n from sage.combinat.rigged_configurations.rigged_configurations import RiggedConfigurations\n from sage.combinat.rigged_configurations.rigged_partition import RiggedPartition, RiggedPartitionTypeB\n \n # Convert to a type A_{2n-1}^{(2)} RC\n RC = RiggedConfigurations(['A', 2*self.n-1, 2], self.cur_dims)\n if verbose:\n print(\"====================\")\n print(repr(RC(*self.cur_partitions, use_vacancy_numbers=True)))\n print(\"--------------------\")\n print(ret_crystal_path)\n print(\"--------------------\\n\")\n print(\"Applying doubling map\\n\")\n # Convert the n-th partition into a regular rigged partition\n self.cur_partitions[-1] = RiggedPartition(self.cur_partitions[-1]._list,\n self.cur_partitions[-1].rigging,\n self.cur_partitions[-1].vacancy_numbers)\n\n bij = RCToKRTBijectionTypeA2Odd(RC(*self.cur_partitions, use_vacancy_numbers=True))\n for i in range(len(self.cur_dims)):\n if bij.cur_dims[i][0] != self.n:\n bij.cur_dims[i][1] *= 2\n for i in range(self.n-1):\n for j in range(len(bij.cur_partitions[i])):\n bij.cur_partitions[i]._list[j] *= 2\n bij.cur_partitions[i].rigging[j] *= 2\n bij.cur_partitions[i].vacancy_numbers[j] *= 2\n\n if build_graph:\n y = self.rigged_con.parent()(*[x._clone() for x in self.cur_partitions], use_vacancy_numbers=True)\n self._graph.append([self._graph[-1][1], (y, len(self._graph)), '2x'])\n \n # Perform the type A_{2n-1}^{(2)} bijection\n \n # Iterate over each column\n for dummy_var in range(dim[1]):\n # Split off a new column if necessary\n if bij.cur_dims[0][1] > 1:\n bij.cur_dims[0][1] -= 1\n bij.cur_dims.insert(0, [dim[0], 1])\n \n # Perform the corresponding splitting map on rigged configurations\n # All it does is update the vacancy numbers on the RC side\n for a in range(self.n):\n bij._update_vacancy_numbers(a)\n\n if build_graph:\n y = self.rigged_con.parent()(*[x._clone() for x in self.cur_partitions], use_vacancy_numbers=True)\n self._graph.append([self._graph[-1][1], (y, len(self._graph)), 'ls'])\n \n while bij.cur_dims[0][0] > 0:\n if verbose:\n print(\"====================\")\n print(repr(RC(*bij.cur_partitions, use_vacancy_numbers=True)))\n print(\"--------------------\")\n print(ret_crystal_path)\n print(\"--------------------\\n\")\n\n bij.cur_dims[0][0] -= 1 # This takes care of the indexing\n b = bij.next_state(bij.cur_dims[0][0])\n # Make sure we have a crystal letter\n ret_crystal_path[-1].append(letters(b)) # Append the rank\n\n if build_graph:\n y = self.rigged_con.parent()(*[x._clone() for x in self.cur_partitions], use_vacancy_numbers=True)\n self._graph.append([self._graph[-1][1], (y, len(self._graph)), letters(b)])\n\n bij.cur_dims.pop(0) # Pop off the leading column\n\n self.cur_dims.pop(0) # Pop off the spin rectangle\n\n self.cur_partitions = bij.cur_partitions\n # Convert the n-th partition back into the special type B one\n self.cur_partitions[-1] = RiggedPartitionTypeB(self.cur_partitions[-1])\n\n # Convert back to a type B_n^{(1)}\n if verbose:\n print(\"====================\")\n print(repr(self.rigged_con.parent()(*bij.cur_partitions, use_vacancy_numbers=True)))\n print(\"--------------------\")\n print(ret_crystal_path)\n print(\"--------------------\\n\")\n print(\"Applying halving map\\n\")\n\n for i in range(self.n-1):\n for j in range(len(self.cur_partitions[i])):\n self.cur_partitions[i]._list[j] //= 2\n self.cur_partitions[i].rigging[j] //= 2\n self.cur_partitions[i].vacancy_numbers[j] //= 2\n\n if build_graph:\n y = self.rigged_con.parent()(*[x._clone() for x in self.cur_partitions], use_vacancy_numbers=True)\n self._graph.append([self._graph[-1][1], (y, len(self._graph)), '1/2x'])\n else:\n # Perform the regular type B_n^{(1)} bijection\n\n # Iterate over each column\n for dummy_var in range(dim[1]):\n # Split off a new column if necessary\n if self.cur_dims[0][1] > 1:\n if verbose:\n print(\"====================\")\n print(repr(self.rigged_con.parent()(*self.cur_partitions, use_vacancy_numbers=True)))\n print(\"--------------------\")\n print(ret_crystal_path)\n print(\"--------------------\\n\")\n print(\"Applying column split\")\n\n self.cur_dims[0][1] -= 1\n self.cur_dims.insert(0, [dim[0], 1])\n\n # Perform the corresponding splitting map on rigged configurations\n # All it does is update the vacancy numbers on the RC side\n for a in range(self.n):\n self._update_vacancy_numbers(a)\n\n if build_graph:\n y = self.rigged_con.parent()(*[x._clone() for x in self.cur_partitions], use_vacancy_numbers=True)\n self._graph.append([self._graph[-1][1], (y, len(self._graph)), '2x'])\n\n while self.cur_dims[0][0] > 0:\n if verbose:\n print(\"====================\")\n print(repr(self.rigged_con.parent()(*self.cur_partitions, use_vacancy_numbers=True)))\n print(\"--------------------\")\n print(ret_crystal_path)\n print(\"--------------------\\n\")\n\n self.cur_dims[0][0] -= 1 # This takes care of the indexing\n b = self.next_state(self.cur_dims[0][0])\n\n # Make sure we have a crystal letter\n ret_crystal_path[-1].append(letters(b)) # Append the rank\n\n if build_graph:\n y = self.rigged_con.parent()(*[x._clone() for x in self.cur_partitions], use_vacancy_numbers=True)\n self._graph.append([self._graph[-1][1], (y, len(self._graph)), letters(b)])\n\n self.cur_dims.pop(0) # Pop off the leading column\n\n if build_graph:\n self._graph.pop(0) # Remove the dummy at the start\n from sage.graphs.digraph import DiGraph\n from sage.graphs.dot2tex_utils import have_dot2tex\n self._graph = DiGraph(self._graph)\n if have_dot2tex():\n self._graph.set_latex_options(format=\"dot2tex\", edge_labels=True)\n\n return self.KRT(pathlist=ret_crystal_path)","def drawcutline(f,layernamelist,cutline_entities_count): \r\n \r\n #layernamelist=[layernamelist[0]] \r\n layercount=0\r\n ringlist=[[[-0.215+globalconfig.CUTLINE_X_OFFSET,0.0+globalconfig.CUTLINE_Y_OFFSET],[0.215+globalconfig.CUTLINE_X_OFFSET,0.0+globalconfig.CUTLINE_Y_OFFSET]],\r\n [[-0.215+globalconfig.CUTLINE_X_OFFSET,171.68+globalconfig.CUTLINE_Y_OFFSET],[0.215+globalconfig.CUTLINE_X_OFFSET,171.68+globalconfig.CUTLINE_Y_OFFSET]],\r\n [[-0.215+globalconfig.CUTLINE_X_OFFSET,175.68+globalconfig.CUTLINE_Y_OFFSET],[0.215+globalconfig.CUTLINE_X_OFFSET,175.68+globalconfig.CUTLINE_Y_OFFSET]],\r\n [[171.4650+globalconfig.CUTLINE_X_OFFSET,0.0+globalconfig.CUTLINE_Y_OFFSET],[171.8950+globalconfig.CUTLINE_X_OFFSET,0.0+globalconfig.CUTLINE_Y_OFFSET]],\r\n [[171.4650+globalconfig.CUTLINE_X_OFFSET,171.68+globalconfig.CUTLINE_Y_OFFSET],[171.8950+globalconfig.CUTLINE_X_OFFSET,171.68+globalconfig.CUTLINE_Y_OFFSET]]]\r\n flashlist=buildflashlist()\r\n cutlineset=buildcutlineset() \r\n \r\n f.write(\"0\\nSECTION\\n2\\nENTITIES\\n\")\r\n \r\n for layername in layernamelist:\r\n layercount=layercount+1\r\n for polyline in cutlineset:\r\n cutline_entities_count=cutline_entities_count+1\r\n f.write(\"0\\nPOLYLINE\\n8\\n\"+layername+\"\\n5\\n\"+hex(cutline_entities_count)[2:]) # begin writing a polyline\r\n f.write(\"\\n66\\n1\\n10\\n0.0\\n20\\n0.0\\n30\\n0.0\\n40\\n0.08\\n41\\n0.08\\n\")\r\n cutline_entities_count=drawwidthpolyline(polyline, cutline_entities_count, f,layername)\r\n cutline_entities_count=drawring(ringlist, cutline_entities_count, f, layername)\r\n cutline_entities_count=drawflash(flashlist, cutline_entities_count, f, layername)\r\n cutline_entities_count=drawtext(cutline_entities_count, f, layername,layercount)\r\n \r\n return cutline_entities_count","def ring(self):\n pass"],"string":"[\n \"def test_creation(self):\\n\\n assert self.test_shape.solid is not None\\n assert self.test_shape.volume() > 1000\",\n \"def test_creation(self):\\n\\n assert self.test_shape.solid is not None\\n assert self.test_shape.volume() > 1000\",\n \"def add_cable_ring(self, env, info={}, cable_idx=0):\\n def rad_to_deg(rad):\\n return (rad * 180.0) / np.pi\\n\\n def get_discretized_rotations(num_rotations):\\n # counter-clockwise\\n theta = i * (2 * np.pi) / num_rotations\\n return (theta, rad_to_deg(theta))\\n\\n # Bead properties.\\n num_parts = self.num_parts\\n radius = self.radius\\n color = self.colors[cable_idx] + [1]\\n\\n # The `ring_radius` (not the bead radius!) has to be tuned somewhat.\\n # Try to make sure the beads don't have notable gaps between them.\\n ring_radius = info['ring_radius']\\n beads = []\\n bead_positions_l = []\\n\\n # Add beaded cable. Here, `position` is the circle center.\\n position = np.float32(info['center_position'])\\n part_shape = p.createCollisionShape(p.GEOM_BOX, halfExtents=[radius]*3)\\n part_visual = p.createVisualShape(p.GEOM_SPHERE, radius=radius*1.5)\\n\\n # Iterate through parts and create constraints as needed.\\n for i in range(num_parts):\\n angle_rad, _ = get_discretized_rotations(num_parts)\\n px = ring_radius * np.cos(angle_rad)\\n py = ring_radius * np.sin(angle_rad)\\n #print(f'pos: {px:0.2f}, {py:0.2f}, angle: {angle_rad:0.2f}, {angle_deg:0.1f}')\\n bead_position = np.float32([position[0] + px, position[1] + py, 0.01])\\n part_id = p.createMultiBody(0.1, part_shape, part_visual,\\n basePosition=bead_position)\\n p.changeVisualShape(part_id, -1, rgbaColor=color)\\n\\n if i > 0:\\n parent_frame = bead_position - bead_positions_l[-1]\\n constraint_id = p.createConstraint(\\n parentBodyUniqueId=beads[-1],\\n parentLinkIndex=-1,\\n childBodyUniqueId=part_id,\\n childLinkIndex=-1,\\n jointType=p.JOINT_POINT2POINT,\\n jointAxis=(0, 0, 0),\\n parentFramePosition=parent_frame,\\n childFramePosition=(0, 0, 0))\\n p.changeConstraint(constraint_id, maxForce=100)\\n\\n # Make a constraint with i=0. Careful with `parent_frame`!\\n if i == num_parts - 1:\\n parent_frame = bead_positions_l[0] - bead_position\\n constraint_id = p.createConstraint(\\n parentBodyUniqueId=part_id,\\n parentLinkIndex=-1,\\n childBodyUniqueId=beads[0],\\n childLinkIndex=-1,\\n jointType=p.JOINT_POINT2POINT,\\n jointAxis=(0, 0, 0),\\n parentFramePosition=parent_frame,\\n childFramePosition=(0, 0, 0))\\n p.changeConstraint(constraint_id, maxForce=100)\\n\\n # Track beads.\\n beads.append(part_id)\\n bead_positions_l.append(bead_position)\\n\\n # The usual for tracking IDs. Four things to add.\\n self.cable_bead_IDs.append(part_id)\\n self._IDs[part_id] = f'cable_part_{str(part_id).zfill(2)}'\\n env.objects.append(part_id)\\n self.object_points[part_id] = np.float32((0, 0, 0)).reshape(3, 1)\\n\\n if 'cable-ring' in self._name:\\n # For targets, we can assume the starting position gives us\\n # that. Later, apply a random force on the ring to perturb it.\\n true_position = (bead_position[0], bead_position[1], 0)\\n self.goal['places'][part_id] = (true_position, (0, 0, 0, 1.))\\n symmetry = 0\\n self.goal['steps'][0][part_id] = (symmetry, [part_id])\\n\\n # Make the true positions visible if desired.\\n if info['targets_visible']:\\n sq_pose = ((true_position[0], true_position[1], 0.002), (0,0,0,1))\\n sq_template = 'assets/square/square-template-allsides-green.urdf'\\n replace = {'DIM': (0.003,), 'HALF': (0.003 / 2,)}\\n urdf = self.fill_template(sq_template, replace)\\n env.add_object(urdf, sq_pose, fixed=True)\\n os.remove(urdf)\\n else:\\n print(f'Warning, env {self._name} will not have goals.')\",\n \"def generate_solid(self):\\n ext = os.path.splitext(self.filename)[1][1:]\\n if ext == 'stl':\\n shaft_compound = read_stl_file(self.filename)\\n elif ext == 'iges':\\n iges_reader = IGESControl_Reader()\\n iges_reader.ReadFile(self.filename)\\n iges_reader.TransferRoots()\\n shaft_compound = iges_reader.Shape()\\n else:\\n raise Exception('The shaft file is not in iges/stl formats')\\n sewer = BRepBuilderAPI_Sewing(1e-2)\\n sewer.Add(shaft_compound)\\n sewer.Perform()\\n result_sewed_shaft = sewer.SewedShape()\\n shaft_solid_maker = BRepBuilderAPI_MakeSolid()\\n shaft_solid_maker.Add(OCC.Core.TopoDS.topods_Shell(result_sewed_shaft))\\n if not shaft_solid_maker.IsDone():\\n raise RuntimeError('Unsuccessful assembling of solid shaft')\\n shaft_solid = shaft_solid_maker.Solid()\\n return shaft_solid\",\n \"def _create_main_shape(self):\\n\\n a, b = gc( self.size/2,\\n self._ZERO_DEGREES - self.angle,\\n self._180_DEGREES + self.angle)\\n self.wafer_points = zip(a,b)\\n self.wafer_polygon = gdspy.Polygon(self.wafer_points, self.WAFER_LAYER)\\n self.cell.add(self.wafer_polygon)\",\n \"def _check_mount(self):\\n if self.mount == ComponentBase.MOUNT_SMD:\\n valid_shapes = [Con.SHAPE_PAD]\\n default_shape = Con.SHAPE_PAD\\n elif self.mount == ComponentBase.MOUNT_THT:\\n valid_shapes = [Con.SHAPE_HOLE, Con.SHAPE_RHOLE]\\n default_shape = Con.SHAPE_HOLE\\n \\n for con in self.connectors:\\n if con.p_shape not in valid_shapes:\\n con.p_shape = default_shape\",\n \"def __bcc_left_diagonals(self) -> cq.cq.Workplane:\\n # In a cuboid ABCDA1B1C1D1 this is the angle C1AD\\n #angle_C1AD = 90 - degrees(acos(2**-.5))\\n angle_C1AD = 90 - degrees(acos(0.5))\\n angle_CAD = 90 - degrees(acos(sqrt(2/3)))\\n pseudo_unit_cell_size = sqrt(2/3)*self.unit_cell_size\\n corner_points = np.array(\\n [(0, 0),\\n (self.bcc_unit_cell_size, 0),\\n (self.bcc_unit_cell_size, self.unit_cell_size),\\n (0, self.unit_cell_size)]\\n )\\n result = (\\n cq.Workplane(\\\"XY\\\")\\n .pushPoints(corner_points)\\n .eachpointAdaptive(\\n create_bcc_diagonal_strut,\\n callback_extra_args = [\\n {\\\"unit_cell_size\\\": pseudo_unit_cell_size,\\n \\\"radius\\\": self.strut_radius,\\n \\\"angle_x\\\": - angle_CAD,\\n \\\"angle_y\\\": angle_C1AD},\\n {\\\"unit_cell_size\\\": 0.5 * pseudo_unit_cell_size,\\n \\\"radius\\\": self.strut_radius,\\n \\\"angle_x\\\": - angle_CAD,\\n \\\"angle_y\\\": - angle_C1AD},\\n {\\\"unit_cell_size\\\": 0.5 * pseudo_unit_cell_size,\\n \\\"radius\\\": self.strut_radius,\\n \\\"angle_x\\\": angle_CAD,\\n \\\"angle_y\\\": - angle_C1AD},\\n {\\\"unit_cell_size\\\": pseudo_unit_cell_size,\\n \\\"radius\\\": self.strut_radius,\\n \\\"angle_x\\\": angle_CAD,\\n \\\"angle_y\\\": angle_C1AD}\\n ],\\n useLocalCoords = True\\n )\\n )\\n return result\",\n \"def test_drawSolid(self):\\n\\n image_name = filename(sys._getframe().f_code.co_name)\\n result_file, reference_file = get_path(image_name)\\n\\n ''' This function is to create an empty image with a specific dimension\\n with white background, and black/white colored '''\\n\\n image, canvas = get_image('RGB', (640, 480), 'white')\\n\\n '''\\n for different representations of colors see\\n \\\"https://pillow.readthedocs.io/en/3.0.x/reference/ImageColor.html#color-names\\\"\\n '''\\n drawSolid(canvas, regularPolygon(3, np.array([160, 120]), 50), 'red')\\n drawSolid(canvas, regularPolygon(4, np.array([480, 120]), 90), 'blue')\\n drawSolid(canvas, regularPolygon(5, np.array([420, 360]), 60), 'green')\\n drawSolid(canvas, regularPolygon(6, np.array([160, 360]), 80), 'black')\\n drawSolid(canvas, regularPolygon(7, np.array([320, 160]), 70), 'brown')\\n\\n \\\"\\\"\\\" saving the file and closing it \\\"\\\"\\\"\\n image.save(result_file)\\n image.close()\\n\\n \\\"\\\"\\\" validate the resultant file against the reference images\\\"\\\"\\\"\\n\\n validate(reference_file, result_file)\",\n \"def test_rocket():\\n ring = [(0,0), (10, 0), (15,5), (10,9), (1,7), (6,4), (0,0)]\\n conv = ToPointsAndSegments()\\n conv.add_polygon([ring])\\n skel = calc_skel(conv, output=True, pause=True)\\n print \\\"DONE\\\"\",\n \"def finalize(self):\\n\\n if self.finalized:\\n return\\n\\n ## Loop over each ring and add cells for inner rings\\n params = zip(self.radii, self.box, self.fills, self.rot)\\n for i, (radius, box, fill, rot) in enumerate(params):\\n\\n label = \\\"{0} radial {1}: {2}\\\".format(self._name, i, fill._name)\\n\\n if i == 0:\\n # this is the first ring\\n\\n if box:\\n # this first ring is a box ring\\n\\n cell = openmc.Cell(name=label, fill=fill)\\n cell.region = radius\\n if not rot is None: cell.rotation = rot\\n self.add_cell(cell)\\n\\n else:\\n # this first ring is a regular cylinder\\n\\n cell = openmc.Cell(name=label, fill=fill)\\n cell.region = -radius\\n if not rot is None: cell.rotation = rot\\n self.add_cell(cell)\\n\\n else:\\n # this is not the first ring\\n\\n if self.box[i-1]:\\n # the last ring was a box\\n\\n if box:\\n # this is a box ring, and the last one was also a box ring\\n cell = openmc.Cell(name=label, fill=fill)\\n cell.region = ~radius\\n if not rot is None: cell.rotation = rot\\n self.add_cell(cell)\\n\\n else:\\n # this is a regular cylinder, and the last one was a box ring\\n cell = openmc.Cell(name=label, fill=fill)\\n cell.region = -r & ~self.radii[i-1]\\n self.add_cell(cell)\\n\\n else:\\n # the last ring was a regular cylinder\\n\\n if box:\\n # this is a box ring, and the last one was a regular cylinder\\n\\n cell = openmc.Cell(name=label, fill=fill)\\n cell.region = +self.radii[i-1] & radius\\n if not rot is None: cell.rotation = rot\\n self.add_cell(cell)\\n\\n else:\\n # this is a regular ring, and the last one was a regular cylinder\\n\\n cell = openmc.Cell(name=label, fill=fill)\\n cell.region = +self.radii[i-1] & -radius\\n if not rot is None: cell.rotation = rot\\n self.add_cell(cell)\\n\\n ## Now write the outermost cell(s) that go to infinity\\n\\n label = \\\"{0} radial outer: {1}\\\".format(self._name, self.fills[-1]._name)\\n\\n if self.box[-1]:\\n # the last one is a box, we need 4 outer cells to infinity\\n cell = openmc.Cell(name=label, fill=self.fills[-1])\\n cell.region = ~radius\\n if not self.rot[-1] is None: cell.rotation = self.rot[-1]\\n self.add_cell(cell)\\n\\n else:\\n\\n # the last one is a regular cylindrical ring - just one cell to infinity\\n cell = openmc.Cell(name=label, fill=self.fills[-1])\\n cell.region = +self.radii[-1]\\n if not self.rot[-1] is None: cell.rotation = self.rot[-1]\\n self.add_cell(cell)\\n\\n self.finalized = True\",\n \"def test_polygons_with_inner_rings(self):\\n\\n # Define two (closed) outer rings - clock wise direction\\n outer_rings = [numpy.array([[106.79, -6.233],\\n [106.80, -6.24],\\n [106.78, -6.23],\\n [106.77, -6.21],\\n [106.79, -6.233]]),\\n numpy.array([[106.76, -6.23],\\n [106.72, -6.23],\\n [106.72, -6.22],\\n [106.72, -6.21],\\n [106.76, -6.23]])]\\n\\n tmp_filename = unique_filename(suffix='.shp')\\n\\n # Do outer rings first (use default geometry type polygon)\\n v_ref = Vector(geometry=outer_rings)\\n assert v_ref.is_polygon_data\\n\\n v_ref.write_to_file(tmp_filename)\\n v_file = read_layer(tmp_filename)\\n assert v_file == v_ref\\n assert v_file.is_polygon_data\\n\\n # Do it again but with (closed) inner rings as well\\n\\n # Define inner rings (counter clock wise)\\n inner_rings = [\\n # 2 rings for feature 0\\n [numpy.array([[106.77827, -6.2252],\\n [106.77775, -6.22378],\\n [106.78, -6.22311],\\n [106.78017, -6.22530],\\n [106.77827, -6.2252]])[::-1],\\n numpy.array([[106.78652, -6.23215],\\n [106.78642, -6.23075],\\n [106.78746, -6.23143],\\n [106.78831, -6.23307],\\n [106.78652, -6.23215]])[::-1]],\\n # 1 ring for feature 1\\n [numpy.array([[106.73709, -6.22752],\\n [106.73911, -6.22585],\\n [106.74265, -6.22814],\\n [106.73971, -6.22926],\\n [106.73709, -6.22752]])[::-1]]]\\n\\n polygons = []\\n for i, outer_ring in enumerate(outer_rings):\\n p = Polygon(outer_ring=outer_ring, inner_rings=inner_rings[i])\\n polygons.append(p)\\n\\n v_ref = Vector(geometry=polygons)\\n assert v_ref.is_polygon_data\\n data_bbox = v_ref.get_bounding_box()\\n\\n # Check data from Vector object\\n geometry = v_ref.get_geometry(as_geometry_objects=True)\\n for i, g in enumerate(geometry):\\n assert numpy.allclose(g.outer_ring, outer_rings[i])\\n if i == 0:\\n assert len(g.inner_rings) == 2\\n else:\\n assert len(g.inner_rings) == 1\\n\\n for j, ring in enumerate(inner_rings[i]):\\n assert numpy.allclose(ring, g.inner_rings[j])\\n\\n # Write to file and read again\\n v_ref.write_to_file(tmp_filename)\\n #print 'With inner rings, written to ', tmp_filename\\n v_file = read_layer(tmp_filename)\\n assert v_file == v_ref\\n assert v_file.is_polygon_data\\n assert numpy.allclose(v_file.get_bounding_box(), data_bbox,\\n rtol=1.0e-12, atol=1.0e-12)\\n\\n # Check data from file\\n geometry = v_file.get_geometry(as_geometry_objects=True)\\n for i, g in enumerate(geometry):\\n assert numpy.allclose(g.outer_ring, outer_rings[i])\\n if i == 0:\\n assert len(g.inner_rings) == 2\\n else:\\n assert len(g.inner_rings) == 1\\n\\n for j, ring in enumerate(inner_rings[i]):\\n assert numpy.allclose(ring, g.inner_rings[j])\",\n \"def build_lens_icosahedron(kabamland, vtx, rad, diameter_ratio, thickness_ratio, half_EPD, blockers=True, blocker_thickness_ratio=1.0/1000, light_confinement=False, focal_length=1.0, lens_system_name=None):\\n # Get the list of lens meshes from the appropriate lens system as well as the lens material'''\\n scale_rad = rad*diameter_ratio #max_radius->rad of the lens assembly\\n lenses = lenssystem.get_lens_mesh_list(lens_system_name, scale_rad)\\n lensmat = lenssystem.get_lens_material(lens_system_name)\\n face = None\\n for lns in lenses:\\n #lns = mh.rotate(lns,make_rotation_matrix(ph,ax))\\n if not face:\\n face = Solid(lns, lensmat, kabamland.detector_material)\\n else:\\n face += Solid(lns, lensmat, kabamland.detector_material)\\n\\n if light_confinement:\\n shield = mh.rotate(cylindrical_shell(rad*(1 - 0.001), rad, focal_length,32), make_rotation_matrix(np.pi/2.0, (1,0,0)))\\n baffle = Solid(shield, lensmat, kabamland.detector_material, black_surface, 0xff0000)\\n\\n if blockers:\\n blocker_thickness = 2*rad*blocker_thickness_ratio\\n if half_EPD < rad:\\n c1 = lenssystem.get_lens_sys(lens_system_name).c1*lenssystem.get_scale_factor(lens_system_name,scale_rad)\\n offset = [0,0,c1-np.sqrt(c1*c1-rad*rad)]\\n anulus_blocker = mh.shift(mh.rotate(cylindrical_shell(half_EPD, rad, blocker_thickness, 32), make_rotation_matrix(np.pi/2.0, (1,0,0))),offset)\\n face += Solid(anulus_blocker, lensmat, kabamland.detector_material, black_surface, 0xff0000)\\n phi, axs = rot_axis([0,0,1],vtx)\\n for vx,ph,ax in zip(vtx,-phi,axs):\\n kabamland.add_solid(face, rotation=make_rotation_matrix(ph,ax), displacement = -vx)\\n if light_confinement:\\n kabamland.add_solid(baffle, rotation=make_rotation_matrix(ph,ax), displacement = -normalize(vx)*(np.linalg.norm(vx)+focal_length/2.0))\",\n \"def createCylinder( basePoint=(0,-1,0), tipPoint=(0,1,0), radius = 1.0, colour=(0.6,0.6,0.6), samples = 20 ):\\r\\n \\r\\n basePoint = PyUtils.toPoint3d(basePoint)\\r\\n tipPoint = PyUtils.toPoint3d(tipPoint)\\r\\n baseToTipVector = Vector3d(basePoint,tipPoint)\\r\\n if baseToTipVector.isZeroVector() :\\r\\n raise ValueError( 'Invalid points for cylinder: base and tip are equal!' )\\r\\n baseToTipUnitVector = baseToTipVector.unit()\\r\\n xUnitVector = baseToTipUnitVector.crossProductWith( Vector3d(0,0,1) )\\r\\n if xUnitVector.length() < 0.5 :\\r\\n xUnitVector = baseToTipUnitVector.crossProductWith( Vector3d(0,-1,0) )\\r\\n xUnitVector.toUnit()\\r\\n yUnitVector = baseToTipUnitVector.crossProductWith( Vector3d(-1,0,0) )\\r\\n if yUnitVector.length() < 0.5 :\\r\\n yUnitVector = baseToTipUnitVector.crossProductWith( Vector3d(0,1,0) )\\r\\n yUnitVector.toUnit()\\r\\n\\r\\n vertices = []\\r\\n for i in range(samples):\\r\\n theta = i * 2 * math.pi / float(samples)\\r\\n vertices.append( basePoint + xUnitVector * math.cos(theta) * radius + yUnitVector * math.sin(theta) * radius )\\r\\n for i in range(samples):\\r\\n theta = i * 2 * math.pi / float(samples)\\r\\n vertices.append( tipPoint + xUnitVector * math.cos(theta) * radius + yUnitVector * math.sin(theta) * radius )\\r\\n for i in range(samples):\\r\\n theta = i * 2 * math.pi / float(samples)\\r\\n vertices.append( basePoint + xUnitVector * math.cos(theta) * radius + yUnitVector * math.sin(theta) * radius )\\r\\n vertices.append( tipPoint + xUnitVector * math.cos(theta) * radius + yUnitVector * math.sin(theta) * radius )\\r\\n \\r\\n faces = [ range(0,samples), range(samples,2*samples) ]\\r\\n for i in range(0,2*samples,2) :\\r\\n base = 2*samples\\r\\n size = 2*samples\\r\\n faces.append( (base+i, base+i+1, base+(i+3)%size, base+(i+2)%size ) )\\r\\n \\r\\n return create( vertices, faces, colour )\",\n \"def create_rink():\\n\\n # RINK\\n coords = OFFSET, OFFSET, OFFSET+22*SCALE, OFFSET+22*SCALE\\n canvas.create_arc(coords, start=90, extent=90, fill=WHITE, outline=\\\"\\\")\\n coords = OFFSET, HEIGHT-OFFSET-22*SCALE, OFFSET+22*SCALE, HEIGHT-OFFSET\\n canvas.create_arc(coords, start=180, extent=90, fill=WHITE, outline=WHITE)\\n coords = WIDTH-OFFSET-22*SCALE, HEIGHT-OFFSET-22*SCALE, WIDTH-OFFSET, HEIGHT-OFFSET\\n canvas.create_arc(coords, start=270, extent=90, fill=WHITE, outline=WHITE)\\n coords = WIDTH-OFFSET-22*SCALE, OFFSET, WIDTH-OFFSET, OFFSET+22*SCALE\\n canvas.create_arc(coords, start=0, extent=90, fill=WHITE, outline=WHITE)\\n coords = OFFSET+11*SCALE, OFFSET, WIDTH-OFFSET-11*SCALE, OFFSET, WIDTH-OFFSET-11*SCALE, HEIGHT-OFFSET, OFFSET+11*SCALE, HEIGHT-OFFSET\\n canvas.create_polygon(coords, fill=WHITE, outline=WHITE)\\n coords = OFFSET, OFFSET+11*SCALE, WIDTH-OFFSET, OFFSET+11*SCALE, WIDTH-OFFSET, HEIGHT-OFFSET-11*SCALE, OFFSET, HEIGHT-OFFSET-11*SCALE\\n canvas.create_polygon(coords, fill=WHITE, outline=WHITE)\\n\\n # CENTER CIRCLE\\n coords = WIDTH/2-15*SCALE, HEIGHT/2-15*SCALE, WIDTH/2+15*SCALE, HEIGHT/2+15*SCALE\\n canvas.create_oval(coords, outline=BLUE, width=2, fill=WHITE)\\n\\n # HALF CENTER CIRCLE\\n coords = WIDTH/2-10*SCALE, HEIGHT-OFFSET-10*SCALE, WIDTH/2+10*SCALE, HEIGHT-OFFSET+10*SCALE\\n canvas.create_arc(coords, outline=RED, width=2, start=0, extent=180)\\n\\n # GOAL AREA\\n # - Left\\n # - - Crease\\n coords = OFFSET+5*SCALE, HEIGHT/2-6*SCALE, OFFSET+17*SCALE, HEIGHT/2+6*SCALE\\n canvas.create_arc(coords, fill=LIGHT_BLUE, start=318, extent=84, outline=\\\"\\\")\\n canvas.create_arc(coords, outline=RED, start=318, extent=84, style=ARC)\\n coords = OFFSET+11*SCALE, HEIGHT/2-4*SCALE, OFFSET+15.5*SCALE, HEIGHT/2-4*SCALE, OFFSET+15.5*SCALE, HEIGHT/2+4*SCALE, OFFSET+11*SCALE, HEIGHT/2+4*SCALE\\n canvas.create_polygon(coords, fill=LIGHT_BLUE, outline=\\\"\\\")\\n coords = OFFSET+11*SCALE, HEIGHT/2-4*SCALE, OFFSET+15.2*SCALE+1, HEIGHT/2-4*SCALE\\n canvas.create_line(coords, fill=RED)\\n coords = OFFSET+15.2*SCALE+1, HEIGHT/2+4*SCALE, OFFSET+11*SCALE, HEIGHT/2+4*SCALE\\n canvas.create_line(coords, fill=RED)\\n # - - Restricted Area\\n coords = OFFSET, HEIGHT/2-14*SCALE, OFFSET+11*SCALE, HEIGHT/2-9*SCALE\\n canvas.create_line(coords, fill=RED)\\n coords = OFFSET, HEIGHT/2+14*SCALE, OFFSET+11*SCALE, HEIGHT/2+9*SCALE\\n canvas.create_line(coords, fill=RED)\\n # - - Goal\\n coords = OFFSET+8*SCALE, HEIGHT/2-3*SCALE, OFFSET+11*SCALE, HEIGHT/2-3*SCALE, OFFSET+11*SCALE, HEIGHT/2+3*SCALE, OFFSET+8*SCALE, HEIGHT/2+3*SCALE\\n canvas.create_polygon(coords, fill=GRAY, outline=RED)\\n # - Right\\n # - - Crease\\n coords = WIDTH-(OFFSET+5*SCALE), HEIGHT/2-6*SCALE, WIDTH-(OFFSET+17*SCALE), HEIGHT/2+6*SCALE\\n canvas.create_arc(coords, fill=LIGHT_BLUE, start=138, extent=84, outline=\\\"\\\")\\n canvas.create_arc(coords, outline=RED, start=138, extent=84, style=ARC)\\n coords = WIDTH-(OFFSET+11*SCALE), HEIGHT/2-4*SCALE, WIDTH-(OFFSET+15.5*SCALE), HEIGHT/2-4*SCALE, WIDTH-(OFFSET+15.5*SCALE), HEIGHT/2+4*SCALE, WIDTH-(OFFSET+11*SCALE), HEIGHT/2+4*SCALE\\n canvas.create_polygon(coords, fill=LIGHT_BLUE, outline=\\\"\\\")\\n coords = WIDTH-(OFFSET+11*SCALE), HEIGHT/2-4*SCALE, WIDTH-(OFFSET+15.2*SCALE+1), HEIGHT/2-4*SCALE\\n canvas.create_line(coords, fill=RED)\\n coords = WIDTH-(OFFSET+15.2*SCALE+1), HEIGHT/2+4*SCALE, WIDTH-(OFFSET+11*SCALE), HEIGHT/2+4*SCALE\\n canvas.create_line(coords, fill=RED)\\n # - - Restricted Area\\n coords = WIDTH-OFFSET, HEIGHT/2-14*SCALE, WIDTH-OFFSET-11*SCALE, HEIGHT/2-9*SCALE\\n canvas.create_line(coords, fill=RED)\\n coords = WIDTH-OFFSET, HEIGHT/2+14*SCALE, WIDTH-OFFSET-11*SCALE, HEIGHT/2+9*SCALE\\n canvas.create_line(coords, fill=RED)\\n # - - Goal\\n coords = WIDTH-(OFFSET+8*SCALE), HEIGHT/2-3*SCALE, WIDTH-(OFFSET+11*SCALE), HEIGHT/2-3*SCALE, WIDTH-(OFFSET+11*SCALE), HEIGHT/2+3*SCALE, WIDTH-(OFFSET+8*SCALE), HEIGHT/2+3*SCALE\\n canvas.create_polygon(coords, fill=GRAY, outline=RED)\\n\\n # LINES\\n # - Left Baseline\\n coords = OFFSET+11*SCALE, OFFSET, OFFSET+11*SCALE, HEIGHT-OFFSET\\n canvas.create_line(coords, fill=RED, width=1.5)\\n # - Right Baseline\\n coords = WIDTH-OFFSET-11*SCALE, OFFSET, WIDTH-OFFSET-11*SCALE, HEIGHT-OFFSET\\n canvas.create_line(coords, fill=RED, width=1.5)\\n # - Left Blueline\\n coords = OFFSET+70*SCALE, OFFSET, OFFSET+70*SCALE, HEIGHT-OFFSET\\n canvas.create_line(coords, fill=BLUE, width=7)\\n # - Right Blueline\\n coords = WIDTH-(OFFSET+70*SCALE), OFFSET, WIDTH-(OFFSET+70*SCALE), HEIGHT-OFFSET\\n canvas.create_line(coords, fill=BLUE, width=7)\\n # - Redline\\n coords = WIDTH/2, OFFSET, WIDTH/2, HEIGHT-OFFSET\\n canvas.create_line(coords, fill=RED, width=7)\\n coords = WIDTH/2, OFFSET, WIDTH/2, HEIGHT-OFFSET\\n canvas.create_line(coords, fill=WHITE, width=5, dash=(9,9))\\n\\n # RINK OUTLINE\\n coords = OFFSET, OFFSET, OFFSET+22*SCALE, OFFSET+22*SCALE\\n canvas.create_arc(coords, start=90, extent=90, outline=BLACK, style=ARC, width=2)\\n coords = OFFSET, HEIGHT-OFFSET-22*SCALE, OFFSET+22*SCALE, HEIGHT-OFFSET\\n canvas.create_arc(coords, start=180, extent=90, outline=BLACK, style=ARC, width=2)\\n coords = WIDTH-OFFSET-22*SCALE, HEIGHT-OFFSET-22*SCALE, WIDTH-OFFSET, HEIGHT-OFFSET\\n canvas.create_arc(coords, start=270, extent=90, outline=BLACK, style=ARC, width=2)\\n coords = WIDTH-OFFSET-22*SCALE, OFFSET, WIDTH-OFFSET, OFFSET+22*SCALE\\n canvas.create_arc(coords, start=0, extent=90, outline=BLACK, style=ARC, width=2)\\n coords = OFFSET+11*SCALE, OFFSET, WIDTH-OFFSET-11*SCALE, OFFSET\\n canvas.create_line(coords, fill=BLACK, width=2)\\n coords = WIDTH-OFFSET, OFFSET+11*SCALE, WIDTH-OFFSET, HEIGHT-OFFSET-11*SCALE\\n canvas.create_line(coords, fill=BLACK, width=2)\\n coords = WIDTH-OFFSET-11*SCALE, HEIGHT-OFFSET, OFFSET+11*SCALE, HEIGHT-OFFSET\\n canvas.create_line(coords, fill=BLACK, width=2)\\n coords = OFFSET, OFFSET+11*SCALE, OFFSET, HEIGHT-OFFSET-11*SCALE\\n canvas.create_line(coords, fill=BLACK, width=2)\\n\\n\\n # CENTER DOT\\n coords = WIDTH/2-1*SCALE-1, HEIGHT/2-1*SCALE-1, WIDTH/2+1*SCALE+1, HEIGHT/2+1*SCALE+1\\n canvas.create_oval(coords, outline=WHITE, fill=BLUE)\\n\\n # FACEOFF\\n # - Top Left\\n # - - Ticks\\n coords = OFFSET+29.5*SCALE, HEIGHT/2-39*SCALE, OFFSET+29.5*SCALE, HEIGHT/2-5*SCALE\\n canvas.create_line(coords, fill=RED, width=2)\\n coords = OFFSET+32.5*SCALE, HEIGHT/2-39*SCALE, OFFSET+32.5*SCALE, HEIGHT/2-5*SCALE\\n canvas.create_line(coords, fill=RED, width=2)\\n # - - Circles\\n coords = OFFSET+16*SCALE, HEIGHT/2-37*SCALE, OFFSET+46*SCALE, HEIGHT/2-7*SCALE\\n canvas.create_oval(coords, outline=RED, width=2, fill=WHITE)\\n coords = OFFSET+30*SCALE, HEIGHT/2-23*SCALE, OFFSET+32*SCALE, HEIGHT/2-21*SCALE\\n canvas.create_oval(coords, fill=RED, outline=\\\"\\\")\\n # - - Cross\\n coords = OFFSET+25*SCALE, HEIGHT/2-22.8*SCALE, OFFSET+29*SCALE, HEIGHT/2-22.8*SCALE, OFFSET+29*SCALE, HEIGHT/2-25.8*SCALE\\n canvas.create_line(coords, fill=RED, width=2)\\n coords = OFFSET+25*SCALE, HEIGHT/2-21.2*SCALE, OFFSET+29*SCALE, HEIGHT/2-21.2*SCALE, OFFSET+29*SCALE, HEIGHT/2-18.2*SCALE\\n canvas.create_line(coords, fill=RED, width=2)\\n coords = OFFSET+37*SCALE, HEIGHT/2-22.8*SCALE, OFFSET+33*SCALE, HEIGHT/2-22.8*SCALE, OFFSET+33*SCALE, HEIGHT/2-25.8*SCALE\\n canvas.create_line(coords, fill=RED, width=2)\\n coords = OFFSET+37*SCALE, HEIGHT/2-21.2*SCALE, OFFSET+33*SCALE, HEIGHT/2-21.2*SCALE, OFFSET+33*SCALE, HEIGHT/2-18.2*SCALE\\n canvas.create_line(coords, fill=RED, width=2)\\n # - Bottom Left\\n # - - Ticks\\n coords = OFFSET+29.5*SCALE, HEIGHT/2+39*SCALE, OFFSET+29.5*SCALE, HEIGHT/2+5*SCALE\\n canvas.create_line(coords, fill=RED, width=2)\\n coords = OFFSET+32.5*SCALE, HEIGHT/2+39*SCALE, OFFSET+32.5*SCALE, HEIGHT/2+5*SCALE\\n canvas.create_line(coords, fill=RED, width=2)\\n # - - Circles\\n coords = OFFSET+16*SCALE, HEIGHT/2+37*SCALE, OFFSET+46*SCALE, HEIGHT/2+7*SCALE\\n canvas.create_oval(coords, outline=RED, width=2, fill=WHITE)\\n coords = OFFSET+30*SCALE, HEIGHT/2+23*SCALE, OFFSET+32*SCALE, HEIGHT/2+21*SCALE\\n canvas.create_oval(coords, fill=RED, outline=\\\"\\\")\\n # - - Cross\\n coords = OFFSET+25*SCALE, HEIGHT/2+22.8*SCALE, OFFSET+29*SCALE, HEIGHT/2+22.8*SCALE, OFFSET+29*SCALE, HEIGHT/2+25.8*SCALE\\n canvas.create_line(coords, fill=RED, width=2)\\n coords = OFFSET+25*SCALE, HEIGHT/2+21.2*SCALE, OFFSET+29*SCALE, HEIGHT/2+21.2*SCALE, OFFSET+29*SCALE, HEIGHT/2+18.2*SCALE\\n canvas.create_line(coords, fill=RED, width=2)\\n coords = OFFSET+37*SCALE, HEIGHT/2+22.8*SCALE, OFFSET+33*SCALE, HEIGHT/2+22.8*SCALE, OFFSET+33*SCALE, HEIGHT/2+25.8*SCALE\\n canvas.create_line(coords, fill=RED, width=2)\\n coords = OFFSET+37*SCALE, HEIGHT/2+21.2*SCALE, OFFSET+33*SCALE, HEIGHT/2+21.2*SCALE, OFFSET+33*SCALE, HEIGHT/2+18.2*SCALE\\n canvas.create_line(coords, fill=RED, width=2)\\n # - Top Right\\n # - - Ticks\\n coords = WIDTH-(OFFSET+29.5*SCALE), HEIGHT/2-39*SCALE, WIDTH-(OFFSET+29.5*SCALE), HEIGHT/2-5*SCALE\\n canvas.create_line(coords, fill=RED, width=2)\\n coords = WIDTH-(OFFSET+32.5*SCALE), HEIGHT/2-39*SCALE, WIDTH-(OFFSET+32.5*SCALE), HEIGHT/2-5*SCALE\\n canvas.create_line(coords, fill=RED, width=2)\\n # - - Circles\\n coords = WIDTH-(OFFSET+16*SCALE), HEIGHT/2-37*SCALE, WIDTH-(OFFSET+46*SCALE), HEIGHT/2-7*SCALE\\n canvas.create_oval(coords, outline=RED, width=2, fill=WHITE)\\n coords = WIDTH-(OFFSET+30*SCALE), HEIGHT/2-23*SCALE, WIDTH-(OFFSET+32*SCALE), HEIGHT/2-21*SCALE\\n canvas.create_oval(coords, fill=RED, outline=\\\"\\\")\\n # - - Cross\\n coords = WIDTH-(OFFSET+25*SCALE), HEIGHT/2-22.8*SCALE, WIDTH-(OFFSET+29*SCALE), HEIGHT/2-22.8*SCALE, WIDTH-(OFFSET+29*SCALE), HEIGHT/2-25.8*SCALE\\n canvas.create_line(coords, fill=RED, width=2)\\n coords = WIDTH-(OFFSET+25*SCALE), HEIGHT/2-21.2*SCALE, WIDTH-(OFFSET+29*SCALE), HEIGHT/2-21.2*SCALE, WIDTH-(OFFSET+29*SCALE), HEIGHT/2-18.2*SCALE\\n canvas.create_line(coords, fill=RED, width=2)\\n coords = WIDTH-(OFFSET+37*SCALE), HEIGHT/2-22.8*SCALE, WIDTH-(OFFSET+33*SCALE), HEIGHT/2-22.8*SCALE, WIDTH-(OFFSET+33*SCALE), HEIGHT/2-25.8*SCALE\\n canvas.create_line(coords, fill=RED, width=2)\\n coords = WIDTH-(OFFSET+37*SCALE), HEIGHT/2-21.2*SCALE, WIDTH-(OFFSET+33*SCALE), HEIGHT/2-21.2*SCALE, WIDTH-(OFFSET+33*SCALE), HEIGHT/2-18.2*SCALE\\n canvas.create_line(coords, fill=RED, width=2)\\n # - Bottom Right\\n # - - Ticks\\n coords = WIDTH-(OFFSET+29.5*SCALE), HEIGHT/2+39*SCALE, WIDTH-(OFFSET+29.5*SCALE), HEIGHT/2+5*SCALE\\n canvas.create_line(coords, fill=RED, width=2)\\n coords = WIDTH-(OFFSET+32.5*SCALE), HEIGHT/2+39*SCALE, WIDTH-(OFFSET+32.5*SCALE), HEIGHT/2+5*SCALE\\n canvas.create_line(coords, fill=RED, width=2)\\n # - - Circles\\n coords = WIDTH-(OFFSET+16*SCALE), HEIGHT/2+37*SCALE, WIDTH-(OFFSET+46*SCALE), HEIGHT/2+7*SCALE\\n canvas.create_oval(coords, outline=RED, width=2, fill=WHITE)\\n coords = WIDTH-(OFFSET+30*SCALE), HEIGHT/2+23*SCALE, WIDTH-(OFFSET+32*SCALE), HEIGHT/2+21*SCALE\\n canvas.create_oval(coords, fill=RED, outline=\\\"\\\")\\n # - - Cross\\n coords = WIDTH-(OFFSET+25*SCALE), HEIGHT/2+22.8*SCALE, WIDTH-(OFFSET+29*SCALE), HEIGHT/2+22.8*SCALE, WIDTH-(OFFSET+29*SCALE), HEIGHT/2+25.8*SCALE\\n canvas.create_line(coords, fill=RED, width=2)\\n coords = WIDTH-(OFFSET+25*SCALE), HEIGHT/2+21.2*SCALE, WIDTH-(OFFSET+29*SCALE), HEIGHT/2+21.2*SCALE, WIDTH-(OFFSET+29*SCALE), HEIGHT/2+18.2*SCALE\\n canvas.create_line(coords, fill=RED, width=2)\\n coords = WIDTH-(OFFSET+37*SCALE), HEIGHT/2+22.8*SCALE, WIDTH-(OFFSET+33*SCALE), HEIGHT/2+22.8*SCALE, WIDTH-(OFFSET+33*SCALE), HEIGHT/2+25.8*SCALE\\n canvas.create_line(coords, fill=RED, width=2)\\n coords = WIDTH-(OFFSET+37*SCALE), HEIGHT/2+21.2*SCALE, WIDTH-(OFFSET+33*SCALE), HEIGHT/2+21.2*SCALE, WIDTH-(OFFSET+33*SCALE), HEIGHT/2+18.2*SCALE\\n canvas.create_line(coords, fill=RED, width=2)\\n\\n # NEUTRAL ZONE FACEOFF\\n # - Top Left\\n coords = WIDTH/2-21*SCALE, HEIGHT/2-23*SCALE, WIDTH/2-19*SCALE, HEIGHT/2-21*SCALE\\n canvas.create_oval(coords, outline=\\\"\\\", fill=RED)\\n # - Bottom Left\\n coords = WIDTH/2-21*SCALE, HEIGHT/2+23*SCALE, WIDTH/2-19*SCALE, HEIGHT/2+21*SCALE\\n canvas.create_oval(coords, outline=\\\"\\\", fill=RED)\\n # - Top Right\\n coords = WIDTH/2+21*SCALE, HEIGHT/2-23*SCALE, WIDTH/2+19*SCALE, HEIGHT/2-21*SCALE\\n canvas.create_oval(coords, outline=\\\"\\\", fill=RED)\\n # - Bottom Right\\n coords = WIDTH/2+21*SCALE, HEIGHT/2+23*SCALE, WIDTH/2+19*SCALE, HEIGHT/2+21*SCALE\\n canvas.create_oval(coords, outline=\\\"\\\", fill=RED)\\n\\n\\n canvas.grid(row=1, columnspan=5)\",\n \"def RingPartition(ringsize, z, r, beta):\\n # divide the ring into segments and initialise the coordinate of the segments\\n location = list(range(ringsize))\\n assert ringsize<=16 and ringsize>=5, \\\"Ring size greater than 16 or smaller than 5 is not supported\\\"\\n if ringsize<=7 and ringsize>=5:\\n segment1 = location[0:3]\\n segment2 = location[2:-1]\\n segment2.reverse()\\n segment3 = location[-2:]+[location[0]]\\n segment3.reverse()\\n elif ringsize<=10 and ringsize>=8:\\n segment1 = location[0:4]\\n segment2 = location[3:-2]\\n segment2.reverse()\\n segment3 = location[-3:]+[location[0]]\\n segment3.reverse()\\n elif ringsize<=13 and ringsize>=11:\\n segment1 = location[0:5]\\n segment2 = location[4:-3]\\n segment2.reverse()\\n segment3 = location[-4:]+[location[0]]\\n segment3.reverse()\\n else: #ringsize<=16 and ringsize>=14:\\n segment1 = location[0:6]\\n segment2 = location[5:-4]\\n segment2.reverse()\\n segment3 = location[-5:] + [location[0]]\\n segment3.reverse()\\n segcoord_1_init = SegCoord(segment1, r, beta)\\n segcoord_2_init = SegCoord(segment2, r, beta)\\n segcoord_3_init = SegCoord(segment3, r, beta)\\n Reflection = np.array((-1,1))\\n OPsq = np.inner(segcoord_1_init[-1], segcoord_1_init[-1])\\n PQsq = np.inner(segcoord_2_init[-1], segcoord_2_init[-1])\\n OQsq = np.inner(segcoord_3_init[-1], segcoord_3_init[-1])\\n segcoord_1 = [Reflection*item for item in segcoord_1_init]\\n segcoord_2 = [x + np.sqrt((OQsq,0)) for x in segcoord_2_init]\\n segcoord_3 = [np.array(x) for x in segcoord_3_init]\\n # Link segment together\\n xp = (OPsq+OQsq-PQsq)/(2*np.sqrt(OQsq))\\n yp = np.sqrt(OPsq-np.square(xp))\\n phi1, phi2, phi3 = np.arctan2(segcoord_1[-1][1],segcoord_1[-1][0]), np.arctan2(segcoord_2[-1][1], segcoord_2[-1][0]-np.sqrt(OQsq)), np.arctan2(segcoord_3[-1][1], segcoord_3[-1][0])\\n phiseg1, phiseg2 = np.arctan2(yp,xp), np.arctan2(yp,xp-np.sqrt(OQsq))\\n sigma1, sigma2, sigma3 = np.abs(phi1-phiseg1), np.abs(phiseg2-phi2), np.abs(phi3)\\n Rsigma1, Rsigma2, Rsigma3 = RotationMatrix(-sigma1), RotationMatrix(sigma2), RotationMatrix(-sigma3)\\n coordinate_1 = [np.array((0,0))]\\n seg1_size = len(segcoord_1)\\n for i in range(1,seg1_size-1):\\n coordinate_1.append(np.matmul(Rsigma1,segcoord_1[i]))\\n coordinate_1.append(np.array((xp,yp)))\\n #### Check Here ####\\n coordinate_2 = []\\n seg2_size = len(segcoord_2)\\n for i in range(seg2_size-2,0,-1):\\n tmp = np.sqrt((OQsq,0))\\n coordinate_2.append(tmp + np.matmul(Rsigma2, (segcoord_2[i]-tmp)))\\n coordinate_3 = [np.sqrt((OQsq,0))]\\n seg3_size = len(segcoord_3)\\n for i in range(seg3_size-2,0,-1):\\n coordinate_3.append(np.matmul(Rsigma3, segcoord_3[i]))\\n coordinate = coordinate_1 + coordinate_2 + coordinate_3\\n Rg = np.sum(coordinate,axis=0)\\n phig = np.arctan2(Rg[1],Rg[0]) + np.pi/2\\n Rphig = RotationMatrix(-phig) \\n newcoord = [np.matmul(Rphig, coordinate[i]-Rg).tolist()+[z[i]] for i in range(ringsize)]\\n origin = np.mean(newcoord,axis=0)\\n finalcoord = np.array(newcoord)-origin\\n return finalcoord\",\n \"def __bcc_top_diagonals(self) -> cq.cq.Workplane:\\n # In a cuboid ABCDA1B1C1D1 this is the angle C1AD\\n #angle_C1AD = 90 - degrees(acos(2**-.5))\\n angle_C1AD = 90 - degrees(acos(0.5))\\n angle_CAD = 90 - degrees(acos(sqrt(2/3)))\\n pseudo_unit_cell_size = sqrt(2/3)*self.unit_cell_size\\n corner_points = np.array(\\n [(0, 0),\\n (self.bcc_unit_cell_size, 0),\\n (self.bcc_unit_cell_size, self.unit_cell_size),\\n (0, self.unit_cell_size)]\\n )\\n result = (\\n cq.Workplane(\\\"XY\\\")\\n .pushPoints(corner_points)\\n .eachpointAdaptive(\\n create_bcc_diagonal_strut,\\n callback_extra_args = [\\n {\\\"unit_cell_size\\\": 0.5 * pseudo_unit_cell_size,\\n \\\"radius\\\": self.strut_radius,\\n \\\"angle_x\\\": - angle_CAD,\\n \\\"angle_y\\\": angle_C1AD},\\n {\\\"unit_cell_size\\\": pseudo_unit_cell_size,\\n \\\"radius\\\": self.strut_radius,\\n \\\"angle_x\\\": - angle_CAD,\\n \\\"angle_y\\\": - angle_C1AD},\\n {\\\"unit_cell_size\\\": pseudo_unit_cell_size,\\n \\\"radius\\\": self.strut_radius,\\n \\\"angle_x\\\": angle_CAD,\\n \\\"angle_y\\\": - angle_C1AD},\\n {\\\"unit_cell_size\\\": 0.5 * pseudo_unit_cell_size,\\n \\\"radius\\\": self.strut_radius,\\n \\\"angle_x\\\": angle_CAD,\\n \\\"angle_y\\\": angle_C1AD}\\n ],\\n useLocalCoords = True\\n )\\n )\\n return result\",\n \"def create_solids(self):\\n\\n plasma = self.create_plasma()\\n pf_coils = self.create_pf_coils()\\n tf_coil = self.create_tf_coils()\\n vessel = self.create_vessel_components()\\n\\n shapes_and_components = plasma + pf_coils + vessel[:-1] + tf_coil\\n self.shapes_and_components = shapes_and_components\\n\\n return shapes_and_components\",\n \"def create_cylinders_volume(\\n shape: (int, int, int),\\n cylinders_list: list,\\n foreground=1,\\n dtype=np.uint8):\\n volume = np.zeros(shape, dtype=bool)\\n for point1, point2, radius in cylinders_list:\\n volume = add_cylinder_px(volume, point1, point2, radius)\\n return volume_bool_to_dtype(volume, fg=foreground, dtype=dtype)\",\n \"def cleanOpenBranches(skeleton, skelton_copy, points, radii, length, clean = True, verbose = False):\\n \\n assert np.isfortran(skeleton);\\n assert np.isfortran(skelton_copy);\\n \\n timer = tmr.Timer();\\n timer_all = tmr.Timer();\\n \\n # find branch and end points\\n deg = cpl.convolve_3d_indices(skeleton, t3d.n26, points, out_dtype = 'uint8');\\n branchpoints = points[deg >= 3];\\n e_pts = points[deg == 1];\\n \\n if verbose:\\n timer.printElapsedTime('Detected %d branch and %d endpoints' % (branchpoints.shape[0], e_pts.shape[0]));\\n timer.reset();\\n \\n #prepare temps\\n #skel = skeleton.copy();\\n skel_flat = np.reshape(skelton_copy, -1, order = 'A');\\n strides = np.array(skelton_copy.strides);\\n \\n \\n if verbose:\\n timer.printElapsedTime('Detected %d branch and %d endpoints' % (branchpoints.shape[0], e_pts.shape[0]));\\n timer.reset();\\n \\n label = np.arange(27);\\n label = label.reshape([3,3,3]);\\n label[1,1,1] = 0;\\n \\n critical_points = [e_pts];\\n delete_points = [];\\n \\n for l in range(1, length + 1):\\n #neighbours of end points\\n e_pts_label = cpl.convolve_3d_indices(skelton_copy, label, e_pts);\\n \\n if verbose:\\n timer.printElapsedTime('Done labeling %d / %d' % (l, length));\\n timer.reset();\\n \\n #label zero points are non-critical short isolated branches\\n e_pts_zero = e_pts_label == 0;\\n #print 'zero length:', np.unravel_index(e_pts[e_pts_zero], skel.shape)\\n if e_pts_zero.sum() > 0:\\n keep = np.logical_not(e_pts_zero);\\n for m in range(l):\\n critical_points[m] = critical_points[m][keep];\\n e_pts_label = e_pts_label[keep];\\n e_pts = e_pts[keep];\\n \\n if verbose:\\n timer.printElapsedTime('Ignored %d small branches' % (keep.sum()));\\n timer.reset();\\n \\n e_pts_new = e_pts + np.sum((np.vstack(np.unravel_index(e_pts_label, label.shape)) - 1).T * strides, axis = 1)\\n \\n # did we hit a branch point\\n delete = np.in1d(e_pts_new, branchpoints); #, assume_unique = True);\\n keep = np.logical_not(delete);\\n #print delete.shape, keep.shape, e_pts_new.shape\\n \\n #delete all path that hit a branch point\\n if delete.sum() > 0:\\n for m in range(l):\\n delete_points.append(critical_points[m][delete]);\\n #print 'deleting:', np.unravel_index(critical_points[m][delete], skel.shape)\\n critical_points[m] = critical_points[m][keep];\\n e_pts_new = e_pts_new[keep];\\n \\n if verbose:\\n timer.printElapsedTime('Deleted %d points' % (delete.sum()));\\n timer.reset();\\n \\n if l < length:\\n skel_flat[e_pts] = False; # remove endpoints for new neighbour detection\\n critical_points.append(e_pts_new);\\n e_pts = e_pts_new;\\n \\n if verbose:\\n timer.printElapsedTime('Cleanup iteration %d / %d done.' % (l, length));\\n \\n #gather all points\\n if len(delete_points) > 0:\\n delete_points = np.hstack(delete_points);\\n delete_points = np.unique(delete_points);\\n else:\\n delete_points = np.zeros(0);\\n \\n if verbose:\\n timer_all.printElapsedTime('Cleanup');\\n \\n if clean:\\n skel_flat = np.reshape(skeleton, -1, order = 'F');\\n skel_flat[delete_points] = False;\\n keep_ids = np.logical_not(np.in1d(points, delete_points, assume_unique = True))\\n points = points[keep_ids];\\n radii = radii[keep_ids];\\n return skeleton, points, radii\\n \\n return delete_points;\",\n \"def __bcc_diagonals(self) -> cq.cq.Workplane:\\n # In a cuboid ABCDA1B1C1D1 this is the angle C1AD\\n #angle_C1AD = 90 - degrees(acos(2**-.5))\\n angle_C1AD = 90 - degrees(acos(0.5))\\n angle_CAD = 90 - degrees(acos(sqrt(2/3)))\\n pseudo_unit_cell_size = sqrt(2/3)*self.unit_cell_size\\n corner_points = np.array(\\n [(0, 0),\\n (self.bcc_unit_cell_size, 0),\\n (self.bcc_unit_cell_size, self.unit_cell_size),\\n (0, self.unit_cell_size)]\\n )\\n result = (\\n cq.Workplane(\\\"XY\\\")\\n .pushPoints(corner_points)\\n .eachpointAdaptive(\\n create_bcc_diagonal_strut,\\n callback_extra_args = [\\n {\\\"unit_cell_size\\\": pseudo_unit_cell_size,\\n \\\"radius\\\": self.strut_radius,\\n \\\"angle_x\\\": - angle_CAD,\\n \\\"angle_y\\\": angle_C1AD},\\n {\\\"unit_cell_size\\\": pseudo_unit_cell_size,\\n \\\"radius\\\": self.strut_radius,\\n \\\"angle_x\\\": - angle_CAD,\\n \\\"angle_y\\\": - angle_C1AD},\\n {\\\"unit_cell_size\\\": pseudo_unit_cell_size,\\n \\\"radius\\\": self.strut_radius,\\n \\\"angle_x\\\": angle_CAD,\\n \\\"angle_y\\\": - angle_C1AD},\\n {\\\"unit_cell_size\\\": pseudo_unit_cell_size,\\n \\\"radius\\\": self.strut_radius,\\n \\\"angle_x\\\": angle_CAD,\\n \\\"angle_y\\\": angle_C1AD}\\n ],\\n useLocalCoords = True\\n )\\n )\\n return result\",\n \"def test_clip_points_by_polygons_with_holes_real(self):\\n\\n # Read real polygon with holes\\n filename = '%s/%s' % (TESTDATA, 'donut.shp')\\n L = read_layer(filename)\\n\\n # --------------------------------------------\\n # Pick one polygon that has 2 inner rings\\n P = L.get_geometry(as_geometry_objects=True)[1]\\n\\n outer_ring = P.outer_ring\\n inner_ring0 = P.inner_rings[0]\\n inner_ring1 = P.inner_rings[1]\\n\\n # Make some test points\\n points_in_bbox = generate_random_points_in_bbox(outer_ring, 1000)\\n points_in_inner_ring0 = populate_polygon(inner_ring0, 2, seed=13)\\n points_in_inner_ring1 = populate_polygon(inner_ring1, 2, seed=17)\\n points = numpy.concatenate((points_in_bbox,\\n points_in_inner_ring0,\\n points_in_inner_ring1))\\n\\n # Clip\\n indices = inside_polygon(points, P.outer_ring, holes=P.inner_rings)\\n\\n # Sanity\\n for point in points[indices, :]:\\n # Must be inside outer ring\\n assert is_inside_polygon(point, outer_ring)\\n\\n # But not in any of the inner rings\\n assert not is_inside_polygon(point, inner_ring0)\\n assert not is_inside_polygon(point, inner_ring1)\\n\\n # ---------------------------------------------------------\\n # Pick a polygon that has 1 inner ring (nice visualisation)\\n P = L.get_geometry(as_geometry_objects=True)[9]\\n\\n outer_ring = P.outer_ring\\n inner_ring = P.inner_rings[0]\\n\\n # Make some test points\\n points = generate_random_points_in_bbox(outer_ring, 500)\\n\\n # Clip\\n indices = inside_polygon(points, P.outer_ring, holes=P.inner_rings)\\n\\n # Sanity\\n for point in points[indices, :]:\\n # Must be inside outer ring\\n assert is_inside_polygon(point, outer_ring)\\n\\n # But not in the inner ring\\n assert not is_inside_polygon(point, inner_ring)\\n\\n # Store for visual check (nice one!)\\n # Uncomment os.remove if you want see the layers\\n pol = Vector(geometry=[P])\\n tmp_filename = unique_filename(suffix='.shp')\\n pol.write_to_file(tmp_filename)\\n #print 'Polygon with holes written to %s' % tmp_filename\\n os.remove(tmp_filename)\\n\\n pts = Vector(geometry=points[indices, :])\\n tmp_filename = unique_filename(suffix='.shp')\\n pts.write_to_file(tmp_filename)\\n #print 'Clipped points written to %s' % tmp_filename\\n os.remove(tmp_filename)\",\n \"def corridor(x,z, emap, width=10, length=10, height=10, details=None, walls=\\\"ns\\\", name=\\\"wall\\\", mergeshape=None):\\r\\n global wallnum\\r\\n n = z + width / 2\\r\\n s = z - width / 2\\r\\n e = x + length / 2\\r\\n w = x - length / 2\\r\\n\\r\\n solid_objects = []\\r\\n\\r\\n if \\\"n\\\" in walls:\\r\\n # TODO: abstract out the mostly-duplicate code in these cases...\\r\\n nwall = SolidObject(name+str(wallnum),\\r\\n Size(length, height, 1),\\r\\n Position(x, emap.calcHeight(x, z) + height / 2, n-0.5), 0)\\r\\n solid_objects.append(nwall)\\r\\n nwallmodel = createMyCuboid(nwall.w() * 2, nwall.h() * 2, nwall.d() * 2,\\r\\n name=name+str(wallnum),\\r\\n x=nwall.x(),y=nwall.y(),z=nwall.z(),\\r\\n rx=0.0, ry=0.0, rz=0.0, cx=0.0, cy=0.0, cz=0.0)\\r\\n if mergeshape:\\r\\n mergeshape.add(nwallmodel)\\r\\n else:\\r\\n nwall.setmodel(nwallmodel, details)\\r\\n\\r\\n\\r\\n wallnum += 1\\r\\n\\r\\n if \\\"s\\\" in walls:\\r\\n swall = SolidObject(name+str(wallnum), Size(length, height, 1), Position(x, emap.calcHeight(x, z)+height / 2, s+0.5), 0)\\r\\n solid_objects.append(swall)\\r\\n swallmodel = createMyCuboid(swall.w()*2, swall.h()*2, swall.d()*2,\\r\\n name=name+str(wallnum),\\r\\n x=swall.x(), y=swall.y(), z=swall.z(),\\r\\n rx=0.0, ry=0.0, rz=0.0, cx=0.0,cy=0.0, cz=0.0)\\r\\n if mergeshape:\\r\\n mergeshape.add(swallmodel)\\r\\n else:\\r\\n swall.setmodel(swallmodel, details)\\r\\n\\r\\n wallnum += 1\\r\\n\\r\\n if \\\"e\\\" in walls:\\r\\n ewall = SolidObject(name+str(wallnum), Size(1, height, width), Position(e-0.5, emap.calcHeight(x, z)+height / 2, z), 0)\\r\\n solid_objects.append(ewall)\\r\\n ewallmodel = createMyCuboid(ewall.w()*2, ewall.h()*2, ewall.d()*2,\\r\\n name=name+str(wallnum),\\r\\n x=ewall.x(), y=ewall.y(), z=ewall.z(),\\r\\n rx=0.0, ry=0.0, rz=0.0, cx=0.0, cy=0.0, cz=0.0)\\r\\n if mergeshape:\\r\\n mergeshape.add(ewallmodel)\\r\\n else:\\r\\n ewall.setmodel(ewallmodel, details)\\r\\n\\r\\n wallnum += 1\\r\\n\\r\\n if \\\"w\\\" in walls:\\r\\n wwall = SolidObject(name+str(wallnum), Size(1, height, width), Position(w+0.5, emap.calcHeight(x, z)+height / 2, z), 0)\\r\\n solid_objects.append(wwall)\\r\\n wwallmodel = createMyCuboid(wwall.w()*2, wwall.h()*2, wwall.d()*2,\\r\\n name=name+str(wallnum),\\r\\n x=wwall.x(), y=wwall.y(), z=wwall.z(),\\r\\n rx=0.0, ry=0.0, rz=0.0, cx=0.0, cy=0.0, cz=0.0)\\r\\n if mergeshape:\\r\\n mergeshape.add(wwallmodel)\\r\\n else:\\r\\n wwall.setmodel(wwallmodel, details)\\r\\n wallnum += 1\\r\\n\\r\\n if \\\"o\\\" not in walls:\\r\\n ceiling = SolidObject(name+str(wallnum), Size(length, 1, width), Position(x, emap.calcHeight(x, z)+height+0.5, z), 0)\\r\\n solid_objects.append(ceiling)\\r\\n ceilingmodel = createMyCuboid(ceiling.w()*2, ceiling.h()*2, ceiling.d()*2,\\r\\n name=name+str(wallnum),\\r\\n x=ceiling.x(), y=ceiling.y(), z=ceiling.z(),\\r\\n rx=0.0, ry=0.0, rz=0.0, cx=0.0, cy=0.0, cz=0.0)\\r\\n if mergeshape:\\r\\n mergeshape.add(ceilingmodel)\\r\\n else:\\r\\n ceiling.setmodel(ceilingmodel, details)\\r\\n\\r\\n wallnum += 1\\r\\n\\r\\n return solid_objects\",\n \"def Cool_per_Grain(grain_size, grain_type, ZZ, fdist, ntot, xe, temp):\\n import numpy as np\\n import math\\n import compute_charge_dist as fz\\n \\n tau = grain_size * fz.AAtocm * fz.kb * temp / fz.echarge**2\\n \\n # Loop over species!\\n Cool_spec = 0\\n for partner in [\\\"electron\\\", \\\"hydrogen\\\", \\\"carbon\\\"]:\\n \\n Cool_Zall = 0\\n # Loop over charge\\n for zi in range(len(ZZ)):\\n \\n if partner == \\\"electron\\\":\\n nu = -1*ZZ[zi]\\n stick_coef = fz.get_stickCoef(ZZ[zi], grain_size, grain_type)\\n charge_frac = xe\\n mass = fz.me\\n \\n elif partner == \\\"hydrogen\\\":\\n nu = ZZ[zi]\\n stick_coef = 1.0\\n charge_frac = xe\\n mass = fz.mH\\n \\n elif partner == \\\"carbon\\\":\\n nu = ZZ[zi]\\n stick_coef = 1.0\\n # Maximum fraction of ionized Carbon is 1e-4*ntot.\\n charge_frac = min(1.0e-4, xe)\\n mass = fz.mC\\n \\n Cooltilde = 1.0\\n \\n if nu < 0:\\n Cooltilde = fz.Jtilde_neg(tau, nu)\\n elif nu == 0:\\n Cooltilde = fz.Jtilde_0(tau, nu)\\n else:\\n Cooltilde = fz.Jtilde_pos(tau, nu)\\n \\n #print(zi)\\n Cool_Zhere = fdist[zi]*Cooltilde*fz.kb*temp\\n Cool_Zall += Cool_Zhere\\n \\n #print(\\\"Collisional Partner = \\\", partner)\\n Cool_spec += ntot*charge_frac*stick_coef*np.sqrt(8.0*fz.kb*temp/(np.pi*mass))*Cool_Zall\\n \\n Cool_tot = math.pi * (grain_size*AAtocm)**2 * Cool_spec\\n \\n return Cool_tot\",\n \"def unitQuad_Edge(lens, N=3):\\n template = [ np.array([0,0]), np.array([lens[0], 0]), None, None ] #Template from which to generate other Quad Vertex Lists\\n leftDegenerate = template.copy() #Left Limit of quad if you were to rotate edge 3 CCW about the origin until you no longer can\\n rightDegenerate = template.copy() #Right Limit of quad if you were to rotate edge 2 CW about point 1 until you no longer can,\\n # or alternatively, how far edge 3 can rotate CW until the quad is degenerate\\n try:\\n leftDegenerate[3] = np.array( circleIntersection(leftDegenerate[0], lens[3], leftDegenerate[1], lens[1]+lens[2]) )\\n leftDegenerate[2] = ( lens[1] / (lens[2]+lens[1]) ) * (leftDegenerate[3]-leftDegenerate[1]) + leftDegenerate[1]\\n except: \\n leftDegenerate[3] = np.array([-lens[3],0])\\n leftDegenerate[2] = np.array( circleIntersection(leftDegenerate[3], lens[2], leftDegenerate[1], lens[1]) )\\n\\n try:\\n rightDegenerate[2] = np.array( circleIntersection(rightDegenerate[0], lens[2]+lens[3], rightDegenerate[1], lens[1]) )\\n rightDegenerate[3] = ( lens[3] / (lens[3]+lens[2]) ) * rightDegenerate[2]\\n except:\\n rightDegenerate[2] = np.array([lens[0]+lens[1], 0])\\n rightDegenerate[3] = np.array( circleIntersection(rightDegenerate[0], lens[3], rightDegenerate[2], lens[2]))\\n \\n rightOfOrigin = np.array([1,0]) #Theta = 0 on the Unit Circle\\n thetaMin = angle_between(leftDegenerate[3], rightOfOrigin) #Angle of \\n thetaMax = angle_between(rightDegenerate[3], rightOfOrigin)\\n pitch = (thetaMax - thetaMin) / (N-1)\\n\\n result = []\\n result.append(leftDegenerate) \\n for i in range(1, N-1):\\n result.append(template.copy())\\n result[i][3] = lens[3]*unitCircPt(i*pitch+thetaMin)\\n result[i][2] = np.array(circleIntersection( result[i][3], lens[2], result[i][1], lens[1]))\\n result.append(rightDegenerate) \\n\\n return listify(result)\",\n \"def _makeComponentPatch(component, position, cold):\\n x = position[0]\\n y = position[1]\\n\\n if isinstance(component, Helix):\\n blockPatch = matplotlib.patches.Wedge(\\n (\\n x\\n + component.getDimension(\\\"helixDiameter\\\", cold=cold)\\n / 2\\n * math.cos(math.pi / 6),\\n y\\n + component.getDimension(\\\"helixDiameter\\\", cold=cold)\\n / 2\\n * math.sin(math.pi / 6),\\n ),\\n component.getDimension(\\\"od\\\", cold=cold) / 2,\\n 0,\\n 360,\\n width=(component.getDimension(\\\"od\\\", cold=cold) / 2)\\n - (component.getDimension(\\\"id\\\", cold=cold) / 2),\\n )\\n elif isinstance(component, Circle):\\n\\n blockPatch = matplotlib.patches.Wedge(\\n (x, y),\\n component.getDimension(\\\"od\\\", cold=cold) / 2,\\n 0,\\n 360,\\n width=(component.getDimension(\\\"od\\\", cold=cold) / 2)\\n - (component.getDimension(\\\"id\\\", cold=cold) / 2),\\n )\\n elif isinstance(component, Hexagon):\\n if component.getDimension(\\\"ip\\\", cold=cold) != 0:\\n innerPoints = numpy.array(\\n hexagon.corners(30) * component.getDimension(\\\"ip\\\", cold=cold)\\n )\\n outerPoints = numpy.array(\\n hexagon.corners(30) * component.getDimension(\\\"op\\\", cold=cold)\\n )\\n blockPatch = []\\n for n in range(6):\\n corners = [\\n innerPoints[n],\\n innerPoints[(n + 1) % 6],\\n outerPoints[(n + 1) % 6],\\n outerPoints[n],\\n ]\\n patch = matplotlib.patches.Polygon(corners, fill=True)\\n blockPatch.append(patch)\\n else:\\n # Just make it a hexagon...\\n blockPatch = matplotlib.patches.RegularPolygon(\\n (x, y), 6, component.getDimension(\\\"op\\\", cold=cold) / math.sqrt(3)\\n )\\n\\n elif isinstance(component, Rectangle):\\n if component.getDimension(\\\"widthInner\\\", cold=cold) != 0:\\n innerPoints = numpy.array(\\n [\\n [\\n x + component.getDimension(\\\"widthInner\\\", cold=cold) / 2,\\n y + component.getDimension(\\\"lengthInner\\\", cold=cold) / 2,\\n ],\\n [\\n x + component.getDimension(\\\"widthInner\\\", cold=cold) / 2,\\n y - component.getDimension(\\\"lengthInner\\\", cold=cold) / 2,\\n ],\\n [\\n x - component.getDimension(\\\"widthInner\\\", cold=cold) / 2,\\n y - component.getDimension(\\\"lengthInner\\\", cold=cold) / 2,\\n ],\\n [\\n x - component.getDimension(\\\"widthInner\\\", cold=cold) / 2,\\n y + component.getDimension(\\\"lengthInner\\\", cold=cold) / 2,\\n ],\\n ]\\n )\\n\\n outerPoints = numpy.array(\\n [\\n [\\n x + component.getDimension(\\\"widthOuter\\\", cold=cold) / 2,\\n y + component.getDimension(\\\"lengthOuter\\\", cold=cold) / 2,\\n ],\\n [\\n x + component.getDimension(\\\"widthOuter\\\", cold=cold) / 2,\\n y - component.getDimension(\\\"lengthOuter\\\", cold=cold) / 2,\\n ],\\n [\\n x - component.getDimension(\\\"widthOuter\\\", cold=cold) / 2,\\n y - component.getDimension(\\\"lengthOuter\\\", cold=cold) / 2,\\n ],\\n [\\n x - component.getDimension(\\\"widthOuter\\\", cold=cold) / 2,\\n y + component.getDimension(\\\"lengthOuter\\\", cold=cold) / 2,\\n ],\\n ]\\n )\\n blockPatch = []\\n for n in range(4):\\n corners = [\\n innerPoints[n],\\n innerPoints[(n + 1) % 4],\\n outerPoints[(n + 1) % 4],\\n outerPoints[n],\\n ]\\n patch = matplotlib.patches.Polygon(corners, fill=True)\\n blockPatch.append(patch)\\n else:\\n # Just make it a rectangle...\\n blockPatch = matplotlib.patches.Rectangle(\\n (\\n x - component.getDimension(\\\"widthOuter\\\", cold=cold) / 2,\\n y - component.getDimension(\\\"lengthOuter\\\", cold=cold) / 2,\\n ),\\n component.getDimension(\\\"widthOuter\\\", cold=cold),\\n component.getDimension(\\\"lengthOuter\\\", cold=cold),\\n )\\n if isinstance(blockPatch, list):\\n return blockPatch\\n return [blockPatch]\",\n \"def test_clip_points_by_polygons_with_holes0(self):\\n\\n # Define an outer ring\\n outer_ring = numpy.array([[106.79, -6.233],\\n [106.80, -6.24],\\n [106.78, -6.23],\\n [106.77, -6.21],\\n [106.79, -6.233]])\\n\\n # Define inner rings\\n inner_rings = [numpy.array([[106.77827, -6.2252],\\n [106.77775, -6.22378],\\n [106.78, -6.22311],\\n [106.78017, -6.22530],\\n [106.77827, -6.2252]])[::-1],\\n numpy.array([[106.78652, -6.23215],\\n [106.78642, -6.23075],\\n [106.78746, -6.23143],\\n [106.78831, -6.23307],\\n [106.78652, -6.23215]])[::-1]]\\n\\n v = Vector(geometry=[Polygon(outer_ring=outer_ring,\\n inner_rings=inner_rings)])\\n assert v.is_polygon_data\\n\\n # Write it to file\\n tmp_filename = unique_filename(suffix='.shp')\\n v.write_to_file(tmp_filename)\\n\\n # Read polygon it back\\n L = read_layer(tmp_filename)\\n P = L.get_geometry(as_geometry_objects=True)[0]\\n\\n outer_ring = P.outer_ring\\n inner_ring0 = P.inner_rings[0]\\n inner_ring1 = P.inner_rings[1]\\n\\n # Make some test points\\n points = generate_random_points_in_bbox(outer_ring, 1000, seed=13)\\n\\n # Clip to outer ring, excluding holes\\n indices = inside_polygon(points, P.outer_ring, holes=P.inner_rings)\\n\\n # Sanity\\n for point in points[indices, :]:\\n # Must be inside outer ring\\n assert is_inside_polygon(point, outer_ring)\\n\\n # But not in any of the inner rings\\n assert not is_inside_polygon(point, inner_ring0)\\n assert not is_inside_polygon(point, inner_ring1)\\n\\n if False:\\n # Store for visual check\\n pol = Vector(geometry=[P])\\n tmp_filename = unique_filename(suffix='.shp')\\n pol.write_to_file(tmp_filename)\\n print 'Polygon with holes written to %s' % tmp_filename\\n\\n pts = Vector(geometry=points[indices, :])\\n tmp_filename = unique_filename(suffix='.shp')\\n pts.write_to_file(tmp_filename)\\n print 'Clipped points written to %s' % tmp_filename\",\n \"def RemovePolygonHoles_management(in_fc, threshold=0.0):\\n desc = arcpy.Describe(in_fc)\\n if desc.dataType != \\\"FeatureClass\\\" and desc.dataType != \\\"ShapeFile\\\":\\n print(\\\"Invalid data type. The input is supposed to be a Polygon FeatureClass or Shapefile.\\\")\\n return\\n else:\\n if desc.shapeType != \\\"Polygon\\\":\\n print(\\\"The input is supposed to be a Polygon FeatureClass or Shapefile.\\\")\\n return\\n if threshold < 0.0:\\n threshold = 0.0\\n with arcpy.da.UpdateCursor(in_fc, [\\\"SHAPE@\\\"]) as updateCursor:\\n for updateRow in updateCursor:\\n shape = updateRow[0]\\n new_shape = arcpy.Array()\\n for part in shape:\\n new_part = arcpy.Array()\\n if threshold > 0:\\n # find None point in shape part\\n # in arcpy module, a None point is used to seperate exterior and interior vertices\\n null_point_index = []\\n for i in range(len(part)):\\n if part[i] is None:\\n null_point_index.append(i)\\n # if interior vertices exist, create polygons and compare polygon shape area to given threshold\\n # if larger, keep vertices, else, dismiss them\\n if len(null_point_index) > 0:\\n for k in range(0, null_point_index[0]):\\n new_part.add(part[k])\\n for i in range(len(null_point_index)):\\n pointArray = arcpy.Array()\\n # determine if the None point is the last one\\n if i+1 < len(null_point_index):\\n for j in range(null_point_index[i] + 1, null_point_index[i+1]):\\n pointArray.add(part[j])\\n else:\\n for j in range(null_point_index[i] + 1, len(part)):\\n pointArray.add(part[j])\\n # create a polygon to check shape area against the given threshold\\n inner_poly = arcpy.Polygon(pointArray)\\n # if larger than threshold, then add to the new part Array\\n if inner_poly.area > threshold:\\n if i+1 < len(null_point_index):\\n for k in range(null_point_index[i], null_point_index[i+1]):\\n new_part.add(part[k])\\n else:\\n for k in range(null_point_index[i], len(part)):\\n new_part.add(part[k])\\n new_shape.add(new_part)\\n # if interior does not exist, add the whole part\\n else:\\n new_shape.add(part)\\n else:\\n # get the first None point index\\n first_null_point_index = 0\\n for i in range(len(part)):\\n if part[i] is None:\\n first_null_point_index = i\\n break\\n if first_null_point_index == 0:\\n new_shape.add(part)\\n else:\\n for j in range(first_null_point_index):\\n new_part.add(part[j])\\n new_shape.add(new_part)\\n if len(new_shape) > 0:\\n new_poly = arcpy.Polygon(new_shape)\\n updateRow[0] = new_poly\\n updateCursor.updateRow(updateRow)\",\n \"def is_ring(self): # -> bool:\\n ...\",\n \"def reset_shapes():\\n if bpy.context.object.modeling_cloth:\\n ob = bpy.context.object\\n else: \\n ob = extra_data['last_object']\\n\\n if ob.data.shape_keys == None:\\n ob.shape_key_add('Basis') \\n if 'modeling cloth source key' not in ob.data.shape_keys.key_blocks:\\n ob.shape_key_add('modeling cloth source key') \\n if 'modeling cloth key' not in ob.data.shape_keys.key_blocks:\\n ob.shape_key_add('modeling cloth key') \\n ob.data.shape_keys.key_blocks['modeling cloth key'].value=1\\n \\n keys = ob.data.shape_keys.key_blocks\\n count = len(ob.data.vertices)\\n co = np.zeros(count * 3, dtype=np.float32)\\n keys['modeling cloth source key'].data.foreach_get('co', co)\\n keys['modeling cloth key'].data.foreach_set('co', co)\\n\\n data[ob.name].vel *= 0\\n \\n ob.data.shape_keys.key_blocks['modeling cloth key'].mute = True\\n ob.data.shape_keys.key_blocks['modeling cloth key'].mute = False\",\n \"def make_tight_box(self, tightness: float = 0.33) -> None:\\r\\n\\r\\n # Default to the plant's original box\\r\\n x1 = self.box[0]\\r\\n y1 = self.box[1]\\r\\n x2 = self.box[2]\\r\\n y2 = self.box[3]\\r\\n\\r\\n ## Find y coordinates\\r\\n # Initialize variables and sort pixels by x coordinate\\r\\n width = self.box[2] - self.box[0]\\r\\n cents = sorted(self.cluster, key = lambda u: u[1])\\r\\n clust = []\\r\\n curr = cents[0][1]\\r\\n last = 0\\r\\n\\r\\n # Split the pixels by x coordinate\\r\\n for p in range(len(cents)):\\r\\n if cents[p][1] != curr:\\r\\n clust.append(cents[last: p])\\r\\n curr = cents[p][1]\\r\\n last = p\\r\\n \\r\\n # Get the topmost y value which is <tightness> green\\r\\n for hor in clust:\\r\\n if len(hor) / width > tightness:\\r\\n y1 = hor[0][1]\\r\\n break\\r\\n\\r\\n # Get the bottommost y value which is <tightness> green\\r\\n for hor in clust[::-1]:\\r\\n if len(hor) / width > tightness:\\r\\n y2 = hor[0][1]\\r\\n break\\r\\n\\r\\n ## Find x coordinates\\r\\n # Initialize variables and sort pixels by y coordinate\\r\\n height = self.box[3] - self.box[1]\\r\\n cents = sorted(self.cluster, key = lambda u: u[0])\\r\\n clust = []\\r\\n curr = cents[0][0]\\r\\n last = 0\\r\\n\\r\\n # Split the pixels by y coordinate\\r\\n for p in range(len(cents)):\\r\\n if cents[p][0] != curr:\\r\\n clust.append(cents[last: p])\\r\\n curr = cents[p][0]\\r\\n last = p\\r\\n\\r\\n # Get the leftmost x value which is <tightness> green\\r\\n for ver in clust:\\r\\n if len(ver) / height > tightness:\\r\\n x1 = ver[0][0]\\r\\n break\\r\\n\\r\\n # Get the rightmost x value which is <tightness> green\\r\\n for ver in clust[::-1]:\\r\\n if len(ver) / height > tightness:\\r\\n x2 = ver[0][0]\\r\\n break\\r\\n\\r\\n # Default to original x values if no better estimate was found\\r\\n if x1 == x2:\\r\\n x1 = self.box[0]\\r\\n x2 = self.box[2]\\r\\n\\r\\n # Default to original y values if no better estimate was found\\r\\n if y1 == y2:\\r\\n y1 = self.box[1]\\r\\n y2 = self.box[3]\\r\\n\\r\\n self.tight_box = (x1, y1, x2, y2)\",\n \"def cliques_on_ring(cliques,labels,G, cut=0):\\n print(\\\"cliques_on_ring CUT:\\\", cut)\\n #if partitions\\n if cut > 1:\\n partitions = get_partitions(cliques,cut)\\n for partition in partitions:\\n if len(partition) > 1:\\n n1 = random.choice(partition[0])\\n for idx,clique in enumerate(partition):\\n if idx > 0:# and idx not in cuts:\\n candidates = [n for n in clique if labels[n.id] != labels[n1.id]]\\n candidates = candidates if len(candidates) > 0 else clique\\n n2 = random.choice(candidates)\\n G.add_edge(n1,n2)\\n n1 = random.choice(clique)\\n\\n else:\\n n1 = random.choice(cliques[0]) \\n for idx,clique in enumerate(cliques):\\n if idx > 0:# and idx not in cuts:\\n candidates = [n for n in clique if labels[n.id] != labels[n1.id]]\\n candidates = candidates if len(candidates) > 0 else clique\\n n2 = random.choice(candidates)\\n G.add_edge(n1,n2)\\n n1 = random.choice(clique)\\n \\n #Attach head and tail cliques\\n candidates = [n for n in cliques[0] if labels[n.id] != labels[n1.id]]\\n candidates = candidates if len(candidates) > 0 else cliques[0]\\n n2 = random.choice(candidates)\\n G.add_edge(n1,n2)\",\n \"def make_flower(shape, x, y, c1, c2, l, s):\\n shape.penup()\\n shape.speed(20)\\n shape.setpos(x, y)\\n shape.color(c2, c1)\\n shape.begin_fill()\\n shape.pendown()\\n for side in range(6):\\n shape.left(60)\\n shape.forward(s) # s stands for short side\\n shape.right(60)\\n shape.forward(l) # l stands for long side\\n shape.right(60)\\n shape.forward(s)\\n shape.right(60)\\n shape.forward(s)\\n shape.right(60)\\n shape.forward(l)\\n shape.right(60)\\n shape.forward(s)\\n shape.right(60)\\n shape.end_fill()\\n shape.pendown()\\n\\n shape.color(\\\"green\\\")\\n shape.right(90)\\n shape.penup()\\n shape.forward(10)\\n shape.pendown()\\n shape.forward(110)\\n shape.left(90)\\n\\n\\n\\n # ...\",\n \"def generatePolygons():\",\n \"def make_circle_fill():\\n num_points = 40\\n batch = pyglet.graphics.Batch()\\n rad = math.pi * 2 / num_points # getting 360 / n in radians\\n index = list(itertools.chain.from_iterable( (0, x-1, x) for x in range(2, num_points+1) ))\\n index += [0, 1, num_points] # end of fan\\n vertices = [0, 0] # adding center of fan\\n for i in range(1, num_points + 1):\\n angle = rad * i\\n vertices += [math.cos(angle), math.sin(angle)]\\n vertices += [1, 0] # adding end of fan\\n circle = pyglet.graphics.vertex_list_indexed(num_points+2, index, ('v2f', vertices))\\n return circle\",\n \"def grating_coupler_circular(\\n taper_angle: float = 30.0,\\n taper_length: float = 10.0,\\n length: float = 30.0,\\n period: float = 1.0,\\n fill_factor: float = 0.7,\\n n_periods: int = 30,\\n bias_gap: float = 0,\\n port: Coordinate = (0.0, 0.0),\\n layer_slab: Optional[LayerSpec] = None,\\n layer_cladding: LayerSpec = \\\"WGCLAD\\\",\\n gaps: Optional[Floats] = None,\\n widths: Optional[Floats] = None,\\n direction: str = \\\"EAST\\\",\\n polarization: str = \\\"te\\\",\\n wavelength: float = 1.55,\\n fiber_marker_width: float = 11.0,\\n fiber_marker_layer: Optional[LayerSpec] = \\\"TE\\\",\\n cladding_offset: float = 2.0,\\n cross_section: CrossSectionSpec = \\\"strip\\\",\\n **kwargs,\\n) -> Component:\\n x = gf.get_cross_section(cross_section, **kwargs)\\n layer = x.layer\\n wg_width = x.width\\n\\n widths = widths or n_periods * [period * fill_factor]\\n gaps = gaps or n_periods * [period * (1 - fill_factor)]\\n\\n gaps = np.array(gaps) + bias_gap\\n widths = np.array(widths) - bias_gap\\n teeth_list = list(zip(gaps, widths))\\n\\n layer = gf.get_layer(layer)\\n layer_slab = gf.get_layer(layer_slab)\\n layer_cladding = gf.get_layer(layer_cladding)\\n\\n c = pc.GratingCoupler(\\n gf.call_if_func(\\n strip,\\n cladding_offset=cladding_offset,\\n wg_width=wg_width,\\n layer=layer,\\n layer_cladding=layer_cladding,\\n ),\\n theta=np.deg2rad(taper_angle),\\n length=length,\\n taper_length=taper_length,\\n period=period,\\n dutycycle=fill_factor,\\n ridge=bool(layer_slab),\\n ridge_layers=layer_slab,\\n teeth_list=teeth_list,\\n port=port,\\n direction=direction,\\n )\\n\\n c = gf.read.from_picwriter(c)\\n c.info[\\\"polarization\\\"] = polarization\\n c.info[\\\"wavelength\\\"] = wavelength\\n c.ports[\\\"o1\\\"].cross_section = x\\n\\n fiber_xoffset = np.round(c.center[0] + taper_length / 2, 3)\\n\\n if fiber_marker_layer:\\n circle = gf.components.circle(\\n radius=fiber_marker_width / 2, layer=fiber_marker_layer\\n )\\n circle_ref = c.add_ref(circle)\\n circle_ref.movex(fiber_xoffset)\\n\\n c.add_port(\\n name=f\\\"vertical_{polarization.lower()}\\\",\\n center=[fiber_xoffset, 0],\\n width=fiber_marker_width,\\n orientation=0,\\n layer=fiber_marker_layer,\\n )\\n if x.add_bbox:\\n c = x.add_bbox(c)\\n if x.add_pins:\\n c = x.add_pins(c)\\n return c\",\n \"def test_comb(pad_size = (200, 200), wire_width = 1, wire_gap = 3,\\n comb_layer = 0, overlap_zigzag_layer = 1,\\n comb_pad_layer = 2, comb_gnd_layer = 3,\\n overlap_pad_layer = 4):\\n CI = Device(\\\"test_comb\\\")\\n\\n # if comb_pad_layer is None: comb_pad_layer = comb_layer\\n # if comb_gnd_layer is None: comb_gnd_layer = comb_layer\\n # if overlap_pad_layer is None: overlap_pad_layer = overlap_zigzag_layer\\n wire_spacing = wire_width + wire_gap*2\\n\\n # pad overlays\\n overlay_padb = CI.add_ref(rectangle(size = (pad_size[0]*9 / 10,\\n pad_size[1]*9 / 10),\\n layer = overlap_pad_layer))\\n overlay_padl = CI.add_ref(rectangle(size = (pad_size[0]*9 / 10,\\n pad_size[1]*9 / 10),\\n layer = comb_pad_layer))\\n overlay_padt = CI.add_ref(rectangle(size = (pad_size[0]*9 / 10,\\n pad_size[1]*9 / 10),\\n layer = comb_pad_layer))\\n overlay_padr = CI.add_ref(rectangle(size = (pad_size[0]*9 / 10,\\n pad_size[1]*9 / 10),\\n layer = comb_gnd_layer))\\n overlay_padl.xmin = 0\\n overlay_padl.ymin = 0\\n overlay_padb.ymax = 0\\n overlay_padb.xmin = overlay_padl.xmax + pad_size[1]/5\\n overlay_padr.ymin = overlay_padl.ymin\\n overlay_padr.xmin = overlay_padb.xmax + pad_size[1]/5\\n overlay_padt.xmin = overlay_padl.xmax + pad_size[1]/5\\n overlay_padt.ymin = overlay_padl.ymax\\n\\n # pads\\n padl = CI.add_ref(rectangle(size = pad_size, layer = comb_layer))\\n padt = CI.add_ref(rectangle(size = pad_size, layer = comb_layer))\\n padr = CI.add_ref(rectangle(size = pad_size, layer = comb_layer))\\n padb = CI.add_ref(rectangle(size = pad_size, layer = overlap_zigzag_layer))\\n padl_nub = CI.add_ref(rectangle(size = (pad_size[0]/4,\\n pad_size[1]/2),\\n layer = comb_layer))\\n padr_nub = CI.add_ref(rectangle(size = (pad_size[0]/4,\\n pad_size[1]/2),\\n layer = comb_layer))\\n padl.xmin = overlay_padl.xmin\\n padl.center = [padl.center[0], overlay_padl.center[1]]\\n padt.ymax = overlay_padt.ymax\\n padt.center = [overlay_padt.center[0], padt.center[1]]\\n padr.xmax = overlay_padr.xmax\\n padr.center = [padr.center[0], overlay_padr.center[1]]\\n padb.ymin = overlay_padb.ymin\\n padb.center = [overlay_padb.center[0], padb.center[1]]\\n padl_nub.xmin = padl.xmax\\n padl_nub.center = [padl_nub.center[0], padl.center[1]]\\n padr_nub.xmax = padr.xmin\\n padr_nub.center = [padr_nub.center[0], padr.center[1]]\\n\\n # connected zig\\n head = CI.add_ref(compass(size = (pad_size[0]/12, wire_width),\\n layer = comb_layer))\\n head.xmin = padl_nub.xmax\\n head.ymax = padl_nub.ymax\\n connector = CI.add_ref(compass(size = (wire_width, wire_width),\\n layer = comb_layer))\\n connector.connect(port = 'W', destination = head.ports['E'])\\n old_port = connector.ports['S']\\n top = True\\n obj = connector\\n while(obj.xmax + pad_size[0]/12 < padr_nub.xmin):\\n # long zig zag rectangle\\n obj = CI.add_ref(compass(size = (pad_size[1]/2 - 2*wire_width,\\n wire_width),\\n layer = comb_layer))\\n obj.connect(port = 'W', destination = old_port)\\n old_port = obj.ports['E']\\n if(top):\\n # zig zag edge rectangle\\n obj = CI.add_ref(compass(size = (wire_width, wire_width),\\n layer = comb_layer))\\n obj.connect(port = 'N', destination = old_port)\\n top = False\\n else:\\n # zig zag edge rectangle\\n obj = CI.add_ref(compass(size = (wire_width, wire_width),\\n layer = comb_layer))\\n obj.connect(port = 'S', destination = old_port)\\n top = True\\n # comb rectange\\n comb = CI.add_ref(rectangle(\\n size = ((padt.ymin - head.ymax) + pad_size[1]/2 \\\\\\n - (wire_spacing + wire_width)/2, wire_width),\\n layer = comb_layer))\\n comb.rotate(90)\\n comb.ymax = padt.ymin\\n comb.xmax = obj.xmax - (wire_spacing + wire_width)/2\\n old_port = obj.ports['E']\\n obj = CI.add_ref(compass(size = (wire_spacing, wire_width),\\n layer = comb_layer))\\n obj.connect(port = 'W', destination = old_port)\\n old_port = obj.ports['E']\\n obj = CI.add_ref(compass(size = (wire_width, wire_width),\\n layer = comb_layer))\\n obj.connect(port = 'W', destination = old_port)\\n if(top): old_port = obj.ports['S']\\n else: old_port = obj.ports['N']\\n old_port = obj.ports['E']\\n if(padr_nub.xmin-obj.xmax > 0):\\n tail = CI.add_ref(compass(size = (padr_nub.xmin-obj.xmax, wire_width),\\n layer = comb_layer))\\n else:\\n tail = CI.add_ref(compass(size = (wire_width, wire_width),\\n layer = comb_layer))\\n tail.connect(port = 'W', destination = old_port)\\n\\n # disconnected zig\\n dhead = CI.add_ref(compass(size = (padr_nub.ymin - padb.ymax - wire_width,\\n wire_width),\\n layer = overlap_zigzag_layer))\\n dhead.rotate(90)\\n dhead.ymin = padb.ymax\\n dhead.xmax = tail.xmin - (wire_spacing+wire_width)/2\\n connector = CI.add_ref(compass(size = (wire_width, wire_width),\\n layer = overlap_zigzag_layer))\\n connector.connect(port = 'S', destination = dhead.ports['E'])\\n old_port = connector.ports['N']\\n right = True\\n obj = connector\\n while(obj.ymax + wire_spacing + wire_width < head.ymax):\\n obj = CI.add_ref(compass(size = (wire_spacing, wire_width),\\n layer = overlap_zigzag_layer))\\n obj.connect(port = 'W', destination = old_port)\\n old_port = obj.ports['E']\\n if(right):\\n obj = CI.add_ref(compass(size = (wire_width, wire_width),\\n layer = overlap_zigzag_layer))\\n obj.connect(port = 'W', destination = old_port)\\n right = False\\n else:\\n obj = CI.add_ref(compass(size = (wire_width, wire_width),\\n layer = overlap_zigzag_layer))\\n obj.connect(port = 'E', destination = old_port)\\n right = True\\n old_port = obj.ports['N']\\n obj = CI.add_ref(compass(\\n size = (dhead.xmin - (head.xmax+head.xmin+wire_width)/2,\\n wire_width),\\n layer = overlap_zigzag_layer))\\n obj.connect(port = 'E', destination = old_port)\\n old_port = obj.ports['W']\\n obj = CI.add_ref(compass(size = (wire_width, wire_width),\\n layer = overlap_zigzag_layer))\\n obj.connect(port = 'S', destination = old_port)\\n if(right):\\n old_port = obj.ports['W']\\n else:\\n old_port = obj.ports['E']\\n\\n return CI\",\n \"def C(width = 1, size = (10, 20), layer = 0):\\n D = Device(name = 'C')\\n w = width/2\\n s1, s2 = size\\n points = [(-w, -w), (s1, -w), (s1, w), (w, w), (w, s2-w),\\n (s1, s2-w), (s1, s2+w), (-w, s2+w), (-w, -w)]\\n D.add_polygon(points, layer = layer)\\n D.add_port(name = 1, midpoint = (s1, s2), width = width, orientation = 0)\\n D.add_port(name = 2, midpoint = (s1, 0), width = width, orientation = 0)\\n return D\",\n \"def add_cable(self, env, size_range, info={}, cable_idx=0,\\n direction='z', max_force=100):\\n num_parts = self.num_parts\\n radius = self.radius\\n length = self.length\\n color = self.colors[cable_idx] + [1]\\n color_end = U.COLORS['yellow'] + [1]\\n\\n # Add beaded cable.\\n distance = length / num_parts\\n position, _ = self.random_pose(env, size_range)\\n position = np.float32(position)\\n part_shape = p.createCollisionShape(p.GEOM_BOX, halfExtents=[radius]*3)\\n part_visual = p.createVisualShape(p.GEOM_SPHERE, radius=radius*1.5)\\n\\n # Iterate through parts and create constraints as needed.\\n for i in range(num_parts):\\n if direction == 'x':\\n position[0] += distance\\n parent_frame = (distance, 0, 0)\\n elif direction == 'y':\\n position[1] += distance\\n parent_frame = (0, distance, 0)\\n else:\\n position[2] += distance\\n parent_frame = (0, 0, distance)\\n\\n part_id = p.createMultiBody(0.1, part_shape, part_visual,\\n basePosition=position)\\n if i > 0:\\n constraint_id = p.createConstraint(\\n parentBodyUniqueId=env.objects[-1],\\n parentLinkIndex=-1,\\n childBodyUniqueId=part_id,\\n childLinkIndex=-1,\\n jointType=p.JOINT_POINT2POINT,\\n jointAxis=(0, 0, 0),\\n parentFramePosition=parent_frame,\\n childFramePosition=(0, 0, 0))\\n p.changeConstraint(constraint_id, maxForce=max_force)\\n\\n if (i > 0) and (i < num_parts - 1):\\n p.changeVisualShape(part_id, -1, rgbaColor=color)\\n elif i == num_parts - 1:\\n p.changeVisualShape(part_id, -1, rgbaColor=color_end)\\n\\n # The usual for tracking IDs. Four things to add.\\n self.cable_bead_IDs.append(part_id)\\n self._IDs[part_id] = f'cable_part_{str(part_id).zfill(2)}'\\n env.objects.append(part_id)\\n self.object_points[part_id] = np.float32((0, 0, 0)).reshape(3, 1)\\n\\n # Get target placing positions for each cable bead, if applicable.\\n if self._name == 'cable-shape' or self._name == 'cable-shape-notarget' or \\\\\\n self._name == 'cable-line-notarget':\\n # ----------------------------------------------------------- #\\n # Here, zone_pose = square_pose, unlike Ravens cable, where the\\n # zone_pose is shifted so that its center matches the straight\\n # line segment center. For `true_position`, we use `zone_pose`\\n # but apply the correct offset to deal with the sides. Note\\n # that `length` is the size of a fully smoothed cable, BUT we\\n # made a rectangle with each side <= length.\\n # ----------------------------------------------------------- #\\n lx = info['lengthx']\\n ly = info['lengthy']\\n r = radius\\n\\n if info['nb_sides'] == 1:\\n # Here it's just a straight line on the 'lx' side.\\n x_coord = lx / 2 - (distance * i)\\n y_coord = 0\\n true_position = (x_coord - r, y_coord, 0)\\n\\n elif info['nb_sides'] == 2:\\n # Start from lx side, go 'left' to the pivot point, then on\\n # the ly side, go 'upwards' but offset by `i`. For radius\\n # offset, I just got this by tuning. XD\\n if i < info['cutoff']:\\n x_coord = lx / 2 - (distance * i)\\n y_coord = -ly / 2\\n true_position = (x_coord - r, y_coord, 0)\\n else:\\n x_coord = -lx / 2\\n y_coord = -ly / 2 + (distance * (i - info['cutoff']))\\n true_position = (x_coord, y_coord + r, 0)\\n\\n elif info['nb_sides'] == 3:\\n # Start from positive lx, positive ly, go down to first\\n # pivot. Then go left to the second pivot, then up again.\\n # For v1, division by two is because we assume BOTH of the\\n # 'ly edges' were divided by two.\\n v1 = (self.num_parts - info['cutoff']) / 2\\n v2 = self.num_parts - v1\\n if i < v1:\\n x_coord = lx / 2\\n y_coord = ly / 2 - (distance * i)\\n true_position = (x_coord, y_coord - r, 0)\\n elif i < v2:\\n x_coord = lx / 2 - (distance * (i - v1))\\n y_coord = -ly / 2\\n true_position = (x_coord - r, y_coord, 0)\\n else:\\n x_coord = -lx / 2\\n y_coord = -ly / 2 + (distance * (i - v2))\\n true_position = (x_coord, y_coord + r, 0)\\n\\n elif info['nb_sides'] == 4:\\n # I think this is similar to the 2-side case: we start in\\n # the same direction and go counter-clockwise.\\n v1 = info['cutoff'] / 2\\n v2 = num_parts / 2\\n v3 = (num_parts + info['cutoff']) / 2\\n if i < v1:\\n x_coord = lx / 2 - (distance * i)\\n y_coord = -ly / 2\\n true_position = (x_coord, y_coord, 0)\\n elif i < v2:\\n x_coord = -lx / 2\\n y_coord = -ly / 2 + (distance * (i - v1))\\n true_position = (x_coord, y_coord, 0)\\n elif i < v3:\\n x_coord = -lx / 2 + (distance * (i - v2))\\n y_coord = ly / 2\\n true_position = (x_coord, y_coord, 0)\\n else:\\n x_coord = lx / 2\\n y_coord = ly / 2 - (distance * (i - v3))\\n true_position = (x_coord, y_coord, 0)\\n\\n # Map true_position onto the workspace from zone_pose.\\n true_position = self.apply(self.zone_pose, true_position)\\n\\n # See `cable.py`: just get the places and steps set.\\n self.goal['places'][part_id] = (true_position, (0, 0, 0, 1.))\\n symmetry = 0\\n self.goal['steps'][0][part_id] = (symmetry, [part_id])\\n\\n # Debugging target zones.\\n if self.target_debug_markers:\\n sq_pose = ((true_position[0], true_position[1], 0.002), (0,0,0,1))\\n sq_template = 'assets/square/square-template-allsides-blue.urdf'\\n replace = {'DIM': (0.003,), 'HALF': (0.003 / 2,)}\\n urdf = self.fill_template(sq_template, replace)\\n env.add_object(urdf, sq_pose, fixed=True)\\n os.remove(urdf)\\n else:\\n print(f'Warning, env {self._name} will not have goals.')\",\n \"def drawShapes(self):\\n self.draw_polygon(self.poly3.get_points() , color = \\\"#000\\\")\\n self.draw_polygon(self.poly2.get_points() , color = \\\"#000\\\")\\n self.draw_polygon(self.poly1.get_points() , color = \\\"#000\\\")\\n self.draw_rect(0, 0, self.width, self.height, color= \\\"#000\\\")\\n \\\"\\\"\\\"These statements are used to determine if a point is inside any of the\\n 3 polygons and if so changes the point's color\\\"\\\"\\\"\\n if (self.poly2.point_inside_polygon(self.p1) or self.poly1.point_inside_polygon(self.p1)\\n or self.poly3.point_inside_polygon(self.p1)):\\n color = \\\"#0F0\\\"\\n else:\\n color = \\\"#F00\\\"\\n self.fill_oval(self.p1.x, self.p1.y, 7, 7, color)\\n\\n if (self.poly2.point_inside_polygon(self.p2) or self.poly1.point_inside_polygon(self.p2)\\n or self.poly3.point_inside_polygon(self.p2)):\\n color = \\\"#0F0\\\"\\n else:\\n color = \\\"#F00\\\"\\n self.fill_oval(self.p2.x, self.p2.y, 7, 7, color)\\n if (self.poly2.point_inside_polygon(self.p3) or self.poly1.point_inside_polygon(self.p3)\\n or self.poly3.point_inside_polygon(self.p3)):\\n color = \\\"#0F0\\\"\\n else:\\n color = \\\"#F00\\\"\\n self.fill_oval(self.p3.x, self.p3.y, 7, 7, color)\",\n \"def ring(radius = 10, width = 0.5, angle_resolution = 2.5, layer = 0):\\n D = Device(name = 'ring')\\n inner_radius = radius - width/2\\n outer_radius = radius + width/2\\n n = int(np.round(360/angle_resolution))\\n t = np.linspace(0, 360, n+1) * pi/180\\n inner_points_x = (inner_radius*cos(t)).tolist()\\n inner_points_y = (inner_radius*sin(t)).tolist()\\n outer_points_x = (outer_radius*cos(t)).tolist()\\n outer_points_y = (outer_radius*sin(t)).tolist()\\n xpts = inner_points_x + outer_points_x[::-1]\\n ypts = inner_points_y + outer_points_y[::-1]\\n D.add_polygon(points = (xpts, ypts), layer = layer)\\n return D\",\n \"def poly_enclose(points, color, inc=1.2, rad=0.3, lw=2):\\n points = np.log(points)\\n hull = ConvexHull(points)\\n\\n cent = np.mean(points, 0)\\n pts = []\\n for pt in points[hull.simplices]:\\n pts.append(pt[0].tolist())\\n pts.append(pt[1].tolist())\\n \\n pts.sort(key=lambda p: np.arctan2(p[1] - cent[1],\\n p[0] - cent[0]))\\n pts = pts[0::2] # Deleting duplicates\\n pts.insert(len(pts), pts[0])\\n \\n \\n verts = inc*(np.array(pts)- cent) + cent\\n verts2 = np.zeros((3*verts.shape[0]-2,2))\\n verts2[0::3] = verts\\n verts2[1::3,:] = (1-rad)*verts[0:-1,:] + rad*verts[1:,:]\\n verts2[2::3,:] = rad*verts[0:-1,:] + (1-rad)*verts[1:,:]\\n verts2[0:-1] = verts2[1:]\\n verts2[-1] = verts2[0]\\n\\n\\n \\n codes = [Path.MOVETO, Path.LINETO, Path.CURVE3,]\\n for j in range(len(pts)-2):\\n codes.extend([Path.CURVE3, Path.LINETO, Path.CURVE3,])\\n codes.append(Path.CURVE3)\\n \\n \\n path = Path(verts2, codes)\\n patch = patches.PathPatch(path, facecolor=color, lw=0, alpha=0.2)\\n edge = patches.PathPatch(path, edgecolor=color, facecolor='none', lw=lw)\\n patch._path._vertices = np.exp(patch._path._vertices)\\n return patch, edge\",\n \"def boundaries_and_initialize():\\n greenLower = (29, 86, 6) # define the lower and upper boundaries of the \\\"green\\\"\\n greenUpper = (64, 255, 255)\\n pts = [((200,300),(255,255,255), 0)]\\n blanks = []\\n linecolor = (0,0,0)\\n counter = 1\\n radius = 11\\n return greenLower, greenUpper, pts, linecolor, counter, blanks, radius\",\n \"def create_ring(self):\\n\\t\\tself.north_coords = numpy.add(self.center, self.north)\\n\\t\\tself.northeast_coords = numpy.add(self.center, self.northeast)\\n\\t\\tself.east_coords = numpy.add(self.center, self.east)\\n\\t\\tself.southeast_coords = numpy.add(self.center, self.southeast)\\n\\t\\tself.south_coords = numpy.add(self.center, self.south)\\n\\t\\tself.southwest_coords = numpy.add(self.center, self.southwest)\\n\\t\\tself.west_coords = numpy.add(self.center, self.west)\\n\\t\\tself.northwest_coords = numpy.add(self.center, self.northwest)\",\n \"def store_horiz_points_clean(self, ring_points, display_opt):\\n plane_colors = [(0, 255, 0), (0, 0, 255), (0.9100, 0.4100, 0.1700)] #4,2,3\\n\\n num_ring_pts = len(ring_points)\\n\\n # declare arrays for storage ..\\n landmarks = []\\n landmarks_2chs = []\\n landmarks_4chs = []\\n\\n y = []\\n y_2ch = []\\n y_4ch = []\\n\\n # find top and low pts for the 2ch and 4ch views at the ideal angles\\n _, _, highest_2ch_orig, _ = self.find_top_low_pts3([self.orig_cut_poly_array[1][0],self.orig_cut_poly_array[1][1]])\\n _, _, highest_4ch_orig, _ = self.find_top_low_pts3([self.orig_cut_poly_array[0][0],self.orig_cut_poly_array[0][1]])\\n\\n for (i, offset_2ch) in enumerate(ring_points):\\n offset_pt_2ch = np.asarray(offset_2ch)\\n\\n two_ch_view_plane_normal = find_plane_eq(offset_pt_2ch, highest_2ch_orig[0], highest_2ch_orig[1])\\n\\n cutPoly_2ch, _ = self.get_edges_strips(two_ch_view_plane_normal, offset_pt_2ch,\\n \\\"2ch ring_pt index = \\\" + str(i), self.plane_colors[1])\\n\\n lowest_point_2ch, lowest_point_2ch_idx, highest_points_2ch, sorted_pts_endo_epi = self.find_top_low_pts3([cutPoly_2ch[0], cutPoly_2ch[1]])\\n\\n horiz_2ch_a, horiz_2ch_b = self.get_landmarks(sorted_pts_endo_epi[0], lowest_point_2ch_idx, 0)\\n\\n landmarks_3D = np.concatenate((horiz_2ch_a, np.flip(horiz_2ch_b, 0)))\\n\\n # remember to add the lowest point\\n current_np = len(landmarks_3D)\\n idx = int(np.floor(current_np/2.0)) # find middle index\\n landmarks_3D = np.insert(landmarks_3D, idx, lowest_point_2ch, axis=0)\\n landmarks_2D = project_onto_xy_plane(landmarks_3D)\\n landmarks_2chs.append(landmarks_2D)\\n\\n # now assess volume for labels\\n horiz_2ch_dists, horiz_4ch_dists = self.compute_horizontal_distances(horiz_2ch_a, horiz_2ch_b,\\n self.ideal_horiz_4ch_a,\\n self.ideal_horiz_4ch_b)\\n\\n # set L = length of LV cavity (choose longest from 2ch or 4ch)\\n L = get_length_of_LV_cavity(horiz_2ch_a, horiz_2ch_b,\\n self.ideal_horiz_4ch_a, self.ideal_horiz_4ch_b,\\n lowest_point_2ch, self.ideal_lowest_point_4ch)\\n\\n # compute percentage error\\n vol = self.Simpson_bp(horiz_2ch_dists, horiz_4ch_dists, L)\\n abs_error_vol = np.abs(vol - self.ideal_vol) # make all errors positive\\n perc_err = 100.0*(abs_error_vol/self.ideal_vol)\\n\\n if perc_err > 5.0:\\n y_2ch.append(int(1))\\n else:\\n y_2ch.append(int(0))\\n\\n landmarks.append(landmarks_2chs)\\n y.append(y_2ch)\\n\\n for (i, offset_4ch) in enumerate(ring_points):\\n offset_pt_4ch = np.asarray(offset_4ch)\\n\\n four_ch_view_plane_normal = find_plane_eq(offset_pt_4ch, highest_4ch_orig[0], highest_4ch_orig[1])\\n\\n cutPoly_4ch, _ = self.get_edges_strips(four_ch_view_plane_normal, offset_pt_4ch,\\n \\\"4ch = \\\" + str(i), plane_colors[0])\\n\\n lowest_point_4ch, lowest_point_4ch_idx, highest_points_4ch, sorted_pts_endo_epi = self.find_top_low_pts3([cutPoly_4ch[0], cutPoly_4ch[1]])\\n\\n horiz_4ch_a, horiz_4ch_b = self.get_landmarks(sorted_pts_endo_epi[0], lowest_point_4ch_idx, 0)\\n\\n landmarks_3D = np.concatenate((horiz_4ch_a, np.flip(horiz_4ch_b, 0)))\\n\\n # dont forget to add the type I landmarks (lowest points)\\n current_np = len(landmarks_3D)\\n idx = int(np.floor(current_np/2.0))\\n landmarks_3D = np.insert(landmarks_3D, idx, lowest_point_4ch, axis=0)\\n landmarks_2D = project_onto_xy_plane(landmarks_3D)\\n landmarks_4chs.append(landmarks_2D)\\n\\n # now asssess volume for labels\\n horiz_2ch_dists, horiz_4ch_dists = self.compute_horizontal_distances(self.ideal_horiz_2ch_a,\\n self.ideal_horiz_2ch_b,\\n horiz_4ch_a,\\n horiz_4ch_b)\\n\\n # set L = length of LV cavity (choose longest from 2ch or 4ch)\\n L = get_length_of_LV_cavity(self.ideal_horiz_2ch_a, self.ideal_horiz_2ch_b,\\n horiz_4ch_a, horiz_4ch_b,\\n self.ideal_lowest_point_2ch, lowest_point_4ch)\\n\\n # compute percentage error\\n vol = self.Simpson_bp(horiz_2ch_dists, horiz_4ch_dists, L)\\n abs_error_vol = np.abs(vol - self.ideal_vol) # make all errors positive\\n perc_err = 100.0*(abs_error_vol/self.ideal_vol)\\n\\n if perc_err > 5.0:\\n y_4ch.append(int(1))\\n else:\\n y_4ch.append(int(0))\\n\\n landmarks.append(landmarks_4chs)\\n y.append(y_4ch)\\n\\n return landmarks, y\",\n \"def flattener(image, pts, w, h):\\n temp_rect = np.zeros((4,2), dtype = \\\"float32\\\")\\n \\n s = np.sum(pts, axis = 2)\\n\\n tl = pts[np.argmin(s)]\\n br = pts[np.argmax(s)]\\n\\n diff = np.diff(pts, axis = -1)\\n tr = pts[np.argmin(diff)]\\n bl = pts[np.argmax(diff)]\\n\\n if w <= 0.8 * h: # If card is vertically oriented\\n temp_rect[0] = tl\\n temp_rect[1] = tr\\n temp_rect[2] = br\\n temp_rect[3] = bl\\n\\n if w >= 1.2 * h: # If card is horizontally oriented\\n temp_rect[0] = bl\\n temp_rect[1] = tl\\n temp_rect[2] = tr\\n temp_rect[3] = br\\n\\n if w > 0.8 * h and w < 1.2 * h: #If card is diamond oriented\\n # If furthest left point is higher than furthest right point,\\n # card is tilted to the left.\\n if pts[1][0][1] <= pts[3][0][1]:\\n # If card is titled to the left, approxPolyDP returns points\\n # in this order: top right, top left, bottom left, bottom right\\n temp_rect[0] = pts[1][0] # Top left\\n temp_rect[1] = pts[0][0] # Top right\\n temp_rect[2] = pts[3][0] # Bottom right\\n temp_rect[3] = pts[2][0] # Bottom left\\n\\n # If furthest left point is lower than furthest right point,\\n # card is tilted to the right\\n if pts[1][0][1] > pts[3][0][1]:\\n # If card is titled to the right, approxPolyDP returns points\\n # in this order: top left, bottom left, bottom right, top right\\n temp_rect[0] = pts[0][0] # Top left\\n temp_rect[1] = pts[3][0] # Top right\\n temp_rect[2] = pts[2][0] # Bottom right\\n temp_rect[3] = pts[1][0] # Bottom left\\n \\n # Create destination array, calculate perspective transform matrix,\\n # and warp card image\\n dst = np.array([[0, 0], [MAXWIDTH - 1, 0], [MAXWIDTH - 1, MAXHEIGHT - 1], [0, MAXHEIGHT - 1]], np.float32)\\n M = cv2.getPerspectiveTransform(temp_rect, dst)\\n warp = cv2.warpPerspective(image, M, (MAXWIDTH, MAXHEIGHT))\\n\\n return warp\",\n \"def createCone( basePoint=(0,-1,0), tipPoint=(0,1,0), radius = 1.0, colour=(0.6,0.6,0.6), samples = 20 ):\\r\\n \\r\\n basePoint = PyUtils.toPoint3d(basePoint)\\r\\n tipPoint = PyUtils.toPoint3d(tipPoint)\\r\\n baseToTipVector = Vector3d(basePoint,tipPoint)\\r\\n if baseToTipVector.isZeroVector() :\\r\\n raise ValueError( 'Invalid points for cylinder: base and tip are equal!' )\\r\\n baseToTipUnitVector = baseToTipVector.unit()\\r\\n xUnitVector = baseToTipUnitVector.crossProductWith( Vector3d(0,0,1) )\\r\\n if xUnitVector.length() < 0.5 :\\r\\n xUnitVector = baseToTipUnitVector.crossProductWith( Vector3d(0,-1,0) )\\r\\n xUnitVector.toUnit()\\r\\n yUnitVector = baseToTipUnitVector.crossProductWith( Vector3d(-1,0,0) )\\r\\n if yUnitVector.length() < 0.5 :\\r\\n yUnitVector = baseToTipUnitVector.crossProductWith( Vector3d(0,1,0) )\\r\\n yUnitVector.toUnit()\\r\\n\\r\\n vertices = []\\r\\n for i in range(samples):\\r\\n theta = i * 2 * math.pi / float(samples)\\r\\n vertices.append( basePoint + xUnitVector * math.cos(theta) * radius + yUnitVector * math.sin(theta) * radius )\\r\\n for i in range(samples):\\r\\n theta = i * 2 * math.pi / float(samples)\\r\\n vertices.append( basePoint + xUnitVector * math.cos(theta) * radius + yUnitVector * math.sin(theta) * radius )\\r\\n vertices.append( tipPoint )\\r\\n \\r\\n faces = [ range(0,samples) ]\\r\\n for i in range(0,samples) :\\r\\n base = samples\\r\\n size = samples\\r\\n faces.append( (base+i, base+(i+1)%size, 2*samples ) )\\r\\n \\r\\n return create( vertices, faces, colour )\",\n \"def isValidPcbShape(g):\\n return g.GetShape() != pcbnew.S_SEGMENT or g.GetLength() > 0\",\n \"def make_hollow(\\n self,\\n p1: Vec,\\n p2: Vec,\\n thick: float = 16,\\n mat: str = 'tools/toolsnodraw',\\n inner_mat: str = '',\\n ) -> List['Solid']:\\n if not inner_mat:\\n inner_mat = mat\\n b_min, b_max = Vec.bbox(p1, p2)\\n\\n top = self.make_prism(\\n Vec(b_min.x, b_min.y, b_max.z),\\n Vec(b_max.x, b_max.y, b_max.z + thick),\\n mat,\\n )\\n\\n bottom = self.make_prism(\\n Vec(b_min.x, b_min.y, b_min.z),\\n Vec(b_max.x, b_max.y, b_min.z - thick),\\n mat,\\n )\\n\\n west = self.make_prism(\\n Vec(b_min.x - thick, b_min.y, b_min.z),\\n Vec(b_min.x, b_max.y, b_max.z),\\n mat,\\n )\\n\\n east = self.make_prism(\\n Vec(b_max.x, b_min.y, b_min.z),\\n Vec(b_max.x + thick, b_max.y, b_max.z),\\n mat\\n )\\n\\n north = self.make_prism(\\n Vec(b_min.x, b_max.y, b_min.z),\\n Vec(b_max.x, b_max.y + thick, b_max.z),\\n mat,\\n )\\n\\n south = self.make_prism(\\n Vec(b_min.x, b_min.y - thick, b_min.z),\\n Vec(b_max.x, b_min.y, b_max.z),\\n mat,\\n )\\n\\n top.bottom.mat = bottom.top.mat = inner_mat\\n east.west.mat = west.east.mat = inner_mat\\n north.south.mat = south.north.mat = inner_mat\\n\\n return [\\n north.solid, south.solid,\\n east.solid, west.solid,\\n top.solid, bottom.solid,\\n ]\",\n \"def checkRing(self, verbose = 0):\\n angleSum = self.tfs.ANGLE.sum()\\n if self.verbose: print (\\\"check\\\")\\n print (\\\"---------------------------------- \\\\n Checking, if ring is closed: \\\\n\\\", \\\"angleSum = \\\", angleSum)\\n twoPi = 2*pi\\n \\n if angleSum != twoPi:\\n fudge = 2*pi - angleSum\\n print (\\\" ** Ring not closed - offset of: \\\", fudge)\",\n \"def obj_bounding_shape(obj_class,\\n # length,\\n width):\\n # Given the visualized object a shape\\n if obj_class == 'Truck':\\n length = 12\\n elif obj_class == 'Motorcycle':\\n length = 2\\n elif obj_class == 'Car':\\n length = 5\\n else:\\n length = 3\\n\\n if width == 0:\\n if obj_class == 'Truck':\\n width = 4\\n elif obj_class == 'Motorcycle':\\n width = 1\\n elif obj_class == 'Car':\\n width = 2\\n else:\\n width = 3\\n\\n return np.transpose(np.array([length, width]))\",\n \"def empty_diff_walls():\\n\\t# 4 side walls are absorptive\\n\\troom_materials = [pra.Material(energy_absorption=0.1, scattering=None)] * 4\\n\\t# floor and ceiling are reflective\\n\\troom_materials.extend([pra.Material(energy_absorption=0.98, scattering=None)] * 2)\\n\\t\\n\\troom_faces = make_polygon(\\n\\t\\tcentre=[0,0,2.5],\\n\\t\\tradius=10,\\n\\t\\theight=5,\\n\\t\\tN=4,\\n\\t\\trpy=[0,0,np.pi/4]\\n\\t)\\n\\n\\t# create room\\n\\twalls = []\\n\\twalls.extend(create_walls(room_faces, room_materials))\\n\\n\\troom = pra.Room(walls, fs=fs, max_order=3, ray_tracing=False, air_absorption=False)\\n\\n\\troom.add_source([-5, 2, 2.])\\n\\troom.add_microphone([1, 0, 2.])\\n\\n\\t# compute rir\\n\\troom.image_source_model()\\n\\troom.compute_rir()\\n\\n\\treturn room\",\n \"def plot_rings(self,x_shift,y_shift):\\n\\n if not self.rings: return # Bounce if option not selected\\n\\n patches = []\\n colours = []\\n for ring in self.ring_crds:\\n ring[:,0] += x_shift*self.pbc[0]\\n ring[:,1] += y_shift*self.pbc[1]\\n patches.append(Polygon(np.array(ring), True))\\n colours.append(self.ring_colours[ring[:,0].size])\\n ring[:,0]-=x_shift*self.pbc[0]\\n ring[:,1]-=y_shift*self.pbc[1]\\n self.ax.add_collection(PatchCollection(patches,facecolor=colours,linewidths=self.lw,edgecolor=\\\"k\\\",zorder=0))\\n\\n patches = []\\n for ring in self.perimeter_ring_crds:\\n ring[:,0] += x_shift*self.pbc[0]\\n ring[:,1] += y_shift*self.pbc[1]\\n patches.append(Polygon(np.array(ring), True))\\n ring[:,0]-=x_shift*self.pbc[0]\\n ring[:,1]-=y_shift*self.pbc[1]\\n self.ax.add_collection(PatchCollection(patches,facecolor=(0,0,0,0),linewidths=self.lw*3,edgecolor=\\\"orange\\\",zorder=0))\",\n \"def bc_is_solid(bc):\\n solid = BCProp(int(bc_solid[bc.xlb]),\\n int(bc_solid[bc.xrb]),\\n int(bc_solid[bc.ylb]),\\n int(bc_solid[bc.yrb]))\\n return solid\",\n \"def rigid_rings(self):\\n raise NotImplementedError\",\n \"def make_shape_ccw(self):\\n\\n if not(self.closed):\\n return\\n\\n # Optimization for closed shapes\\n # Start value for the first sum\\n\\n if self.isDirectionOfGeosCCW(self.geos):\\n self.reverse()\\n logger.debug(self.tr(\\\"Had to reverse the shape to be CW\\\"))\\n self.cw = True\",\n \"def HollowCylinder(self,center=(0,0,0),inner_radius=1.0,outer_radius=2.,\\n element_type='hex',isotropic=True,nrad=5,ncirc=10, nlong=20,length=10):\\n\\n if element_type != \\\"hex\\\":\\n raise NotImplementedError('Generating {} mesh of cylinder is not supported yet'.format(element_type))\\n\\n if not isinstance(center,tuple):\\n raise ValueError(\\\"The center for the base of the cylinder should be given in a tuple with three elements (x,y,z)\\\")\\n\\n self.__reset__()\\n\\n nlong = int(nlong)\\n if nlong==0:\\n nlong = 1\\n\\n mesh = Mesh()\\n mesh.HollowCircle(center=(center[0],center[1]), inner_radius=inner_radius,\\n outer_radius=outer_radius, element_type=\\\"quad\\\",\\n isotropic=isotropic, nrad=nrad, ncirc=ncirc)\\n\\n self.Extrude(base_mesh=mesh, length=length, nlong=nlong)\\n self.points += center[2]\",\n \"def special_corner() -> None:\\r\\n if example[1, 1] == 0: # NW\\r\\n if conflict_space[0, 0] == conflict_space[0, 2] and conflict_space[2, 0] == conflict_space[0, 0] \\\\\\r\\n and conflict_space[0, 0] != 0:\\r\\n example[0, 0] = 0\\r\\n safeboard[0, 0] = 0\\r\\n progress_handler(False, True)\\r\\n \\r\\n if example[1, shape-2] == 0: # NE\\r\\n if conflict_space[0, shape-1] == conflict_space[0, shape-3] and \\\\\\r\\n conflict_space[2, shape-1] == conflict_space[0, shape-1] and conflict_space[0, shape-1] != 0:\\r\\n example[0, shape-1] = 0\\r\\n safeboard[0, shape-1] = 0\\r\\n progress_handler(False, True)\\r\\n \\r\\n if example[shape-2, shape-2] == 0: # SE\\r\\n if conflict_space[shape-1, shape-1] == conflict_space[shape-1, shape-3] and \\\\\\r\\n conflict_space[shape-1, shape-1] == conflict_space[shape-3, shape-1] \\\\\\r\\n and conflict_space[shape-1, shape-1] != 0:\\r\\n example[shape-1, shape-1] = 0\\r\\n safeboard[shape-1, shape-1] = 0\\r\\n progress_handler(False, True)\\r\\n \\r\\n if example[shape-2, 1] == 0: # SW\\r\\n if conflict_space[shape-1, 0] == conflict_space[shape-1, 2] and \\\\\\r\\n conflict_space[shape-1, 0] == conflict_space[shape-3, 0] and conflict_space[shape-1, 0] != 0:\\r\\n example[shape-1, 0] = 0\\r\\n safeboard[shape-1, 0] = 0\\r\\n progress_handler(False, True)\\r\\n if progress_handler(True, False):\\r\\n conflict_check()\",\n \"def make_path(self, loop):\\n path=Path(closed=True)\\n for c in range(0,len(loop)):\\n connection=loop[c]\\n nextConnection = loop[(c+1)%len(loop)]\\n lastConnection = loop[(c-1)%len(loop)]\\n if self.dontFill(connection, nextConnection, lastConnection):\\n return False\\n cp = self.corner_pos(connection, nextConnection, lastConnection)\\n corner_offset = cp[0]\\n corner_dir = cp[1]\\n # catch case when it is the end of a single rod\\n if type(corner_offset) is list:\\n endpoints = corner_offset\\n corner_offset = endpoints[0]\\n else:\\n endpoints = False\\n if connection.other.radius is not None and ( corner_offset.length() < connection.other.radius or corner_dir >0):\\n # catch case when it is the end of a single rod\\n if endpoints:\\n para=(connection.this.pos-connection.other.pos).normalize()\\n d = math.sqrt(connection.other.radius**2 - corner_offset.length()**2)\\n path.add_point(PSharp(connection.other.pos + corner_offset + d*para))\\n path.add_point(PArc(connection.other.pos, radius=connection.other.radius, direction='cw'))\\n path.add_point(PSharp(connection.other.pos - corner_offset+d*para))\\n else:\\n path.add_point(PAroundcurve(connection.other.pos + corner_offset, centre=connection.other.pos, radius=connection.other.radius, direction='cw'))\\n\\n elif self.get_intRadius(connection, connection.other) is not None:\\n # path.add_point(PIncurve(connection.other.pos + corner_offset, radius=self.get_intRadius(connection, connection.other)))\\n # path.add_point(PIncurve(connection.other.pos - corner_offset, radius=self.get_intRadius(connection, connection.other)))\\n # path.add_point(PIncurve(connection.other.pos - corner_offset, radius=self.get_intRadius(connection, connection.other)))\\n path.add_point(PIncurve(connection.other.pos + corner_offset, radius=self.get_intRadius(connection, connection.other)))\\n else:\\n cornerpos = self.corner_pos(connection, nextConnection, lastConnection)\\n if type(cornerpos) is list:\\n path.add_point(PSharp(connection.other.pos + cornerpos[0]))\\n path.add_point(PSharp(connection.other.pos + cornerpos[1]))\\n else:\\n path.add_point(PSharp(connection.other.pos + cornerpos))#self.corner_pos(connection, nextConnection, lastConnection)))\\n # path.add_point(PSharp(connection.other.pos - cornerpos))#self.corner_pos(connection, nextConnection, lastConnection)))\\n if connection.other.holeRad is not None:\\n if type(connection.other.holeRad) is int or type(connection.other.holeRad) is float:\\n self.otherpaths.append(Circle(connection.other.pos, rad=connection.other.holeRad, side='in'))\\n else:\\n t=copy.deepcopy(connection.other.holeRad)\\n t.translate(connection.other.pos)\\n self.otherpaths.append(t)\\n return path\",\n \"def hecken_taper(length = 200, B = 4.0091, dielectric_thickness = 0.25,\\n eps_r = 2, Lk_per_sq = 250e-12, Z1 = None, Z2 = None,\\n width1 = None, width2 = None, num_pts = 100, layer = 0):\\n if width1 is not None: Z1 = _microstrip_Z_with_Lk(\\n width1*1e-6,\\n dielectric_thickness*1e-6,\\n eps_r, Lk_per_sq\\n )\\n if width2 is not None: Z2 = _microstrip_Z_with_Lk(\\n width2*1e-6,\\n dielectric_thickness*1e-6,\\n eps_r, Lk_per_sq\\n )\\n # Normalized length of the wire [-1 to +1]\\n xi_list = np.linspace(-1, 1, num_pts)\\n Z = [np.exp(0.5*log(Z1*Z2) + 0.5*log(Z2/Z1)*_G(xi, B)) for xi in xi_list]\\n widths = np.array([_find_microstrip_wire_width(\\n z, dielectric_thickness*1e-6,\\n eps_r, Lk_per_sq\\n )*1e6 for z in Z])\\n x = ((xi_list/2)*length)\\n\\n # Compensate for varying speed of light in the microstrip by shortening\\n # and lengthening sections according to the speed of light in that section\\n v = np.array([_microstrip_v_with_Lk(w*1e-6, dielectric_thickness*1e-6,\\n eps_r, Lk_per_sq) for w in widths])\\n dx = np.diff(x)\\n dx_compensated = dx*v[:-1]\\n x_compensated = np.cumsum(dx_compensated)\\n x = np.hstack([0, x_compensated])/max(x_compensated) * length\\n\\n # Create blank device and add taper polygon\\n D = Device('hecken')\\n xpts = np.concatenate([x, x[::-1]])\\n ypts = np.concatenate([widths/2, -widths[::-1]/2])\\n D.add_polygon((xpts, ypts), layer = layer)\\n D.add_port(name = 1, midpoint = (0, 0), width = widths[0],\\n orientation = 180)\\n D.add_port(name = 2, midpoint = (length, 0), width = widths[-1],\\n orientation = 0)\\n\\n # Add meta information about the taper\\n D.info['num_squares'] = np.sum(np.diff(x)/widths[:-1])\\n D.info['width1'] = widths[0]\\n D.info['width2'] = widths[-1]\\n D.info['Z1'] = Z[0]\\n D.info['Z2'] = Z[-1]\\n # Note there are two values for v/c (and f_cutoff) because the speed of\\n # light is different at the beginning and end of the taper\\n D.info['w'] = widths\\n D.info['x'] = x\\n D.info['Z'] = Z\\n D.info['v/c'] = v/3e8\\n D.info['time_length'] = np.sum(np.diff(D.info['x']*1e-6) \\\\\\n / (D.info['v/c'][:-1]*3e8))\\n BetaLmin = sqrt(B**2 + 6.523)\\n D.info['f_cutoff'] = 1/(2*D.info['time_length'])\\n D.info['length'] = length\\n\\n return D\",\n \"def make_shape(type, name, divisions):\\n\\n if type == 'cube':\\n mc.polyCube(n=name, sx=divisions, sy=divisions, sz=divisions)\\n elif type == 'cone':\\n mc.polyCone(n=name, sx=divisions, sy=divisions, sz=divisions)\\n elif type == 'cylinder':\\n mc.polyCylinder(n=name, sx=divisions, sy=divisions, sz=divisions)\\n elif type == 'plane':\\n mc.polyPlane(n=name, sx=divisions, sy=divisions)\\n elif type == 'torus':\\n mc.polyTorus(n=name, sx=divisions, sy=divisions)\\n elif type == 'sphere':\\n mc.polySphere(n=name, sx=divisions, sy=divisions)\\n else:\\n mc.polySphere()\",\n \"def tail_joiner(self):\\n\\n # Fusing Right Horizontal Tail:\\n shape_in_r = Fused(shape_in=self.stabilizer_h.solid, tool=self.stabilizer_vright.solid)\\n shape_out_r = Fused(shape_in=shape_in_r, tool=self.connector_right)\\n\\n # Fusing Left Horizontal Tail:\\n shape_in_l = Fused(shape_in=self.stabilizer_h.ht_mirror, tool=self.stabilizer_vleft.solid)\\n shape_out_l = Fused(shape_in=shape_in_l, tool=self.connector_left)\\n\\n shape_out = Fused(shape_in=shape_out_r, tool=shape_out_l)\\n\\n return shape_out\",\n \"def check_win(self):\\n\\n # Sets rings initially to False\\n black_ring = False\\n white_ring = False\\n\\n # Gets board\\n board = self._game_board.get_board_area()\\n\\n # Iterate through stone-holding points\\n for i in range(1, 19):\\n for j in range(1, 19):\\n # Get the surroundings of each point\\n surround = {board[i+1][j], board[i-1][j], board[i+1][j+1], board[i+1][j-1], board[i-1][j],\\n board[i-1][j-1], board[i-1][j+1], board[i][j-1]}\\n\\n # If the point is empty and surrounded by \\\"B\\\", there's a black ring\\n if board[i][j] == \\\" \\\" and surround == {\\\"B\\\"}:\\n black_ring = True\\n\\n # If the point is empty and surrounded by \\\"W\\\", there's a white ring\\n if board[i][j] == \\\" \\\" and surround == {\\\"W\\\"}:\\n white_ring = True\\n\\n if not black_ring:\\n return \\\"WHITE_WON\\\"\\n\\n if not white_ring:\\n return \\\"BLACK_WON\\\"\\n\\n return \\\"UNFINISHED\\\"\",\n \"def CreateShapesWithStyle(self):\\r\\n\\r\\n useAero = (GetManager(self.GetParent()).GetAGWFlags() & AUI_MGR_AERO_DOCKING_GUIDES) != 0\\r\\n useWhidbey = (GetManager(self.GetParent()).GetAGWFlags() & AUI_MGR_WHIDBEY_DOCKING_GUIDES) != 0\\r\\n\\r\\n self._useAero = 0\\r\\n if useAero:\\r\\n self._useAero = 1\\r\\n elif useWhidbey:\\r\\n self._useAero = 2\\r\\n \\r\\n if useAero:\\r\\n sizeX, sizeY = aeroguideSizeX, aeroguideSizeY\\r\\n elif useWhidbey:\\r\\n sizeX, sizeY = whidbeySizeX, whidbeySizeY \\r\\n else:\\r\\n sizeX, sizeY = guideSizeX, guideSizeY\\r\\n\\r\\n rectLeft = wx.Rect(0, sizeY, sizeY, sizeX)\\r\\n rectTop = wx.Rect(sizeY, 0, sizeX, sizeY)\\r\\n rectRight = wx.Rect(sizeY+sizeX, sizeY, sizeY, sizeX)\\r\\n rectBottom = wx.Rect(sizeY, sizeX + sizeY, sizeX, sizeY)\\r\\n rectCenter = wx.Rect(sizeY, sizeY, sizeX, sizeX)\\r\\n \\r\\n if not self._useAero:\\r\\n\\r\\n self.targetLeft = AuiDockingGuideWindow(self, rectLeft, wx.LEFT, True, useAero)\\r\\n self.targetTop = AuiDockingGuideWindow(self, rectTop, wx.TOP, True, useAero)\\r\\n self.targetRight = AuiDockingGuideWindow(self, rectRight, wx.RIGHT, True, useAero)\\r\\n self.targetBottom = AuiDockingGuideWindow(self, rectBottom, wx.BOTTOM, True, useAero)\\r\\n self.targetCenter = AuiDockingGuideWindow(self, rectCenter, wx.CENTER, True, useAero)\\r\\n\\r\\n \\r\\n # top-left diamond\\r\\n tld = [wx.Point(rectTop.x, rectTop.y+rectTop.height-8),\\r\\n wx.Point(rectLeft.x+rectLeft.width-8, rectLeft.y),\\r\\n rectTop.GetBottomLeft()]\\r\\n # bottom-left diamond\\r\\n bld = [wx.Point(rectLeft.x+rectLeft.width-8, rectLeft.y+rectLeft.height),\\r\\n wx.Point(rectBottom.x, rectBottom.y+8),\\r\\n rectBottom.GetTopLeft()]\\r\\n # top-right diamond\\r\\n trd = [wx.Point(rectTop.x+rectTop.width, rectTop.y+rectTop.height-8),\\r\\n wx.Point(rectRight.x+8, rectRight.y),\\r\\n rectRight.GetTopLeft()] \\r\\n # bottom-right diamond\\r\\n brd = [wx.Point(rectRight.x+8, rectRight.y+rectRight.height),\\r\\n wx.Point(rectBottom.x+rectBottom.width, rectBottom.y+8),\\r\\n rectBottom.GetTopRight()]\\r\\n\\r\\n self._triangles = [tld[0:2], bld[0:2],\\r\\n [wx.Point(rectTop.x+rectTop.width-1, rectTop.y+rectTop.height-8),\\r\\n wx.Point(rectRight.x+7, rectRight.y)],\\r\\n [wx.Point(rectRight.x+7, rectRight.y+rectRight.height),\\r\\n wx.Point(rectBottom.x+rectBottom.width-1, rectBottom.y+8)]]\\r\\n \\r\\n region = wx.Region()\\r\\n region.UnionRect(rectLeft)\\r\\n region.UnionRect(rectTop)\\r\\n region.UnionRect(rectRight)\\r\\n region.UnionRect(rectBottom)\\r\\n region.UnionRect(rectCenter)\\r\\n region.UnionRegion(wx.RegionFromPoints(tld))\\r\\n region.UnionRegion(wx.RegionFromPoints(bld))\\r\\n region.UnionRegion(wx.RegionFromPoints(trd))\\r\\n region.UnionRegion(wx.RegionFromPoints(brd))\\r\\n\\r\\n elif useAero:\\r\\n\\r\\n self._aeroBmp = aero_dock_pane.GetBitmap()\\r\\n region = wx.RegionFromBitmap(self._aeroBmp)\\r\\n\\r\\n self._allAeroBmps = [aero_dock_pane_left.GetBitmap(), aero_dock_pane_top.GetBitmap(),\\r\\n aero_dock_pane_right.GetBitmap(), aero_dock_pane_bottom.GetBitmap(),\\r\\n aero_dock_pane_center.GetBitmap(), aero_dock_pane.GetBitmap()]\\r\\n self._deniedBitmap = aero_denied.GetBitmap()\\r\\n self._aeroRects = [rectLeft, rectTop, rectRight, rectBottom, rectCenter]\\r\\n self._valid = True\\r\\n\\r\\n elif useWhidbey:\\r\\n\\r\\n self._aeroBmp = whidbey_dock_pane.GetBitmap()\\r\\n region = wx.RegionFromBitmap(self._aeroBmp)\\r\\n\\r\\n self._allAeroBmps = [whidbey_dock_pane_left.GetBitmap(), whidbey_dock_pane_top.GetBitmap(),\\r\\n whidbey_dock_pane_right.GetBitmap(), whidbey_dock_pane_bottom.GetBitmap(),\\r\\n whidbey_dock_pane_center.GetBitmap(), whidbey_dock_pane.GetBitmap()]\\r\\n self._deniedBitmap = whidbey_denied.GetBitmap()\\r\\n self._aeroRects = [rectLeft, rectTop, rectRight, rectBottom, rectCenter]\\r\\n self._valid = True\\r\\n \\r\\n \\r\\n self.region = region\",\n \"def toShapely(ring, geometryList):\\n outline = []\\n for idxA, idxB in zip(ring, ring[1:] + ring[:1]):\\n shape = geometryList[idxA].GetShape()\\n if shape in [STROKE_T.S_ARC, STROKE_T.S_CIRCLE]:\\n outline += approximateArc(geometryList[idxA],\\n commonEndPoint(geometryList[idxA], geometryList[idxB]))\\n elif shape in [STROKE_T.S_CURVE]:\\n outline += approximateBezier(geometryList[idxA],\\n commonEndPoint(geometryList[idxA], geometryList[idxB]))\\n elif shape in [STROKE_T.S_RECT]:\\n assert idxA == idxB\\n outline += geometryList[idxA].GetRectCorners()\\n elif shape in [STROKE_T.S_POLYGON]:\\n # Polygons are always closed, so they should appear as stand-alone\\n assert len(ring) in [1, 2]\\n return shapePolyToShapely(geometryList[idxA].GetPolyShape())\\n elif shape in [STROKE_T.S_SEGMENT]:\\n outline.append(commonEndPoint(geometryList[idxA], geometryList[idxB]))\\n else:\\n raise RuntimeError(f\\\"Unsupported shape {shape} in outline\\\")\\n return Polygon(outline)\",\n \"def test_cliches_write_good_basic(self):\\n assert chk.check_cliches_write_good(\\\"\\\"\\\"No cliches here.\\\"\\\"\\\") == []\\n # use one of the example cliches to verify basic functionality\\n assert chk.check_cliches_write_good(self.l_write_good) != []\\n assert \\\"cliches.write_good\\\" in chk.check_cliches_write_good(\\n self.l_write_good)[0]\",\n \"def geoshapes(c = False, r = False, t = False):\\n if c == True:\\n circle = plt.Circle((0,0), radius = 3, fill = None, edgecolor = 'y')\\n plt.gca().add_patch(circle)\\n elif r == True:\\n rectangle = plt.Rectangle((0, 0), 5, 5, fill = None, edgecolor='r')\\n plt.gca().add_patch(rectangle)\\n elif t == True:\\n points = [[0,0], [0,3], [3,3]]\\n triangle = plt.Polygon(points, fill = None, edgecolor = 'r')\\n plt.gca().add_patch(triangle)\\n else:\\n print('Error: please input a True value for either c, r , or t')\",\n \"def __init__(self, workplane, measures):\\n\\n cq.Workplane.bracket = utilities.bracket\\n cq.Workplane.transformedWorkplane = utilities.transformedWorkplane\\n cq.Workplane.bolt = utilities.bolt\\n cq.Workplane.cutEachAdaptive = utilities.cutEachAdaptive\\n\\n self.model = workplane\\n self.debug = False\\n self.measures = measures\\n m = self.measures\\n\\n # The bracket lengths are measured at the outside, but the construction actually uses a \\n # central cuboid block with two attached brackets. Adapting the measures accordingly.\\n m.center_block = Measures(\\n # Naming is as seen from the horizontal leg.\\n width = max(m.horizontal_leg.width, m.vertical_leg.width),\\n depth = m.vertical_leg.height,\\n height = m.horizontal_leg.height\\n )\\n m.horizontal_leg.depth -= m.center_block.depth\\n m.vertical_leg.depth -= m.center_block.height\\n\\n # Create hole specs which combine the other hole measures in the format expected by bolthole().\\n m.horizontal_leg.hole_specs = [\\n {\\n \\\"diameter\\\": m.horizontal_leg.hole_diameters[i] if isinstance(m.horizontal_leg.hole_diameters, list) else m.horizontal_leg.hole_diameters,\\n \\\"clamp_length\\\": m.horizontal_leg.clamp_lengths[i] if isinstance(m.horizontal_leg.clamp_lengths, list) else m.horizontal_leg.clamp_lengths, \\n \\\"nuthole_size\\\": m.horizontal_leg.nuthole_sizes[i] if isinstance(m.horizontal_leg.nuthole_sizes, list) else m.horizontal_leg.nuthole_sizes, \\n \\\"nuthole_depth\\\": 1.1 * m.vertical_leg.depth # Just choose something large enough for cutting. \\n }\\n for i in range(m.horizontal_leg.hole_count)\\n ]\\n m.vertical_leg.hole_specs = [\\n {\\n \\\"diameter\\\": m.vertical_leg.hole_diameters[i] if isinstance(m.vertical_leg.hole_diameters, list) else m.vertical_leg.hole_diameters,\\n \\\"clamp_length\\\": m.vertical_leg.clamp_lengths[i] if isinstance(m.vertical_leg.clamp_lengths, list) else m.vertical_leg.clamp_lengths, \\n \\\"nuthole_size\\\": m.vertical_leg.nuthole_sizes[i] if isinstance(m.vertical_leg.nuthole_sizes, list) else m.vertical_leg.nuthole_sizes, \\n \\\"nuthole_depth\\\": 1.1 * m.horizontal_leg.depth # Just choose something large enough for cutting. \\n }\\n for i in range(m.vertical_leg.hole_count)\\n ]\\n\\n # TODO: Initialize missing measures with defaults.\\n\\n self.build()\",\n \"def test_absolute_shape_volume(self):\\n\\n assert self.test_shape.solid is not None\\n assert self.test_shape.volume() == pytest.approx(math.pi * (10**2) * 30)\",\n \"def ring_forming_scission(rct_zmas, prd_zmas):\\n ret = None\\n rct_zmas, rct_gras = shifted_standard_zmas_graphs(\\n rct_zmas, remove_stereo=True)\\n prd_zmas, prd_gras = shifted_standard_zmas_graphs(\\n prd_zmas, remove_stereo=True)\\n tras, _, _ = automol.graph.reac.ring_forming_scission(rct_gras, prd_gras)\\n if tras:\\n tra = tras[0]\\n brk_bnd_key, = automol.graph.trans.broken_bond_keys(tra)\\n frm_bnd_key, = automol.graph.trans.formed_bond_keys(tra)\\n ts_zma = rct_zmas[0]\\n\\n # set up radical atom, leaving atom, newly formed radical atom\\n # also set up chain between radical atom and newly formed radical atom\\n ts_gra = automol.zmatrix.graph(ts_zma)\\n rad_atm = list(automol.graph.sing_res_dom_radical_atom_keys(ts_gra))[0]\\n for atm in brk_bnd_key:\\n if atm not in frm_bnd_key:\\n leave_atm = atm\\n else:\\n new_rad_atm = atm\\n\\n chain_between = automol.zmatrix.chain_between(ts_zma, new_rad_atm, rad_atm)\\n\\n tors_names = automol.zmatrix.torsion_coordinate_names(ts_zma)\\n coo_dct = automol.zmatrix.coordinates(ts_zma)\\n ang_90 = numpy.pi/2.\\n ts_tors_names = []\\n const_tors_names = []\\n # (i) set torsion from rad atom towards chain to 90\\n for tors_name in tors_names:\\n axis = coo_dct[tors_name][0][1:3]\\n # (ii) remove torsions in chain_between from final torsion sampling list\\n if ((axis[0] not in chain_between) or (axis[1] not in chain_between)):\\n ts_tors_names.append(tors_name)\\n if ((rad_atm == axis[0] and axis[1] in chain_between) or\\n (rad_atm == axis[1] and axis[0] in chain_between)):\\n ts_zma_p = automol.zmatrix.set_values(ts_zma, {tors_name: ang_90})\\n # const_tors_names.append(tors_name)\\n\\n # (iii) vary torsions in chain_between to minimize distance from rad_atm to new_rad_atm\\n preopt_tors_names = []\\n for tors_name in tors_names:\\n axis = coo_dct[tors_name][0][1:3]\\n if ((axis[0] in chain_between) and (axis[1] in chain_between) and\\n (rad_atm not in axis) and (new_rad_atm not in axis)):\\n preopt_tors_names.append(tors_name)\\n # add any ring forming torsions to constraints to ensure 0 dihedrals for the ring\\n const_tors_names.append(tors_name)\\n\\n angles = [0., 2.*numpy.pi/3, 4.*numpy.pi/3]\\n # angles = [0., numpy.pi/3., 2.*numpy.pi/3, 3.*numpy.pi/3., 4.*numpy.pi/3, 5*numpy.pi/3.]\\n trial_zmas = [ts_zma_p]\\n for preopt_tors_name in preopt_tors_names:\\n new_trial_zmas = []\\n for zma_i in trial_zmas:\\n for ang in angles:\\n new_trial_zmas.append(\\n automol.zmatrix.set_values(\\n zma_i, {preopt_tors_name: ang}))\\n trial_zmas = new_trial_zmas\\n\\n dist_min = 1.0e30\\n for trial_zma in trial_zmas:\\n geo_i = automol.zmatrix.geometry(trial_zma)\\n dist = automol.geom.distance(geo_i, rad_atm, new_rad_atm)\\n if dist < dist_min:\\n dist_min = dist\\n ts_zma = trial_zma\\n\\n ang_stp = 2.*numpy.pi/6.\\n # (iv) vary torsion from new_rad_atm to leaving atom so that leave_atm is far from rad_atm\\n for tors_name in tors_names:\\n ang = -ang_stp\\n axis = coo_dct[tors_name][0][1:3]\\n if ((new_rad_atm == axis[0] and axis[1] in chain_between) or\\n (new_rad_atm == axis[1] and axis[0] in chain_between)):\\n dist_max = 0.0\\n for _ in range(6):\\n ang += ang_stp\\n ts_zma_i = automol.zmatrix.set_values(ts_zma, {tors_name: ang})\\n geo_i = automol.zmatrix.geometry(ts_zma_i)\\n dist = automol.geom.distance(geo_i, rad_atm, leave_atm)\\n if dist > dist_max:\\n dist_max = dist\\n ts_zma_max = ts_zma_i\\n const_tors_names.append(tors_name)\\n # set up ts torsions - remove ones with axis in the chain between new and old rad atoms\\n if ((axis[0] not in chain_between) or (axis[1] not in chain_between)):\\n ts_tors_names.append(tors_name)\\n # elif (axis[0] in chain_between) and (axis[1] in chain_between):\\n # if tors_name not in const_tors_names:\\n # const_tors_names.append(tors_name)\\n\\n ts_zma = ts_zma_max\\n\\n # (v) vary angles to decrease rad_atm to new_rad_atm to < 2.25 Ang\\n dist_thresh = 4.25\\n # dist_thresh = 4.\\n ang_names = automol.zmatrix.central_angle_names(ts_zma)\\n ring_angs = []\\n const_angs_names = []\\n for ang_name in ang_names:\\n ang_atms = coo_dct[ang_name][0]\\n if ((ang_atms[0] in chain_between) and (ang_atms[1] in chain_between) and\\n (ang_atms[2] in chain_between)):\\n ring_angs.append(ang_name)\\n const_angs_names.append(ang_name)\\n dist = 1.e30\\n ang_stp = numpy.pi/360.\\n # ang_stp = 0.5 degrees\\n counter = 0\\n while ((dist > dist_thresh) and (counter < 30)):\\n counter += 1\\n values = automol.zmatrix.values(ts_zma)\\n for ang_name in ring_angs:\\n ang = values[ang_name] - ang_stp\\n ts_zma = automol.zmatrix.set_values(ts_zma, {ang_name: ang})\\n geo_i = automol.zmatrix.geometry(ts_zma)\\n dist = automol.geom.distance(geo_i, rad_atm, new_rad_atm)\\n\\n brk_dist_name = automol.zmatrix.bond_key_from_idxs(ts_zma, brk_bnd_key)\\n\\n # Build the reactants graph\\n rcts_gra = automol.graph.union_from_sequence(rct_gras)\\n\\n # Set the indices for the const coords\\n\\n ret = (ts_zma, brk_dist_name, brk_bnd_key,\\n tuple(const_tors_names), tuple(ts_tors_names),\\n tuple(const_angs_names), rcts_gra)\\n\\n return ret\",\n \"def circular_punching(cls, nb_points,outer_rad, position):\\n\\n rad1= outer_rad\\n rad2 = 0.1*rad1\\n rad3 = 0.02*rad1\\n points1 = rad1*np.transpose(np.concatenate(([np.cos(2*np.pi*np.arange(0,nb_points+1)/nb_points)],[np.sin(2*np.pi*np.arange(0,nb_points+1)/nb_points)]),axis=0))\\n curv = 0*np.ones(points1.shape[0])\\n curv[0] = 0\\n curv[-1] = 0\\n punching_circ = Feature.define_tube(points1,curv,rad3)\\n points2 = rad2*np.transpose(np.concatenate(([np.cos(2*np.pi*np.arange(0,nb_points+1)/nb_points)],[np.sin(2*np.pi*np.arange(0,nb_points+1)/nb_points)]),axis=0))\\n sectors = [np.concatenate(([points2[x,:]],[((rad1-rad3)/rad1)*points1[x,:]],[((rad1-rad3)/rad1)*points1[x+1,:]],[points2[x+1,:]]),axis=0) for x in range(0,nb_points,2)]\\n\\n punching = [punching_circ.coord[0],points2]\\n\\n for x in range(len(sectors)):\\n punching.append(sectors[x])\\n\\n for x in range(len(punching)):\\n for y in range(punching[x].shape[0]):\\n punching[x][y,:]=punching[x][y,:]+position\\n\\n punching_obj = cls()\\n punching_obj.coord = punching\\n return punching_obj\",\n \"def checkSubClass(self, checkSub:bool=True):\\n lines = self.edges()\\n slope = [x.slope() for x in lines]\\n length = [x.length() for x in lines]\\n\\n if (\\n abs(slope[0]- slope[2]) < Drawable._comparisonLimit and\\n abs(slope[3] - slope[1]) < Drawable._comparisonLimit\\n ):\\n from Drawables.Parallelogram import Parallelogram\\n rectangle = abs((slope[1] * slope[2]) +1) < Drawable._comparisonLimit\\n rhombus = abs(length[1] - length[2]) < Drawable._comparisonLimit\\n if rectangle and rhombus:\\n from Drawables.Square import Square\\n new = Square()\\n elif rectangle:\\n from Drawables.Rectangle import Rectangle\\n new = Rectangle()\\n elif rhombus:\\n from Drawables.Rhombus import Rhombus\\n new = Rhombus()\\n else:\\n new = Parallelogram()\\n new.vertices = self.vertices\\n new.size = self.size\\n new.clockwise = self.clockwise\\n return new\\n if (\\n abs(slope[0] - slope[2]) < Drawable._comparisonLimit or\\n abs(slope[3] - slope[1]) < Drawable._comparisonLimit\\n ):\\n from Drawables.Trapezoid import Trapezoid\\n new = Trapezoid()\\n new.vertices = self.vertices\\n new.size = self.size\\n new.clockwise = self.clockwise\\n return new\\n if (\\n (\\n abs(length[0] - length[1]) < Drawable._comparisonLimit and \\n abs(length[2] - length[3]) < Drawable._comparisonLimit\\n ) or\\n (\\n abs(length[0] - length[3]) < Drawable._comparisonLimit and \\n abs(length[1] - length[2]) < Drawable._comparisonLimit\\n )\\n ):\\n from Drawables.Kite import Kite\\n new = Kite()\\n new.vertices = self.vertices\\n new.size = self.size\\n new.clockwise = self.clockwise\\n return new\\n return self\",\n \"def test_flatten_requirement(self, space_each_type):\\n tspace = build_required_space(space_each_type, shape_requirement=\\\"flattened\\\")\\n\\n # 1 integer + 1 categorical + 1 * (3, 2) shapes\\n assert len(tspace) == 1 + 1 + 3 * (3 * 2)\\n assert str(tspace).count(\\\"View\\\") == 3 * (3 * 2) + 1\\n\\n i = 0\\n\\n assert tspace[i].type == \\\"categorical\\\"\\n i += 1\\n\\n assert tspace[i].type == \\\"integer\\\"\\n i += 1\\n\\n for _ in range(3 * 2):\\n assert tspace[i].type == \\\"real\\\"\\n i += 1\\n\\n for _ in range(3 * 2):\\n assert tspace[i].type == \\\"integer\\\"\\n i += 1\\n\\n for _ in range(3 * 2):\\n assert tspace[i].type == \\\"real\\\"\\n i += 1\\n\\n tspace = build_required_space(\\n space_each_type, shape_requirement=\\\"flattened\\\", type_requirement=\\\"real\\\"\\n )\\n\\n # 1 integer + 4 categorical + 1 * (3, 2) shapes\\n assert len(tspace) == 1 + 4 + 3 * (3 * 2)\\n assert str(tspace).count(\\\"View\\\") == 4 + 3 * (3 * 2) + 1\",\n \"def test_cut_volume(self):\\n\\n shape_with_cut = ExtrudeCircleShape(points=[(30, 0)], radius=20, distance=40, cut=self.test_shape)\\n\\n assert shape_with_cut.volume() == pytest.approx((math.pi * (20**2) * 40) - (math.pi * (10**2) * 30))\",\n \"def _makeBlockPinPatches(block, cold):\\n patches = []\\n data = []\\n names = []\\n if isinstance(block.spatialGrid, grids.HexGrid):\\n largestPitch, comp = block.getPitch(returnComp=True)\\n\\n elif isinstance(block.spatialGrid, grids.ThetaRZGrid):\\n raise TypeError(\\n \\\"This plot function is not currently supported for ThetaRZGrid grids.\\\"\\n )\\n else:\\n largestPitch, comp = block.getPitch(returnComp=True)\\n if block.getPitch()[0] != block.getPitch()[1]:\\n raise ValueError(\\\"Only works for blocks with equal length and width.\\\")\\n\\n sortedComps = sorted(block, reverse=True)\\n\\n derivedComponents = block.getComponentsOfShape(DerivedShape)\\n if len(derivedComponents) == 1:\\n derivedComponent = derivedComponents[0]\\n sortedComps.remove(derivedComponent)\\n cName = derivedComponent.name\\n\\n if isinstance(derivedComponent.material, custom.Custom):\\n material = derivedComponent.p.customIsotopicsName\\n else:\\n material = derivedComponent.material.name\\n\\n location = comp.spatialLocator\\n if isinstance(location, grids.MultiIndexLocation):\\n location = location[0]\\n x, y, _ = location.getLocalCoordinates()\\n if isinstance(comp, Hexagon):\\n derivedPatch = matplotlib.patches.RegularPolygon(\\n (x, y), 6, largestPitch / math.sqrt(3)\\n )\\n elif isinstance(comp, Square):\\n derivedPatch = matplotlib.patches.Rectangle(\\n (x - largestPitch[0] / 2, y - largestPitch[0] / 2),\\n largestPitch[0],\\n largestPitch[0],\\n )\\n else:\\n raise TypeError(\\n \\\"Shape of the pitch-defining element is not a Square or Hex it is {}, cannot plot for this type of block\\\".format(\\n comp.shape\\n )\\n )\\n patches.append(derivedPatch)\\n data.append(material)\\n names.append(cName)\\n for component in sortedComps:\\n locs = component.spatialLocator\\n if not isinstance(locs, grids.MultiIndexLocation):\\n # make a single location a list to iterate.\\n locs = [locs]\\n for loc in locs:\\n x, y, _ = loc.getLocalCoordinates()\\n\\n # goes through each location\\n # want to place a patch at that location\\n blockPatches = _makeComponentPatch(component, (x, y), cold)\\n for element in blockPatches:\\n patches.append(element)\\n\\n if isinstance(component.material, custom.Custom):\\n material = component.p.customIsotopicsName\\n else:\\n material = component.material.name\\n\\n data.append(material)\\n names.append(component.name)\\n\\n return patches, data, names\",\n \"def circlePrimitive(self):\\n\\n def drawWireframe(self):\\n\\n # Draw line\\n glFT.glBegin(OpenMayaRender.MGL_LINE_STRIP)\\n\\n # Get Color\\n # self.getColor(\\\"edge\\\")\\n\\n def_circle = 100\\n for idx in range(def_circle + 1):\\n\\n theta = 2 * 3.141592 * idx / def_circle\\n x = self.shape_size * math.cos(theta)\\n z = self.shape_size * math.sin(theta)\\n\\n point = OpenMaya.MVector(x, 0.0, z)\\n point = self.setUpAxis(point)\\n point = self.addOffsetRotation(point)\\n point = self.addOffsetPosition(point)\\n self.getBoundingBoxSize(point)\\n\\n glFT.glVertex3f(point.x, point.y, point.z)\\n\\n glFT.glEnd()\\n \\n def drawShaded(self):\\n\\n # Draw quad\\n glFT.glBegin(OpenMayaRender.MGL_POLYGON)\\n\\n # Get Color\\n # self.getColor(\\\"polygon\\\")\\n\\n def_circle = 100\\n for idx in range(def_circle + 1):\\n\\n theta = 2 * 3.141592 * idx / def_circle\\n x = self.shape_size * math.cos(theta)\\n z = self.shape_size * math.sin(theta)\\n\\n point = OpenMaya.MVector(x, 0.0, z)\\n point = self.setUpAxis(point)\\n point = self.addOffsetRotation(point)\\n point = self.addOffsetPosition(point)\\n self.getBoundingBoxSize(point)\\n\\n glFT.glVertex3f(point.x, point.y, point.z)\\n\\n glFT.glEnd()\\n\\n glFT.glNewList(self.vList_id, OpenMayaRender.MGL_COMPILE)\\n\\n # Draw lines\\n if self.draw_type == 0 or self.draw_type == 2:\\n drawWireframe(self)\\n \\n # Draww Polygons\\n if self.draw_type == 1 or self.draw_type == 2:\\n drawShaded(self)\\n\\n glFT.glEndList()\",\n \"def shape(self, rootsequence, side, image, option=0):\\n\\n left_points = self.get_points(\\n side=0,\\n imgnumber=image)\\n\\n leftX, leftY, leftZ = self.separate_points_by_coordinate(left_points)\\n\\n right_points = self.get_points(\\n side=1,\\n imgnumber=image)\\n\\n rightX, rightY, rightZ = self.separate_points_by_coordinate(right_points)\\n\\n if option == 1:\\n lalpha_shapes = self.alpha_shapes(\\n X=leftX,\\n Y=leftY,\\n Z=leftZ,\\n alpha=5,\\n # color='#A91818',\\n color='#808080',\\n opacity=1.0)\\n\\n ralpha_shapes = self.alpha_shapes(\\n X=rightX,\\n Y=rightY,\\n Z=rightZ,\\n alpha=5,\\n # color='#FF3232',\\n color='#808080',\\n opacity=1.0)\\n\\n return [lalpha_shapes, ralpha_shapes]\\n\\n elif option == 2:\\n lpoint_cloud = self.point_cloud(\\n X=leftX,\\n Y=leftY,\\n Z=leftZ,\\n legend='RIGHT LUNG',\\n size=1,\\n # color='#FF3232',\\n # bordercolor='#FF3232',\\n color='#999999',\\n bordercolor='#999999',\\n width=0.5,\\n opacity=1.0)\\n\\n rpoint_cloud = self.point_cloud(\\n X=rightX,\\n Y=rightY,\\n Z=rightZ,\\n legend='LEFT LUNG',\\n size=1,\\n # color='#701700',\\n # bordercolor='#701700',\\n color='#999999',\\n bordercolor='#999999',\\n width=0.5,\\n opacity=1.0)\\n\\n lalpha_shapes = self.alpha_shapes(\\n X=leftX,\\n Y=leftY,\\n Z=leftZ,\\n alpha=5,\\n color='rgba(255, 0, 0, 0.1)',\\n # color='#808080',\\n opacity=1.0)\\n\\n ralpha_shapes = self.alpha_shapes(\\n X=rightX,\\n Y=rightY,\\n Z=rightZ,\\n alpha=5,\\n color='rgba(255, 0, 0, 0.1)',\\n # color='#808080',\\n opacity=1.0)\\n\\n return [lpoint_cloud, rpoint_cloud, lalpha_shapes, ralpha_shapes]\\n\\n else:\\n lpoint_cloud = self.point_cloud(\\n X=leftX,\\n Y=leftY,\\n Z=leftZ,\\n legend='RIGHT LUNG',\\n size=1,\\n # color='#FF3232',\\n # bordercolor='#FF3232',\\n color='#999999',\\n bordercolor='#999999',\\n width=0.5,\\n opacity=1.0)\\n\\n rpoint_cloud = self.point_cloud(\\n X=rightX,\\n Y=rightY,\\n Z=rightZ,\\n legend='LEFT LUNG',\\n size=1,\\n color='#999999',\\n bordercolor='#999999',\\n # color='#701700',\\n # bordercolor='#701700',\\n width=0.5,\\n opacity=1.0)\\n\\n return [lpoint_cloud, rpoint_cloud]\",\n \"def checkForCircle(self, points, tangents):\\n if len(points)<10:\\n return False, 0\\n\\n if all(points[0]==points[-1]): # last exactly equals the first.\\n # Ignore last point for this check\\n points = points[:-1]\\n tangents = tangents[:-1]\\n #print 'Removed last ', points\\n xmin,ymin, w, h = computeBox( points)\\n diag2=(w*w+h*h)\\n \\n diag = sqrt(diag2)*0.5\\n norms = numpy.sqrt(numpy.sum( tangents**2, 1 ))\\n\\n angles = numpy.arctan2( tangents[:,1], tangents[:,0] ) \\n #debug( 'angle = ', repr(angles))\\n N = len(angles)\\n \\n deltas = points[1:] - points[:-1] \\n deltasD = numpy.concatenate([ [D(points[0],points[-1])/diag], numpy.sqrt(numpy.sum( deltas**2, 1 )) / diag] )\\n\\n # locate and avoid the point when swicthing\\n # from -pi to +pi. The point is around the minimum\\n imin = numpy.argmin(angles)\\n debug(' imin ',imin)\\n angles = numpy.roll(angles, -imin)\\n deltasD = numpy.roll(deltasD, -imin)\\n n=int(N*0.1)\\n # avoid fluctuations by removing points around the min\\n angles=angles[n:-n]\\n deltasD=deltasD[n:-n]\\n deltasD = deltasD.cumsum()\\n N = len(angles)\\n\\n # smooth angles to avoid artificial bumps\\n angles = smoothArray(angles, n=max(int(N*0.03),2) )\\n\\n deltaA = angles[1:] - angles[:-1]\\n deltasDD = (deltasD[1:] -deltasD[:-1])\\n deltasDD[numpy.where(deltasDD==0.)] = 1e-5*deltasD[0]\\n dAdD = abs(deltaA/deltasDD)\\n belowT, count = True,0\\n for v in dAdD:\\n if v>6 and belowT:\\n count+=1\\n belowT = False\\n belowT= (v<6)\\n\\n self.temp = (deltasD,angles, tangents, dAdD )\\n fracStraight = numpy.sum(deltasDD[numpy.where(dAdD<0.3)])/(deltasD[-1]-deltasD[0])\\n curveLength = deltasD[-1]/3.14\\n #print \\\"SSS \\\",count , fracStraight\\n if curveLength> 1.4 or fracStraight>0.4 or count > 6:\\n isCircle =False\\n else: \\n isCircle= (count < 4 and fracStraight<=0.3) or \\\\\\n (fracStraight<=0.1 and count<5)\\n\\n if not isCircle:\\n return False, 0\\n \\n # It's a circle !\\n radius = points - numpy.array([xmin+w*0.5,ymin+h*0.5])\\n radius_n = numpy.sqrt(numpy.sum( radius**2, 1 )) # normalize\\n\\n mini = numpy.argmin(radius_n) \\n rmin = radius_n[mini]\\n maxi = numpy.argmax(radius_n) \\n rmax = radius_n[maxi]\\n # void points around maxi and mini to make sure the 2nd max is found\\n # on the \\\"other\\\" side\\n n = len(radius_n)\\n radius_n[maxi]=0 \\n radius_n[mini]=0 \\n for i in range(1,n/8+1):\\n radius_n[(maxi+i)%n]=0\\n radius_n[(maxi-i)%n]=0\\n radius_n[(mini+i)%n]=0\\n radius_n[(mini-i)%n]=0\\n radius_n_2 = [ r for r in radius_n if r>0]\\n rmax_2 = max(radius_n_2)\\n rmin_2 = min(radius_n_2) # not good !!\\n anglemax = numpy.arccos( radius[maxi][0]/rmax)*numpy.sign(radius[maxi][1])\\n return True, (xmin+w*0.5,ymin+h*0.5, 0.5*(rmin+rmin_2), 0.5*(rmax+rmax_2), anglemax)\",\n \"def drawBrick(res_num1, atom1, res_num2, atom2, **kwargs):\\n\\n chain1 = str(kwargs.pop(\\\"chain1\\\", \\\"A\\\")).strip()\\n chain2 = str(kwargs.pop(\\\"chain2\\\", \\\"A\\\")).strip()\\n res_num1 = int(res_num1)\\n res_num2 = int(res_num2)\\n offset1 = str2array(kwargs.pop(\\\"offset1\\\", \\\"(0,0,0)\\\"))\\n offset2 = str2array(kwargs.pop(\\\"offset2\\\", \\\"(0,0,0)\\\"))\\n\\n boxname = kwargs.pop(\\\"boxname\\\", \\\"brick\\\")\\n selname = kwargs.pop(\\\"name\\\", \\\"(sel)\\\")\\n p1 = get_selection_first_coord(\\\"///%(chain1)s/`%(res_num1)d/%(atom1)s\\\" % vars(), selname)\\n p2 = get_selection_first_coord(\\\"///%(chain2)s/`%(res_num2)d/%(atom2)s\\\" % vars(), selname)\\n\\n #print \\\"lower_left: %r\\\" % lower_left\\n #print \\\"offset1: %r\\\" % offset1\\n\\n p1 += offset1\\n p2 += offset2\\n\\n lower_left = numpy.where(p1 < p2, p1, p2)\\n upper_right = numpy.where(p1 < p2, p2, p1)\\n\\n print \\\"--> lower left front corner: %(lower_left)r\\\" % vars()\\n print \\\"--> upper right back corner: %(upper_right)r\\\" % vars()\\n\\n boxCGO = box(lower_left, upper_right, **kwargs)\\n cmd.load_cgo(boxCGO, boxname)\\n return boxname\",\n \"def ring_forming_scission_ts_geometry(rxn, rct_geos,\\n max_dist_err=2e-1, log=False):\\n assert rxn.class_ == ReactionClass.Typ.RING_FORM_SCISSION\\n assert rxn.has_standard_keys()\\n frm_bnd_key, = ts.forming_bond_keys(rxn.forward_ts_graph)\\n brk_bnd_key, = ts.breaking_bond_keys(rxn.forward_ts_graph)\\n frm_bnd_dist = 2.0\\n brk_bnd_dist = 1.5\\n d1234 = 180.\\n\\n dist_dct = automol.geom.ts.distances(rct_geos, angstrom=True)\\n dist_dct[frm_bnd_key] = frm_bnd_dist\\n dist_dct[brk_bnd_key] = brk_bnd_dist\\n\\n # Note that this will not set the angle to exactly 180, because we don't\\n # yet know the 1-3 and 2-4 distances.\\n chain_keys = ring_forming_scission_chain(rxn)\\n key1, key2, key3, key4 = chain_keys[:4]\\n dih_dct = {(key1, key2, key3, key4): (d1234, None)}\\n\\n gra = ts.reactants_graph(rxn.forward_ts_graph)\\n dist_range_dct = automol.graph.embed.distance_ranges_from_coordinates(\\n gra, dist_dct, dih_dct=dih_dct, degree=True, angstrom=True)\\n\\n geo_init, = rct_geos\\n relax_ang = True\\n relax_tors = True\\n\\n geo = _geometry_from_info(\\n gra, rct_geos, geo_init, dist_range_dct,\\n relax_ang=relax_ang, relax_tors=relax_tors,\\n max_dist_err=max_dist_err, log=log)\\n\\n # Rerun the optimization, enforcing planarity on the ring\\n dist_dct = automol.geom.ts.distances([geo], angstrom=True)\\n dist_dct[frm_bnd_key] = frm_bnd_dist\\n dist_dct[brk_bnd_key] = brk_bnd_dist\\n pla_dct = {}\\n for key1, key2, key3, key4 in mit.windowed(chain_keys, 4):\\n pla_dct[(key1, key2, key3, key4)] = (0.0, 0.0)\\n\\n gra = ts.reactants_graph(rxn.forward_ts_graph)\\n dist_range_dct = automol.graph.embed.distance_ranges_from_coordinates(\\n gra, dist_dct, degree=True, angstrom=True)\\n\\n geo = _geometry_from_info(\\n gra, [geo], geo, dist_range_dct,\\n relax_ang=relax_ang, relax_tors=relax_tors,\\n pla_dct=pla_dct,\\n max_dist_err=max_dist_err, log=log)\\n\\n return geo\",\n \"def graphCut(img, center, radius, temp, edge, count, editPoints, padList, theta_width, phi_width):\\r\\n\\r\\n\\r\\n \\\"\\\"\\\"Important note. The labeled image is referred to as temp, or self.temp in the interface.\\r\\n This stands for template. The previously labled image is fed back into the graphcut\\\"\\\"\\\"\\r\\n \\r\\n \\\"\\\"\\\"create polar images and cost arrays\\\"\\\"\\\"\\r\\n \\r\\n print \\\"RUNNING GRAPHCUT!\\\"\\r\\n img= padImage(img, padList)\\r\\n temp= padImage(temp, padList)\\r\\n edge= padImage(edge, padList)\\r\\n center= padCenter(center, padList)\\r\\n \\r\\n polar_img= img2polar(img, center, radius, theta_width=theta_width, phi_width=phi_width)\\r\\n\\r\\n \\r\\n \\r\\n polar_grad, y, x = np.gradient(np.array(polar_img, dtype='float'))\\r\\n \\\"\\\"\\\"Lockett 100416 replacement line below to not use gradient when the image has a surface label\\\"\\\"\\\"\\r\\n \\\"\\\"\\\"polar_grad = -1 * np.array(polar_img, dtype='float')\\\"\\\"\\\"\\r\\n \\r\\n \\r\\n polar_cost = -1 * np.ones(polar_img.shape)\\r\\n for r in range(1,radius):\\r\\n polar_cost[r]= polar_grad[r]-polar_grad[r-1]\\r\\n\\r\\n \\r\\n \\r\\n \\\"\\\"\\\"\\r\\n flip the cost image upside down. This is so that the base set is at the bottom of the array\\r\\n since the graphcut cuts from top to bottom, this inversion is necessary.\\r\\n \\\"\\\"\\\"\\r\\n polar_cost_inv=polar_cost[::-1,:,:]\\r\\n\\r\\n print \\\"CONSTRUCTING GRAPH EDGES... \\\"\\r\\n \\r\\n \\\"\\\"\\\"construct the graph using PyMaxFlow\\\"\\\"\\\"\\r\\n g=maxflow.GraphFloat()\\r\\n nodeids=g.add_grid_nodes(polar_img.shape)\\r\\n structure=np.zeros((3,3,3))\\r\\n structure[2]= np.array([[0,10000,0],[10000, 10000, 10000],[0, 10000, 0]])\\r\\n g.add_grid_edges(nodeids, structure=structure, symmetric=False)\\r\\n\\r\\n \\r\\n \\\"\\\"\\\"convert the previously labeled image (temp) into a polar transform image. Take the labels and\\r\\n give them high cost edge weights so the segmentation avoids previously labeled objects\\\"\\\"\\\"\\r\\n polar_lbl_img= img2polar(temp, center, radius, theta_width=theta_width, phi_width=phi_width)\\r\\n polar_lbl_img_inv= polar_lbl_img[::-1,:]\\r\\n \\r\\n lbl_caps= polar_lbl_img_inv>0\\r\\n self_caps= (polar_lbl_img_inv==count)\\r\\n lbl_caps-=self_caps\\r\\n lbl_source_caps= np.zeros(lbl_caps.shape)\\r\\n lbl_sink_caps= lbl_caps*10000\\r\\n g.add_grid_tedges(nodeids, lbl_source_caps, lbl_sink_caps)\\r\\n \\r\\n structure2= 10000*np.array([[0,0,0],[0,0,1],[0,1,0]])\\r\\n g.add_grid_edges(nodeids[radius-1], structure=structure2, symmetric=True)\\r\\n\\r\\n \\\"\\\"\\\"add terminal edges using two arrays whose elemnts are the costs of the edges from the source and to the\\r\\n sink\\\"\\\"\\\"\\r\\n print \\\"CONSTRUCTING GRAPH TEDGES...\\\"\\r\\n sinkcaps= polar_cost_inv * (polar_cost_inv>=0)\\r\\n sourcecaps = -1 * polar_cost_inv * (polar_cost_inv<0)\\r\\n g.add_grid_tedges(nodeids, sourcecaps, sinkcaps)\\r\\n\\r\\n \\r\\n\\r\\n \\r\\n \\\"\\\"\\\"accounts for edit points. Takes every point in the edit point list, converts it to its spherical coordinate, and adds high cost\\r\\n edges in the column of that edit point inverts the x and y coordinates of the center\\\"\\\"\\\"\\r\\n center= np.array((center[0], center[2], center[1]))\\r\\n if len(editPoints)!=0:\\r\\n for coords in editPoints:\\r\\n\\r\\n \\r\\n rad= math.sqrt((center[0]-coords[0])**2+ (center[1]-coords[2])**2 + (center[2]-coords[1])**2) \\r\\n theta= math.atan2(center[2]-coords[1], coords[2]-center[1])\\r\\n print str((coords[0]-center[0])/(rad+1))\\r\\n phi=math.acos(float(coords[0]-center[0])/(rad+1))\\r\\n if theta<0:\\r\\n theta=2*math.pi+ theta\\r\\n theta= theta_width- theta_width*theta/(2*math.pi)-1\\r\\n phi= phi_width*phi/(math.pi)-1\\r\\n rad= radius- rad\\r\\n print \\\"POLAR COORDS: \\\" + str((rad, theta, phi))\\r\\n\\r\\n for r in range(0, radius):\\r\\n if r<=rad:\\r\\n g.add_tedge(nodeids[r, theta, phi], 0, 10000)\\r\\n \\r\\n else:\\r\\n g.add_tedge(nodeids[r, theta, phi], 10000, 0) \\r\\n\\r\\n\\r\\n\\r\\n\\r\\n print \\\"CUTTING GRAPH...\\\"\\r\\n g.maxflow()\\r\\n\\r\\n \\\"\\\"\\\"s-t mincut of graph. This is converted to cartesian coordinates with the function img2cart. The\\r\\n images are also closed to eliminate spotty areas\\\"\\\"\\\"\\r\\n \\r\\n print \\\"STARTING CARTESIAN TRANSFORM...\\\"\\r\\n polar_img_seg= np.invert(g.get_grid_segments(nodeids)[::-1,:,:])\\r\\n\\r\\n \\r\\n edge_img= np.zeros(img.shape)\\r\\n seg_img= ndimage.binary_closing(img2cart(img, polar_img_seg, center, radius, theta_width, phi_width))\\r\\n \\r\\n \\r\\n \\\"\\\"\\\"create an edge image of the segmented object\\\"\\\"\\\"\\r\\n strel=np.ones((3,3,3))\\r\\n erode_img=ndimage.binary_erosion(seg_img, strel)\\r\\n edge_img=np.logical_xor(seg_img, erode_img)\\r\\n \\r\\n\\r\\n \\\"\\\"\\\"shears the segmentation image and edge if padding was applied\\\"\\\"\\\"\\r\\n \\r\\n\\r\\n \\\"\\\"\\\"add the object back on to the template image (and the edge image back on the template edge)\\r\\n If there was an editpoint involved, remove the previous segmentation of that object and add back\\r\\n on the edited object\\\"\\\"\\\"\\r\\n if len(editPoints)!=0:\\r\\n del_img= (temp==count)*count\\r\\n temp-=del_img\\r\\n\\r\\n del_edge_img= (edge==count)*count\\r\\n edge-= del_edge_img\\r\\n\\r\\n\\r\\n temp+=seg_img*count\\r\\n edge+=edge_img*count\\r\\n\\r\\n temp= shearImage(temp, padList)\\r\\n edge= shearImage(edge, padList)\\r\\n \\r\\n \\r\\n\\r\\n print \\\"FINISHED!\\\"\\r\\n \\r\\n return temp, edge\",\n \"def showSimpleCylinders(self): \\n #from morphforge.morphology.util import TriMeshBuilderVerySimple\\n import sys\\n sys.path.append('/usr/share/pyshared/')\\n \\n #import morphforge\\n from morphforge.morphology.mesh import MeshBuilderRings\\n MonkeyPatchMayaVi()\\n #import enthought.mayavi.mlab as mlab\\n from mayavi import mlab\\n \\n assert len(self.morphs)==1\\n mesh = MeshBuilderRings().build(self.morphs[0])\\n \\n \\n @mlab.show\\n def _showSimpleCylinders():\\n\\t \\n #c = TriMeshBuilderVerySimple(self.morphs[0])\\n #mlab.triangular_mesh(c.x, c.y, c.z, c.triangles, colormap=self.colormap)\\n mlab.triangular_mesh(mesh.vertices[:,0], mesh.vertices[:,1], mesh.vertices[:,2], mesh.triangles, colormap=self.colormap)\\n \\n _showSimpleCylinders()\",\n \"def __fill_lip_solid(self, outer, inner):\\n inner[0].reverse()\\n inner[1].reverse()\\n outer_curve = zip(outer[0], outer[1])\\n inner_curve = zip(inner[0], inner[1])\\n points = []\\n for point in outer_curve:\\n points.append(np.array(point, dtype=np.int32))\\n for point in inner_curve:\\n points.append(np.array(point, dtype=np.int32))\\n points = np.array(points, dtype=np.int32)\\n self.red_l = int(self.red_l)\\n self.green_l = int(self.green_l)\\n self.blue_l = int(self.blue_l)\\n cv2.fillPoly(self.image, [points], (self.red_l, self.green_l, self.blue_l))\",\n \"def grow_surface(initial_shell_point, initial_screen_point, screen_normal, principal_ray, process_pool, stop_flag, on_new_patch):\\n \\n max_angle = FOV/2.0\\n angle_step = math.fabs(math.atan(optics.globals.LIGHT_RADIUS / initial_shell_point[2]))\\n \\n #a simple queue of requests in the form of arguments to pass to create_patch\\n patch_requests = []\\n \\n all_patches = []\\n patch_grid = {}\\n def grid_index(patch):\\n \\\"\\\"\\\"\\n Returns a (mu, rho) integer pair representing the patch. For easy indexing and tracking which have been created.\\n \\\"\\\"\\\"\\n mu = round(math.fabs(patch.mu_start_plane.angle) / angle_step)\\n if patch.mu_end_plane.angle < 0:\\n if patch.mu_start_plane.angle == 0.0:\\n mu = -1\\n else:\\n mu += 2\\n mu *= -1\\n rho = round(math.fabs(patch.rho_start_plane.angle) / angle_step)\\n if patch.rho_end_plane.angle < 0:\\n if patch.rho_start_plane.angle == 0.0:\\n rho = -1\\n else:\\n rho += 2\\n rho *= -1\\n return (mu, rho)\\n \\n def _create_patch_for_index(index):\\n \\\"\\\"\\\"\\n Create a patch at a given index. Assumes that any required previous patches exist.\\n \\\"\\\"\\\"\\n mu_idx, rho_idx = index\\n prev_rho_patch = None\\n prev_mu_patch = None\\n if mu_idx == 0 and rho_idx == 0:\\n shell_point = initial_shell_point\\n screen_point = initial_screen_point\\n mu_start_plane = optics.arcplane.ArcPlane(mu=0.0)\\n mu_end_plane = optics.arcplane.ArcPlane(mu=angle_step)\\n rho_start_plane = optics.arcplane.ArcPlane(rho=0.0)\\n rho_end_plane = optics.arcplane.ArcPlane(rho=angle_step)\\n else:\\n if mu_idx != 0:\\n if mu_idx > 0:\\n prev_mu_idx = mu_idx - 1\\n else:\\n prev_mu_idx = mu_idx + 1\\n prev_mu_patch = patch_grid[(prev_mu_idx, rho_idx)]\\n mu_start_plane = prev_mu_patch.mu_end_plane\\n if mu_idx > 0:\\n mu_end_plane = optics.arcplane.ArcPlane(mu=angle_step * (mu_idx+1))\\n else:\\n mu_end_plane = optics.arcplane.ArcPlane(mu=angle_step * mu_idx)\\n else:\\n mu_start_plane = optics.arcplane.ArcPlane(mu=0.0)\\n mu_end_plane = optics.arcplane.ArcPlane(mu=angle_step)\\n if rho_idx != 0:\\n if rho_idx > 0:\\n prev_rho_idx = rho_idx - 1\\n else:\\n prev_rho_idx = rho_idx + 1\\n prev_rho_patch = patch_grid[(mu_idx, prev_rho_idx)]\\n rho_start_plane = prev_rho_patch.rho_end_plane\\n if rho_idx > 0:\\n rho_end_plane = optics.arcplane.ArcPlane(rho=angle_step * (rho_idx+1))\\n else:\\n rho_end_plane = optics.arcplane.ArcPlane(rho=angle_step * rho_idx)\\n else:\\n rho_start_plane = optics.arcplane.ArcPlane(rho=0.0)\\n rho_end_plane = optics.arcplane.ArcPlane(rho=angle_step)\\n prev_patches = [patch for patch in (prev_mu_patch, prev_rho_patch) if patch != None]\\n \\n #figure out the screen and shell point\\n shell_point = get_shell_point(prev_patches, mu_start_plane.angle, rho_start_plane.angle)\\n screen_point = get_focal_point(prev_patches, shell_point)\\n \\n return optics.patch.create_patch(\\n shell_point,\\n screen_point,\\n mu_start_plane,\\n mu_end_plane,\\n rho_start_plane,\\n rho_end_plane,\\n prev_mu_patch,\\n prev_rho_patch\\n )\\n \\n def on_patch_completed(patch):\\n \\\"\\\"\\\"\\n Figures out which new patch requests to create and add to the list of requests\\n \\\"\\\"\\\"\\n on_new_patch(patch)\\n all_patches.append(patch)\\n \\n #stick them into a grid (because we need to know when adjacent ones have been enabled)\\n (mu, rho) = grid_index(patch)\\n patch_grid[(mu, rho)] = patch\\n for offset_mu, offset_rho in (\\n ( 1, 1),\\n ( 1, -1),\\n (-1, -1),\\n (-1, 1),\\n ):\\n if (mu+offset_mu, rho+offset_rho) not in patch_grid:\\n if (mu+offset_mu, rho) in patch_grid and (mu, rho+offset_rho) in patch_grid:\\n patch_requests.append((mu+offset_mu, rho+offset_rho))\\n \\n #enable horizontal and vertical arcs\\n if patch.mu_start_plane.angle == 0.0 and math.fabs(patch.mu_start_plane.angle) < max_angle:\\n if (mu, rho-1) not in patch_grid:\\n patch_requests.append((mu, rho-1))\\n if (mu, rho+1) not in patch_grid:\\n patch_requests.append((mu, rho+1))\\n if patch.rho_start_plane.angle == 0.0 and math.fabs(patch.rho_start_plane.angle) < max_angle:\\n if (mu-1, rho) not in patch_grid:\\n patch_requests.append((mu-1, rho))\\n if (mu+1, rho) not in patch_grid:\\n patch_requests.append((mu+1, rho))\\n\\n #start off the process with the first patch\\n central_patch = _create_patch_for_index((0.0, 0.0))\\n on_patch_completed(central_patch)\\n \\n #continuously process new patches while there are any remaining requests\\n while len(patch_requests) > 0:\\n request = patch_requests.pop(0)\\n on_patch_completed(_create_patch_for_index(request))\\n \\n return all_patches\",\n \"def make_nsided(edges, continuity=\\\"C0\\\", points=None):\\n fill = BRepFill_Filling()\\n\\n # A helper function to convert strings to Geom_Abs_ enums\\n def str_to_continuity(string):\\n if string == \\\"C0\\\":\\n return GeomAbs_C0\\n elif string == \\\"C1\\\":\\n return GeomAbs_C1\\n elif string == \\\"G1\\\":\\n return GeomAbs_G1\\n elif string == \\\"C2\\\":\\n return GeomAbs_C2\\n elif string == \\\"G2\\\":\\n return GeomAbs_G2\\n elif string == \\\"C3\\\":\\n return GeomAbs_C3\\n\\n if isinstance(continuity, str):\\n assert continuity in (\\\"C0\\\", \\\"C1\\\", \\\"C2\\\")\\n occ_continuity = str_to_continuity(continuity)\\n for edg in edges:\\n fill.Add(edg.topods_shape(), occ_continuity)\\n elif isinstance(continuity, list):\\n assert len(edges) == len(continuity), \\\"Continuity should be provided for each edge\\\"\\n for edg, cont in zip(edges, continuity):\\n occ_cont = str_to_continuity(cont)\\n fill.Add(edg.topods_shape(), occ_cont)\\n\\n # Add points to contrain shape if provided\\n if points:\\n for pt in points:\\n fill.Add(geom_utils.to_gp_pnt(pt))\\n fill.Build()\\n face = fill.Face()\\n return Face(face)\",\n \"def walls_cc(lenght, width, wall_height=3, roof_height=4):\\n a = min(0.1*lenght, 0.1*width, 0.4*(wall_height+0.5*roof_height))\\n trian = 0.5*width*roof_height\\n trian_5 = 0.5*a*a*(wall_height/roof_height)\\n # trian_4 = trian - 2*trian_5\\n\\n area = (lenght + width)*2*wall_height + 2*trian\\n area_5 = 8*a*wall_height + 4*trian_5\\n area_4 = area - area_5\\n\\n return area, area_4, area_5\",\n \"def test_400_swift_backed_image_create(self):\\n u.log.debug('Checking swift objects and containers with a '\\n 'swift-backed glance image...')\\n\\n # Create swift-backed glance image\\n img_new = u.create_cirros_image(self.glance, \\\"cirros-image-1\\\")\\n img_id = img_new.id\\n img_md5 = img_new.checksum\\n img_size = img_new.size\\n\\n # Validate that swift object's checksum/size match that from glance\\n headers, containers = self.swift.get_account()\\n if len(containers) != 1:\\n msg = \\\"Expected 1 swift container, found {}\\\".format(\\n len(containers))\\n amulet.raise_status(amulet.FAIL, msg=msg)\\n\\n container_name = containers[0].get('name')\\n\\n headers, objects = self.swift.get_container(container_name)\\n if len(objects) != 1:\\n msg = \\\"Expected 1 swift object, found {}\\\".format(len(objects))\\n amulet.raise_status(amulet.FAIL, msg=msg)\\n\\n swift_object_size = objects[0].get('bytes')\\n swift_object_md5 = objects[0].get('hash')\\n\\n if img_size != swift_object_size:\\n msg = \\\"Glance image size {} != swift object size {}\\\".format(\\n img_size, swift_object_size)\\n amulet.raise_status(amulet.FAIL, msg=msg)\\n\\n if img_md5 != swift_object_md5:\\n msg = \\\"Glance image hash {} != swift object hash {}\\\".format(\\n img_md5, swift_object_md5)\\n amulet.raise_status(amulet.FAIL, msg=msg)\\n\\n # Cleanup\\n u.delete_resource(self.glance.images, img_id, msg=\\\"glance image\\\")\\n u.log.info('OK')\",\n \"def calculate_shape(self):\\n\\n # error handling\\n if self.radius <= 0: raise ValueError(\\\"Radius must be positive.\\\")\\n if self.inner_radius < 0: raise ValueError(\\\"Inner radius must not be negative\\\")\\n if self.inner_radius > self.radius: raise ValueError(\\\"Inner radius must be smaller than radius\\\")\\n if self.thickness <= 0: raise ValueError(\\\"Thickness must be positive\\\")\\n\\n self.area = pi * self.radius ** 2\\n self.area -= pi * self.inner_radius ** 2\\n\\n self.volume = self.area * self.thickness\",\n \"def smear_coolant_wirewrap(info):\\n height = info[0]\\n fuel_radius = info[1] / 2\\n wirewrap_radius = info[2] / 2\\n wire_wrap_axial_pitch = info[3]\\n fuel_pitch = info[4]\\n coolant_material = info[5]\\n clad_material = info[6]\\n fuel_volume = utilities.get_cylinder_volume(fuel_radius, height)\\n wire_wrap_volume = utilities.get_toroidal_volume(fuel_radius, wirewrap_radius, wire_wrap_axial_pitch, height)\\n pin_hexagonal_universe_volume = utilities.get_hexagonal_prism_volume(fuel_pitch, height)\\n coolant_volume = pin_hexagonal_universe_volume - fuel_volume - wire_wrap_volume\\n total_coolant_wire_wrap_volume = coolant_volume + wire_wrap_volume\\n wire_wrap_volume_percent = wire_wrap_volume / total_coolant_wire_wrap_volume\\n coolant_volume_percent = coolant_volume / total_coolant_wire_wrap_volume\\n smeared_material_dict = {clad_material: wire_wrap_volume_percent, coolant_material: coolant_volume_percent}\\n return smeared_material_dict\",\n \"def test_create_polygon_with_bad_poly_data_fails(self, api_client):\\n url = self.base_url + \\\"/polygons/\\\"\\n prov = baker.make(Provider)\\n data = {\\n \\\"name\\\": \\\"NRB\\\",\\n \\\"price\\\": 930,\\n \\\"provider\\\": prov.id,\\n \\\"poly\\\": \\\"-98.503358 -29.335668, -98.503086 29.335668, -98.503086 29.335423, -98.503358 29.335423, -98.503358 29.335668\\\" # noqa\\n }\\n response = api_client().post(url, data)\\n assert response.status_code == 400\\n assert 'Points of LinearRing do not form a closed linestring.' in response.data['poly']\",\n \"def cmd_cb():\\n cmds = []\\n #cmds.append(\\\"r_m[0.0,-1,1]\\\")\\n cmds.append(\\\"r_m[0.0]\\\")\\n cmds.append('r_a[1.7,0,10]')\\n cmds.append('r_n[1.5,0,10]')\\n cmds.append(\\\"r_s[2.5,0,10]\\\")\\n cmds.append('RooCBShape::res(x,r_m,r_s,r_a,r_n)')\\n return cmds\",\n \"def stokes_right_circular():\\n return np.array([1, 0, 0, 1])\",\n \"def oss_stacked(block, cut, laser):\\r\\n\\tx0_1, x1_1, z0_1, taper_x_1, taper_y_1, layers_1, pyramid_angle_1 = oss_helper(block, cut, laser, cut[\\\"final_dimension_x\\\"]/2)\\r\\n\\tx0_2, x1_2, z0_2, taper_x_2, taper_y_2, layers_2, pyramid_angle_2 = oss_helper(block, cut, laser, cut[\\\"final_dimension_y\\\"]/2)\\r\\n\\tangle = math.radians(laser[\\\"kerf_angle\\\"]/2)\\r\\n\\tgap = math.tan(pyramid_angle_1) * (cut[\\\"final_dimension_x\\\"]/2) + cut[\\\"gap_size\\\"]\\r\\n\\tunit_length = gap + cut[\\\"base_height\\\"]\\r\\n\\tmax_slices = math.floor(block[\\\"thickness\\\"]/unit_length)\\r\\n\\ttaper_straight = math.tan(angle)*(laser[\\\"z_spacing\\\"])\\r\\n\\r\\n\\tif cut[\\\"core\\\"] == \\\"yes\\\":\\r\\n\\t\\tcutlist = json.loads(vertical_core(block,cut,laser))\\r\\n\\t\\tcutlist.pop()\\r\\n\\t\\tcutlist.pop(0)\\r\\n\\telse:\\r\\n\\t\\tcutlist = []\\r\\n\\r\\n\\ta0 = -(90 + math.degrees(angle))\\r\\n\\r\\n\\tz_shift = (cut[\\\"base_height\\\"] + gap) * math.sin(angle)\\r\\n\\tx_shift = (cut[\\\"base_height\\\"] + gap) * math.cos(angle)\\r\\n\\r\\n\\tx_delta = math.sin(angle) * block[\\\"origin_x\\\"]\\r\\n\\ty_delta = math.sin(angle) * block[\\\"origin_y\\\"]\\r\\n\\tz1_delta = math.cos(angle) * block[\\\"origin_x\\\"]\\r\\n\\tz2_delta = math.cos(angle) * block[\\\"origin_y\\\"]\\r\\n\\r\\n\\tcutlist.append([\\\"a_abs\\\",f\\\"{a0:.6f}\\\"])\\r\\n\\tcutlist.append([\\\"c_abs\\\",str(block[\\\"physical_rotation\\\"])])\\r\\n\\tcutlist.append([\\\"z_abs\\\",str(z0_1 + z2_delta)])\\r\\n\\r\\n\\tif pyramid_angle_1 >= angle and pyramid_angle_2 >= angle:\\r\\n\\r\\n\\t\\tif cut[\\\"num_of_seeds\\\"] == \\\"max\\\":\\r\\n\\t\\t\\tnum_slices = max_slices\\r\\n\\t\\telse:\\r\\n\\t\\t\\tnum_slices = cut[\\\"num_of_seeds\\\"] + 1\\r\\n\\t\\t\\r\\n\\t\\tfor i in range(num_slices):\\r\\n\\t\\t\\tcutlist = (cutlist\\r\\n\\t\\t\\t\\t\\t\\t + pyramid_slice(cut[\\\"final_dimension_y\\\"]/2 - block[\\\"origin_x\\\"],x0_1 + y_delta,-cut[\\\"final_dimension_y\\\"]/2 - block[\\\"origin_x\\\"],x1_1 + y_delta,z0_1 + block[\\\"origin_y\\\"],laser[\\\"xy_spacing\\\"], laser[\\\"z_spacing\\\"], taper_x_1,taper_y_1,taper_straight,layers_1)\\r\\n\\t\\t\\t\\t\\t\\t + [[\\\"z_abs\\\",str(z0_2 + z1_delta)]] + [[\\\"c_abs\\\",\\\"90\\\"]]\\r\\n\\t\\t\\t\\t\\t\\t + pyramid_slice(cut[\\\"final_dimension_x\\\"]/2 + block[\\\"origin_y\\\"],x0_2 + x_delta,-cut[\\\"final_dimension_x\\\"]/2 + block[\\\"origin_y\\\"],x1_2 + x_delta,z0_2 + block[\\\"origin_x\\\"],laser[\\\"xy_spacing\\\"], laser[\\\"z_spacing\\\"], taper_x_2,taper_y_2,taper_straight,layers_2)\\r\\n\\t\\t\\t\\t\\t\\t + [[\\\"z_abs\\\",str(z0_1 - z2_delta)]] + [[\\\"c_abs\\\",\\\"180\\\"]]\\r\\n\\t\\t\\t\\t\\t\\t + pyramid_slice(cut[\\\"final_dimension_y\\\"]/2 + block[\\\"origin_x\\\"],x0_1 - y_delta,-cut[\\\"final_dimension_y\\\"]/2 + block[\\\"origin_x\\\"],x1_1 - y_delta,z0_1 - block[\\\"origin_y\\\"],laser[\\\"xy_spacing\\\"], laser[\\\"z_spacing\\\"], taper_x_1,taper_y_1,taper_straight,layers_1)\\r\\n\\t\\t\\t\\t\\t\\t + [[\\\"z_abs\\\",str(z0_2 - z1_delta)]] + [[\\\"c_abs\\\",\\\"270\\\"]]\\r\\n\\t\\t\\t\\t\\t\\t + pyramid_slice(cut[\\\"final_dimension_x\\\"]/2 - block[\\\"origin_y\\\"],x0_2 - x_delta,-cut[\\\"final_dimension_x\\\"]/2 - block[\\\"origin_y\\\"],x1_2 - x_delta,z0_2 - block[\\\"origin_x\\\"],laser[\\\"xy_spacing\\\"], laser[\\\"z_spacing\\\"], taper_x_2,taper_y_2,taper_straight,layers_2)\\r\\n\\t\\t\\t\\t\\t\\t )\\r\\n\\t\\t\\tz0_1 = z0_1 + z_shift\\r\\n\\t\\t\\tz0_2 = z0_2 + z_shift\\r\\n\\t\\t\\tx0_1, x1_1, x0_2, x1_2 = x0_1 - x_shift, x1_1 - x_shift, x0_2 - x_shift, x1_2 - x_shift\\r\\n\\t\\t\\tcutlist.append([\\\"c_abs\\\",str(block[\\\"physical_rotation\\\"])])\\r\\n\\t\\t\\tcutlist.append([\\\"z_abs\\\",str(z0_1 + z2_delta)])\\t\\r\\n\\telse:\\r\\n\\t\\traise Exception(\\\"Pyramid angle too small\\\")\\r\\n\\r\\n\\tcutlist.insert(0, [\\\"set_trigger4\\\", \\\"1\\\", \\\"0\\\", \\\"7\\\", \\\"8\\\", \\\"45\\\"])\\r\\n\\tcutlist.append([\\\"stop_trigger\\\"])\\r\\n\\treturn json.dumps(cutlist)\",\n \"def test_QuadTreeStructureSingleRing(self):\\n ring_texas = Ring([\\n (-105.99835968, 31.3938179016), (-106.212753296, 31.4781284332), (-106.383041382, 31.7337627411),\\n (-106.538970947, 31.7861976624), (-106.614440918, 31.8177280426), (-106.615577698, 31.8446350098),\\n (-106.643531799, 31.8951015472), (-106.633201599, 31.9139976501), (-106.63205719, 31.9721183777),\\n (-106.649513245, 31.9802284241), (-106.623077393, 32.0009880066), (-106.377845764, 32.0006446838),\\n (-106.002708435, 32.0015525818), (-104.921798706, 32.0042686462), (-104.850563049, 32.0031509399),\\n (-104.018814087, 32.0072784424), (-103.980895996, 32.0058898926), (-103.728973389, 32.0061035156),\\n (-103.332092285, 32.0041542053), (-103.05796814, 32.0018997192), (-103.05519104, 32.0849952698),\\n (-103.059547424, 32.5154304504), (-103.048835754, 32.9535331726), (-103.042602539, 33.3777275085),\\n (-103.038238525, 33.5657424927), (-103.03276062, 33.8260879517), (-103.029144287, 34.3077430725),\\n (-103.022155762, 34.7452659607), (-103.024749756, 34.964717865), (-103.025650024, 35.1772079468),\\n (-103.02179718, 35.6236038208), (-103.022117615, 35.7422866821), (-103.02355957, 36.0560264587),\\n (-103.026802063, 36.4915657043), (-102.996917725, 36.4923439026), (-102.165222168, 36.4902076721),\\n (-102.034210205, 36.4929542542), (-101.620315552, 36.4920043945), (-101.089668274, 36.4880218506),\\n (-100.95690918, 36.4896087646), (-100.549415588, 36.4894485474), (-100.006866455, 36.4938774109),\\n (-100.001144409, 36.4925193787), (-99.9971542358, 36.0575485229), (-99.9977264404, 35.8837928772),\\n (-100.0, 35.6188087463), (-99.994354248, 35.424571991), (-99.9971847534, 35.182182312),\\n (-99.9960708618, 35.03099823), (-99.998878479, 34.7471847534), (-99.99609375, 34.5623207092),\\n (-99.9720993042, 34.5618629456), (-99.9447402954, 34.5795707703), (-99.9319076538, 34.5791091919),\\n (-99.8805999756, 34.5481758118), (-99.8605728149, 34.5186271667), (-99.8299331665, 34.5017776489),\\n (-99.7776870728, 34.4439926147), (-99.6849060059, 34.3774452209), (-99.6014480591, 34.3685569763),\\n (-99.5852203369, 34.3848571777), (-99.5778503418, 34.4089126587), (-99.5538635254, 34.4151802063),\\n (-99.5021362305, 34.4040679932), (-99.4794387817, 34.3835220337), (-99.4383773804, 34.3647041321),\\n (-99.4099578857, 34.3691062927), (-99.3941574097, 34.3967437744), (-99.392791748, 34.4289932251),\\n (-99.3642044067, 34.4501953125), (-99.3232955933, 34.4127082825), (-99.2671737671, 34.3982849121),\\n (-99.2541046143, 34.3682136536), (-99.2054901123, 34.331993103), (-99.1963043213, 34.3051223755),\\n (-99.2045974731, 34.255645752), (-99.1904830933, 34.2237358093), (-99.1761550903, 34.2127304077),\\n (-99.1279449463, 34.2014694214), (-99.0784301758, 34.2083587646), (-99.0352172852, 34.1989212036),\\n (-98.9961929321, 34.2094955444), (-98.952507019, 34.1945648193), (-98.8913421631, 34.1608200073),\\n (-98.8110656738, 34.1459350586), (-98.7785339355, 34.1319618225), (-98.705291748, 34.1307144165),\\n (-98.6822128296, 34.1499977112), (-98.6617202759, 34.1470375061), (-98.6259918213, 34.1584358215),\\n (-98.6072463989, 34.1513977051), (-98.5763320923, 34.1419296265), (-98.5575790405, 34.1053352356),\\n (-98.4995193481, 34.0664138794), (-98.4481887817, 34.0543746948), (-98.4213409424, 34.0658302307),\\n (-98.4071350098, 34.0824546814), (-98.390953064, 34.0872306824), (-98.3842544556, 34.1157798767),\\n (-98.350402832, 34.1421203613), (-98.3204879761, 34.1394195557), (-98.2770004272, 34.1228713989),\\n (-98.1728439331, 34.1153678894), (-98.1368637085, 34.1384315491), (-98.1148681641, 34.1489868164),\\n (-98.0941238403, 34.1345558167), (-98.1106872559, 34.0698204041), (-98.0862045288, 34.0053138733),\\n (-98.055557251, 33.9897994995), (-98.0234909058, 33.9869842529), (-97.9826812744, 34.001285553),\\n (-97.9502258301, 33.9711608887), (-97.9477539062, 33.9597511292), (-97.9629974365, 33.9486503601),\\n (-97.9506835938, 33.9325180054), (-97.9761276245, 33.9120521545), (-97.9763793945, 33.9025039673),\\n (-97.9547348022, 33.883480072), (-97.9090652466, 33.8740234375), (-97.8697509766, 33.8551139832),\\n (-97.8525466919, 33.8570709229), (-97.7902069092, 33.8904571533), (-97.756362915, 33.9320983887),\\n (-97.729019165, 33.9392929077), (-97.7042617798, 33.9715461731), (-97.6710662842, 33.9886131287),\\n (-97.6001815796, 33.9694366455), (-97.5923538208, 33.9178848267), (-97.575668335, 33.9025306702),\\n (-97.5545883179, 33.9039039612), (-97.5182037354, 33.9167709351), (-97.4775314331, 33.9077072144),\\n (-97.4627609253, 33.902381897), (-97.4570617676, 33.8904304504), (-97.4527359009, 33.8362121582),\\n (-97.410118103, 33.8207092285), (-97.363319397, 33.8310241699), (-97.3418045044, 33.8619155884),\\n (-97.314956665, 33.8703918457), (-97.3140869141, 33.8958396912), (-97.272277832, 33.8725738525),\\n (-97.2639083862, 33.8587303162), (-97.2506866455, 33.8729705811), (-97.2460632324, 33.8942375183),\\n (-97.2113342285, 33.9056892395), (-97.1877670288, 33.8992042542), (-97.1641693115, 33.8631477356),\\n (-97.1685943604, 33.8477935791), (-97.1950149536, 33.8361587524), (-97.2083206177, 33.8196487427),\\n (-97.189163208, 33.7527694702), (-97.1524734497, 33.7286682129), (-97.115562439, 33.725933075),\\n (-97.0904998779, 33.7316703796), (-97.0834655762, 33.7424125671), (-97.0876693726, 33.8075714111),\\n (-97.0500259399, 33.8234481812), (-97.0782470703, 33.8378105164), (-97.0821762085, 33.8511009216),\\n (-97.0708999634, 33.8567276001), (-97.0255966187, 33.8405609131), (-97.0058517456, 33.8505134583),\\n (-96.9877090454, 33.8764228821), (-96.9878616333, 33.9442024231), (-96.9681854248, 33.9373207092),\\n (-96.9362030029, 33.9478492737), (-96.9295654297, 33.9617729187), (-96.8984527588, 33.9500274658),\\n (-96.882850647, 33.9245910645), (-96.8789367676, 33.8840026855), (-96.8610153198, 33.8616790771),\\n (-96.8440093994, 33.8580322266), (-96.8141174316, 33.8717689514), (-96.7975921631, 33.8699493408),\\n (-96.7488250732, 33.8317375183), (-96.7116775513, 33.8338699341), (-96.6933822632, 33.8479042053),\\n (-96.6777038574, 33.9043235779), (-96.6662368774, 33.9135437012), (-96.584487915, 33.8961448669),\\n (-96.6141662598, 33.8628997803), (-96.6011962891, 33.842956543), (-96.5621337891, 33.8254203796),\\n (-96.5105743408, 33.8156852722), (-96.5007476807, 33.7880897522), (-96.4873733521, 33.7781295776),\\n (-96.4194641113, 33.7883262634), (-96.3708190918, 33.7403945923), (-96.3475875854, 33.7055282593),\\n (-96.3162765503, 33.7018013), (-96.3007888794, 33.714050293), (-96.289680481, 33.761932373),\\n (-96.2780761719, 33.7733879089), (-96.2125473022, 33.756690979), (-96.1870269775, 33.7585830688),\\n (-96.1688156128, 33.7693557739), (-96.161315918, 33.7982292175), (-96.141418457, 33.8203201294),\\n (-96.1545181274, 33.8239440918), (-96.1807250977, 33.8084335327), (-96.1831283569, 33.8157920837),\\n (-96.1692047119, 33.8289833069), (-96.1489639282, 33.8355903625), (-96.1094436646, 33.8292579651),\\n (-96.0915222168, 33.8445777893), (-96.0479736328, 33.8412780762), (-96.0267486572, 33.8560218811),\\n (-96.0140686035, 33.8442077637), (-96.0017929077, 33.8569793701), (-96.0026168823, 33.8733901978),\\n (-95.9942092896, 33.875377655), (-95.977394104, 33.8579521179), (-95.9587631226, 33.8650398254),\\n (-95.943069458, 33.8899726868), (-95.9330749512, 33.8905296326), (-95.8465576172, 33.8410377502),\\n (-95.8259735107, 33.8430252075), (-95.7954788208, 33.8646736145), (-95.7685165405, 33.8514022827),\\n (-95.764251709, 33.8790054321), (-95.7606964111, 33.8934402466), (-95.7468643188, 33.9033966064),\\n (-95.6997070312, 33.8948249817), (-95.6334915161, 33.9201049805), (-95.6129837036, 33.9202384949),\\n (-95.6148300171, 33.9366912842), (-95.6060714722, 33.9445533752), (-95.5627746582, 33.9360733032),\\n (-95.5463180542, 33.9040336609), (-95.5195770264, 33.9066429138), (-95.5267333984, 33.8978157043),\\n (-95.547492981, 33.893157959), (-95.5440368652, 33.8857421875), (-95.5128860474, 33.8977355957),\\n (-95.4988555908, 33.8817176819), (-95.4681243896, 33.8864326477), (-95.4516067505, 33.8657531738),\\n (-95.330039978, 33.8709182739), (-95.336227417, 33.8971138), (-95.3019561768, 33.8866233826),\\n (-95.2864303589, 33.8869018555), (-95.2773513794, 33.9179382324), (-95.2636184692, 33.8978004456),\\n (-95.2509918213, 33.9050216675), (-95.2512893677, 33.9364433289), (-95.2340393066, 33.9648628235),\\n (-95.1483154297, 33.9435462952), (-95.1279678345, 33.9408683777), (-95.1266784668, 33.9171447754),\\n (-95.1192245483, 33.9122810364), (-95.0953598022, 33.9217376709), (-95.0822677612, 33.9184532166),\\n (-95.0897140503, 33.8969154358), (-95.0836029053, 33.8884620667), (-95.0634765625, 33.9176483154),\\n (-95.0631408691, 33.8966941833), (-95.0428619385, 33.8844451904), (-95.037361145, 33.8664512634),\\n (-95.0127716064, 33.8699455261), (-94.9892807007, 33.8561820984), (-94.9687042236, 33.8662147522),\\n (-94.9599075317, 33.8480758667), (-94.9398880005, 33.8408241272), (-94.9403991699, 33.8158073425),\\n (-94.9182357788, 33.8161964417), (-94.9085464478, 33.803478241), (-94.9138793945, 33.7895965576),\\n (-94.8816375732, 33.7749633789), (-94.8578796387, 33.7493209839), (-94.8191604614, 33.7494049072),\\n (-94.8032226562, 33.7395820618), (-94.7835083008, 33.7532615662), (-94.764175415, 33.7528419495),\\n (-94.7820281982, 33.7422676086), (-94.7831573486, 33.7336654663), (-94.7497711182, 33.73670578),\\n (-94.7627182007, 33.716796875), (-94.7421112061, 33.7190475464), (-94.7544784546, 33.7077713013),\\n (-94.7416534424, 33.7012672424), (-94.6909866333, 33.6902885437), (-94.6684570312, 33.6965370178),\\n (-94.6554794312, 33.6922912598), (-94.6443252563, 33.6776504517), (-94.6679534912, 33.671459198),\\n (-94.6694259644, 33.6660614014), (-94.6585388184, 33.6637382507), (-94.6387634277, 33.6701049805),\\n (-94.6317367554, 33.6838989258), (-94.600944519, 33.6656074524), (-94.585105896, 33.678981781),\\n (-94.5785064697, 33.6704711914), (-94.5607223511, 33.671913147), (-94.5652084351, 33.6630134583),\\n (-94.5851593018, 33.6621322632), (-94.5883865356, 33.6554489136), (-94.576461792, 33.6521568298),\\n (-94.5454177856, 33.6616210938), (-94.5419311523, 33.6482467651), (-94.5621948242, 33.642829895),\\n (-94.5621490479, 33.6355361938), (-94.5501937866, 33.6326942444), (-94.5179901123, 33.6430091858),\\n (-94.5250549316, 33.6210212708), (-94.510559082, 33.6308097839), (-94.5006103516, 33.623046875),\\n (-94.4764862061, 33.6319656372), (-94.4359130859, 33.6364440918), (-94.4363327026, 33.6168441772),\\n (-94.4515533447, 33.604347229), (-94.4433288574, 33.5965042114), (-94.4284667969, 33.5971412659),\\n (-94.4065704346, 33.5734863281), (-94.3934173584, 33.5749588013), (-94.3791122437, 33.5933265686),\\n (-94.3706283569, 33.5900421143), (-94.3723068237, 33.5726623535), (-94.3952636719, 33.5603027344),\\n (-94.3707580566, 33.5476837158), (-94.3287506104, 33.573135376), (-94.3023834229, 33.5569343567),\\n (-94.2988204956, 33.5798530579), (-94.2789840698, 33.5893325806), (-94.2720794678, 33.5846061707),\\n (-94.2745437622, 33.5617370605), (-94.2372360229, 33.5924224854), (-94.2230377197, 33.5857200623),\\n (-94.2353668213, 33.5615348816), (-94.2108840942, 33.5579872131), (-94.2053451538, 33.5850791931),\\n (-94.1595153809, 33.5937728882), (-94.155166626, 33.5670852661), (-94.0987014771, 33.5729980469),\\n (-94.0866546631, 33.5839538574), (-94.0614318848, 33.5772132874), (-94.0359268188, 33.5559120178),\\n (-94.0365066528, 33.270324707), (-94.0387496948, 33.0232887268), (-94.0416030884, 32.8823471069),\\n (-94.0401992798, 32.6948127747), (-94.0352325439, 32.3892250061), (-94.0347671509, 32.1994476318),\\n (-94.0350646973, 31.994512558), (-94.0098876953, 31.9891338348), (-94.0043945312, 31.9779415131),\\n (-93.9772109985, 31.9461593628), (-93.9699859619, 31.9231643677), (-93.9357299805, 31.9094562531),\\n (-93.9179229736, 31.909702301), (-93.9234619141, 31.8925933838), (-93.8992614746, 31.8944549561),\\n (-93.8925247192, 31.8700656891), (-93.8812637329, 31.8714199066), (-93.8774032593, 31.850112915),\\n (-93.8648223877, 31.8172721863), (-93.8343276978, 31.8020172119), (-93.8220672607, 31.7746372223),\\n (-93.831161499, 31.7532806396), (-93.8099899292, 31.7303524017), (-93.8149490356, 31.7123508453),\\n (-93.8087692261, 31.7075653076), (-93.7922668457, 31.7113952637), (-93.8118438721, 31.6745662689),\\n (-93.806427002, 31.6537666321), (-93.8147277832, 31.6479663849), (-93.8195877075, 31.6180915833),\\n (-93.8355789185, 31.6151885986), (-93.8326187134, 31.5901832581), (-93.8163223267, 31.5771102905),\\n (-93.8105163574, 31.5590629578), (-93.780128479, 31.5337352753), (-93.7633056641, 31.5307235718),\\n (-93.747543335, 31.5377178192), (-93.7316589355, 31.5218772888), (-93.7057952881, 31.5205688477),\\n (-93.7189941406, 31.4954032898), (-93.7504348755, 31.4905567169), (-93.7512435913, 31.4855003357),\\n (-93.7267837524, 31.4594745636), (-93.6984176636, 31.4614582062), (-93.7019271851, 31.4462509155),\\n (-93.6870040894, 31.4381313324), (-93.6961288452, 31.4277362823), (-93.694442749, 31.4159221649),\\n (-93.6874923706, 31.406129837), (-93.6640167236, 31.3983287811), (-93.6610717773, 31.3723945618),\\n (-93.6348571777, 31.3738269806), (-93.6770401001, 31.3283863068), (-93.6815872192, 31.3126792908),\\n (-93.6561279297, 31.2866706848), (-93.6455917358, 31.2902622223), (-93.6308288574, 31.2739028931),\\n (-93.6164550781, 31.2758045197), (-93.6118774414, 31.2700328827), (-93.611000061, 31.2421875),\\n (-93.5905456543, 31.2296867371), (-93.6029205322, 31.1990661621), (-93.5939407349, 31.1801986694),\\n (-93.5769424438, 31.1721401215), (-93.5505905151, 31.1909294128), (-93.5289230347, 31.1857738495),\\n (-93.5269317627, 31.1780757904), (-93.5370178223, 31.1763401031), (-93.5283279419, 31.1629428864),\\n (-93.5441894531, 31.1591663361), (-93.5375061035, 31.132440567), (-93.5280914307, 31.1259250641),\\n (-93.5350875854, 31.116071701), (-93.556678772, 31.1093425751), (-93.5599822998, 31.1005363464),\\n (-93.5431213379, 31.094751358), (-93.5441055298, 31.0823726654), (-93.516998291, 31.0746707916),\\n (-93.5257415771, 31.0569801331), (-93.5072174072, 31.0389080048), (-93.5471191406, 31.0141410828),\\n (-93.5649414062, 31.0180625916), (-93.5678939819, 31.0129241943), (-93.5708465576, 30.9972705841),\\n (-93.5609512329, 30.991689682), (-93.5724563599, 30.9761772156), (-93.5486755371, 30.9701900482),\\n (-93.5373382568, 30.9568843842), (-93.5321884155, 30.9607315063), (-93.5256195068, 30.9358196259),\\n (-93.5299835205, 30.9269714355), (-93.549621582, 30.9248847961), (-93.5465164185, 30.9053344727),\\n (-93.5644760132, 30.9019317627), (-93.5684967041, 30.8862342834), (-93.5608444214, 30.8718795776),\\n (-93.5528030396, 30.8602828979), (-93.566444397, 30.8451480865), (-93.5556411743, 30.8423423767),\\n (-93.5506820679, 30.8283443451), (-93.5818710327, 30.8020401001), (-93.5851745605, 30.7721843719),\\n (-93.6184539795, 30.7457885742), (-93.6076507568, 30.7320098877), (-93.6177902222, 30.73254776),\\n (-93.612411499, 30.7103290558), (-93.6176071167, 30.6868019104), (-93.6599884033, 30.6728591919),\\n (-93.6779708862, 30.6396923065), (-93.6928787231, 30.6400413513), (-93.6845855713, 30.62342453),\\n (-93.6926956177, 30.6157951355), (-93.671585083, 30.5978317261), (-93.6934204102, 30.5988349915),\\n (-93.7178115845, 30.5873794556), (-93.717880249, 30.5681533813), (-93.7353057861, 30.5455169678),\\n (-93.7054595947, 30.522857666), (-93.7146377563, 30.5051136017), (-93.7072753906, 30.4962406158),\\n (-93.7148513794, 30.4886283875), (-93.6979751587, 30.4700469971), (-93.7034225464, 30.46251297),\\n (-93.6965713501, 30.4426326752), (-93.721534729, 30.4329795837), (-93.7425613403, 30.4088230133),\\n (-93.7549438477, 30.3817882538), (-93.747833252, 30.3674106598), (-93.7593383789, 30.35414505),\\n (-93.7591781616, 30.3408718109), (-93.7297744751, 30.3049163818), (-93.6992111206, 30.2973880768),\\n (-93.707359314, 30.2393722534), (-93.71484375, 30.2203063965), (-93.7043609619, 30.1808605194),\\n (-93.6961669922, 30.1756763458), (-93.6996612549, 30.1508083344), (-93.6831436157, 30.1482315063),\\n (-93.6859588623, 30.1412525177), (-93.698638916, 30.1412258148), (-93.6969223022, 30.1179294586),\\n (-93.7083816528, 30.1147403717), (-93.7158584595, 30.0956687927), (-93.7124786377, 30.0605201721),\\n (-93.7602005005, 30.0059642792), (-93.8572769165, 29.9906539917), (-93.8563308716, 29.9646015167),\\n (-93.9517669678, 29.8183631897), (-93.8349609375, 29.6745700836), (-94.0654067993, 29.6740760803),\\n (-94.3569946289, 29.5599002838), (-94.3770065308, 29.5519695282), (-94.6825180054, 29.4329051971),\\n (-94.7665481567, 29.363992691), (-94.7852478027, 29.3832607269), (-94.6819152832, 29.4751110077),\\n (-94.5726928711, 29.5330524445), (-94.5012817383, 29.5175228119), (-94.4697952271, 29.5567798615),\\n (-94.5108108521, 29.5451469421), (-94.5336990356, 29.5539836884), (-94.5644378662, 29.5789985657),\\n (-94.7880859375, 29.5385570526), (-94.7064208984, 29.6585159302), (-94.7002792358, 29.7545681),\\n (-94.7357254028, 29.7929859161), (-94.8294143677, 29.7598571777), (-94.8871612549, 29.6685390472),\\n (-94.9325866699, 29.6822090149), (-95.0882644653, 29.8039798737), (-95.040397644, 29.7115783691),\\n (-94.9893341064, 29.6797008514), (-95.0141220093, 29.5592651367), (-94.9111557007, 29.500333786),\\n (-94.9828109741, 29.46052742), (-94.9437561035, 29.4646816254), (-94.952507019, 29.4242343903),\\n (-94.913444519, 29.4201126099), (-94.9169921875, 29.4478225708), (-94.8911361694, 29.3993244171),\\n (-94.8153533936, 29.3709316254), (-94.8914718628, 29.3938312531), (-94.8987884521, 29.3087749481),\\n (-94.951133728, 29.3259220123), (-95.066368103, 29.1958770752), (-95.1605224609, 29.2000312805),\\n (-95.1647796631, 29.1175479889), (-95.1973419189, 29.105222702), (-95.2484054565, 28.9783916473),\\n (-95.5265808105, 28.8032417297), (-95.6830291748, 28.7269535065), (-95.6713180542, 28.7526817322),\\n (-95.7863540649, 28.7388706207), (-95.9373092651, 28.690454483), (-95.9561462402, 28.6226730347),\\n (-95.7021484375, 28.7189865112), (-96.2065811157, 28.4883861542), (-95.991645813, 28.5964241028),\\n (-95.9837493896, 28.6531333923), (-96.2375869751, 28.5713214874), (-96.2390289307, 28.5971164703),\\n (-96.1574707031, 28.6112308502), (-96.2404556274, 28.6348590851), (-96.1510620117, 28.7626724243),\\n (-96.2121734619, 28.6867198944), (-96.2859725952, 28.6617240906), (-96.2703781128, 28.7089805603),\\n (-96.3261566162, 28.6340885162), (-96.3641586304, 28.617980957), (-96.3917770386, 28.6702518463),\\n (-96.3927307129, 28.7260284424), (-96.4270858765, 28.7120132446), (-96.4496765137, 28.7550354004),\\n (-96.432258606, 28.6972484589), (-96.4033966064, 28.719493866), (-96.4187850952, 28.6386642456),\\n (-96.3753967285, 28.6100883484), (-96.4912033081, 28.5569438934), (-96.4371566772, 28.5969905853),\\n (-96.4543838501, 28.6559333801), (-96.4832687378, 28.5980548859), (-96.5118942261, 28.6081809998),\\n (-96.5117340088, 28.6495418549), (-96.5703964233, 28.6362667084), (-96.5705566406, 28.6918411255),\\n (-96.5722122192, 28.8081741333), (-96.5764846802, 28.6906890869), (-96.5914993286, 28.7173595428),\\n (-96.6465148926, 28.7141418457), (-96.6600112915, 28.6790752411), (-96.6067047119, 28.6236343384),\\n (-96.6103439331, 28.5589408875), (-96.5667037964, 28.574098587), (-96.486579895, 28.5062217712),\\n (-96.5631942749, 28.4696273804), (-96.5185012817, 28.4608268738), (-96.4765014648, 28.4994544983),\\n (-96.3907241821, 28.4340591431), (-96.6613082886, 28.30626297), (-96.7023620605, 28.3401966095),\\n (-96.7038116455, 28.3958854675), (-96.7407684326, 28.4034576416), (-96.7870941162, 28.4775066376),\\n (-96.8238754272, 28.449640274), (-96.7883377075, 28.4462547302), (-96.7591018677, 28.4109115601),\\n (-96.7753601074, 28.3916301727), (-96.8534927368, 28.4049968719), (-96.788230896, 28.3524703979),\\n (-96.7862701416, 28.3128585815), (-96.7933349609, 28.2713718414), (-96.7779312134, 28.2293491364),\\n (-96.8036880493, 28.2114467621), (-96.9509048462, 28.1143550873), (-96.9127197266, 28.2567977905),\\n (-96.9753036499, 28.2107505798), (-96.9410705566, 28.1867713928), (-96.9751052856, 28.1150455475),\\n (-97.0336151123, 28.1373977661), (-97.0235671997, 28.1997966766), (-97.1318359375, 28.1304264069),\\n (-97.1354141235, 28.1618099213), (-97.1679916382, 28.1594600677), (-97.1570587158, 28.1163806915),\\n (-97.2602844238, 28.0647239685), (-97.2412338257, 28.0486526489), (-97.2702941895, 28.025932312),\\n (-97.2362136841, 28.0405197144), (-97.1230773926, 28.054265976), (-97.0264053345, 28.107749939),\\n (-97.0238037109, 28.020236969), (-97.1146240234, 27.9153862), (-97.1954650879, 27.8122196198),\\n (-97.2470245361, 27.8223190308), (-97.2133407593, 27.8311100006), (-97.2834854126, 27.8711452484),\\n (-97.3610458374, 27.8399543762), (-97.3456192017, 27.8731784821), (-97.4793548584, 27.8529624939),\\n (-97.4966812134, 27.8754692078), (-97.521697998, 27.8636264801), (-97.4995346069, 27.8432426453),\\n (-97.4798126221, 27.8202819824), (-97.3885421753, 27.8314266205), (-97.3965606689, 27.7708396912),\\n (-97.3177947998, 27.7122249603), (-97.3495101929, 27.7153282166), (-97.3200149536, 27.6906337738),\\n (-97.3533630371, 27.6408004761), (-97.3992156982, 27.6331863403), (-97.3475036621, 27.631439209),\\n (-97.309211731, 27.707862854), (-97.2497940063, 27.6888313293), (-97.3314590454, 27.5623207092),\\n (-97.4122619629, 27.321023941), (-97.5004348755, 27.3196678162), (-97.5075378418, 27.4392147064),\\n (-97.5283813477, 27.3441009521), (-97.600112915, 27.3001346588), (-97.7500762939, 27.4196662903),\\n (-97.6800079346, 27.2943725586), (-97.7847442627, 27.2877197266), (-97.5481567383, 27.2302074432),\\n (-97.4272155762, 27.2651329041), (-97.5035018921, 27.0815410614), (-97.4789962769, 26.9965076447),\\n (-97.5685653687, 26.9778575897), (-97.558052063, 26.8460521698), (-97.4955749512, 26.7937812805),\\n (-97.4516983032, 26.6009845734), (-97.4258575439, 26.5182247162), (-97.4747085571, 26.4768047333),\\n (-97.4211883545, 26.3850593567), (-97.3686981201, 26.3590602875), (-97.3533630371, 26.1824493408),\\n (-97.2531204224, 26.068315506), (-97.2763214111, 26.0022754669), (-97.2130966187, 26.0090675354),\\n (-97.1722259521, 25.9545688629), (-97.307144165, 25.9651241302), (-97.30443573, 25.9386634827),\\n (-97.3809890747, 25.9170207977), (-97.3856430054, 25.8453617096), (-97.4343490601, 25.8451976776),\\n (-97.5900878906, 25.9332313538), (-97.5749359131, 25.9541721344), (-97.6129226685, 25.9620018005),\\n (-97.6479721069, 26.0234451294), (-97.8674316406, 26.0601406097), (-98.0400695801, 26.0593948364),\\n (-98.0763473511, 26.0346260071), (-98.0832138062, 26.0657577515), (-98.2006912231, 26.0553760529),\\n (-98.2919464111, 26.0981044769), (-98.2713546753, 26.1208953857), (-98.2922744751, 26.1328086853),\\n (-98.3279342651, 26.1116466522), (-98.3471908569, 26.1586799622), (-98.3845214844, 26.1560306549),\\n (-98.4533920288, 26.220911026), (-98.4885177612, 26.201543808), (-98.5999679565, 26.2604541779),\\n (-98.6779174805, 26.2420558929), (-98.8198318481, 26.3750705719), (-98.9088973999, 26.3603286743),\\n (-98.9392700195, 26.3953094482), (-99.1067276001, 26.4195308685), (-99.1014709473, 26.4883403778),\\n (-99.1686782837, 26.5457286835), (-99.1658172607, 26.5798892975), (-99.2855224609, 26.8573608398),\\n (-99.3905181885, 26.9466304779), (-99.3927154541, 26.9955501556), (-99.4550628662, 27.0286483765),\\n (-99.4371566772, 27.1991977692), (-99.4652709961, 27.2698841095), (-99.543586731, 27.3186531067),\\n (-99.4904937744, 27.4907550812), (-99.5267410278, 27.504283905), (-99.5491867065, 27.6126270294),\\n (-99.7144927979, 27.6615581512), (-99.8157272339, 27.7801074982), (-99.8747329712, 27.7976856232),\\n (-99.9418563843, 27.9868812561), (-99.993309021, 28.0034599304), (-100.096923828, 28.1542816162),\\n (-100.214073181, 28.2019348145), (-100.223464966, 28.2414569855), (-100.297920227, 28.2803535461),\\n (-100.292892456, 28.3203601837), (-100.351570129, 28.3941822052), (-100.37677002, 28.4786510468),\\n (-100.345802307, 28.5008106232), (-100.419532776, 28.5441913605), (-100.403175354, 28.5897331238),\\n (-100.497909546, 28.660987854), (-100.589790344, 28.8942222595), (-100.647224426, 28.9223499298),\\n (-100.668769836, 29.080072403), (-100.768608093, 29.1665706635), (-100.796989441, 29.2425022125),\\n (-101.009056091, 29.373254776), (-101.067359924, 29.4735527039), (-101.261428833, 29.526473999),\\n (-101.254585266, 29.6287498474), (-101.308929443, 29.580909729), (-101.305862427, 29.652431488),\\n (-101.368400574, 29.6571617126), (-101.416099548, 29.7454338074), (-101.401275635, 29.7699050903),\\n (-101.448425293, 29.7605857849), (-101.470466614, 29.788690567), (-101.538345337, 29.7630176544),\\n (-101.543952942, 29.8101196289), (-101.581489563, 29.7651500702), (-101.639671326, 29.7569599152),\\n (-101.759094238, 29.7871665955), (-101.805206299, 29.7799987793), (-101.819099426, 29.814125061),\\n (-101.924224854, 29.7885017395), (-101.973320007, 29.8187732697), (-102.063995361, 29.784570694),\\n (-102.324333191, 29.880115509), (-102.36756134, 29.8452892303), (-102.384796143, 29.7679462433),\\n (-102.503097534, 29.7854557037), (-102.551948547, 29.7495002747), (-102.576499939, 29.7782478333),\\n (-102.637611389, 29.7323379517), (-102.676361084, 29.7442245483), (-102.804725647, 29.5301456451),\\n (-102.82220459, 29.4118442535), (-102.883010864, 29.3533706665), (-102.908325195, 29.269203186),\\n (-102.866172791, 29.2290363312), (-102.988098145, 29.1908626556), (-103.153465271, 28.9786815643),\\n (-103.266586304, 29.0074539185), (-103.280349731, 28.9863739014), (-103.335517883, 29.0503387451),\\n (-103.375450134, 29.0321083069), (-103.474075317, 29.0721340179), (-103.526237488, 29.1466464996),\\n (-103.720314026, 29.1906318665), (-103.739852905, 29.230348587), (-103.782157898, 29.2297954559),\\n (-103.76776123, 29.2812404633), (-103.786994934, 29.2672595978), (-104.045631409, 29.328119278),\\n (-104.164382935, 29.4007148743), (-104.204734802, 29.484041214), (-104.377593994, 29.550611496),\\n (-104.535247803, 29.6794662476), (-104.577560425, 29.8079357147), (-104.674369812, 29.9092826843),\\n (-104.696495056, 30.057302475), (-104.674758911, 30.1489639282), (-104.702613831, 30.238489151),\\n (-104.813957214, 30.3504695892), (-104.806472778, 30.3764476776), (-104.852996826, 30.3922634125),\\n (-104.890678406, 30.5705566406), (-104.986930847, 30.6413249969), (-104.997543335, 30.6843338013),\\n (-105.060562134, 30.6878700256), (-105.21434021, 30.8120861053), (-105.25818634, 30.7976531982),\\n (-105.287597656, 30.831949234), (-105.313781738, 30.8165073395), (-105.390312195, 30.8530807495),\\n (-105.409065247, 30.9025096893), (-105.554382324, 30.9982852936), (-105.603218079, 31.0864276886),\\n (-105.769729614, 31.1707801819), (-105.99835968, 31.3938179016)\\n ])\\n qtssr_texas = QuadTreeStructureSingleRing(ring_texas)\\n points = [\\n [-96.83201838665211, 30.43633054583931, True], [-94.97179271816618, 30.46609834459278, True],\\n [-96.87911915799319, 29.002783392404453, True], [-104.03817768478906, 26.080885130466065, False],\\n [-101.05107033713017, 26.110092672074, False], [-101.90984946051287, 30.2673660562615, True],\\n [-104.2666097673043, 26.638892954348243, False], [-99.00209313228278, 29.312408039204637, True],\\n [-96.76821760997925, 26.53415999513266, False], [-103.60734801725461, 25.989562175464958, False],\\n [-105.52663947372852, 35.59616356954213, False], [-99.73190928401823, 36.34065757158246, False],\\n [-94.28455658519579, 30.510396248421543, True], [-98.287902523108, 32.42446924695663, True],\\n [-98.36319041112684, 26.836620743656326, True], [-100.58823300352246, 28.287422480123738, False],\\n [-106.09575378559609, 29.647073739534953, False], [-96.03197805726944, 34.67673925196511, False],\\n [-106.13189503506499, 28.293328347459486, False], [-105.6163099497765, 34.642876249285806, False],\\n [-102.1699840394609, 32.64792829807019, True], [-102.19213396201079, 31.137813785847744, True],\\n [-96.8832056156457, 33.584067733298724, True], [-105.47157574361026, 33.89108923934286, False],\\n [-101.53889206881809, 27.73095057942401, False], [-95.0730796759137, 26.09464277833887, False],\\n [-96.45795032815394, 30.22238046821291, True], [-99.47479689046119, 27.519862201810025, True],\\n [-104.95530088407097, 34.46894379454478, False], [-99.64935392553515, 27.166719715093752, False],\\n [-101.8740013838435, 35.11537675606412, True], [-99.07039344683601, 33.64951303142618, True],\\n [-106.60595918307385, 29.64471250102584, False], [-97.20030616424087, 32.31820772186446, True],\\n [-96.23784236099425, 27.638993220475054, False], [-105.93765675735541, 35.89412147712274, False],\\n [-97.17726496423283, 28.55515333886519, True], [-101.41972932590615, 26.609185193916016, False],\\n [-101.84272804452128, 31.047193869577697, True], [-95.92485433657428, 33.9254034938182, False],\\n [-98.09279175575493, 31.486295362051568, True], [-100.77512720701931, 34.5423023937584, True],\\n [-105.99024440024378, 32.444411669816, False], [-101.4742991680627, 36.37442042029491, True],\\n [-99.91406680649878, 30.44981434916269, True], [-106.59351726840352, 27.830675040946844, False],\\n [-100.50108029331473, 28.08692086210316, False], [-106.22266727042927, 28.257938478160245, False],\\n [-99.16766510789698, 34.05594801235725, True], [-98.81327349833023, 34.53578673189781, False],\\n [-95.75835434832825, 35.97127466623442, False], [-95.87872844572516, 34.1792497663974, False],\\n [-97.67138045660111, 28.85228239075667, True], [-103.7493116963675, 29.910102031100415, True],\\n [-97.9552991722866, 35.50168101442732, False], [-101.99173352350167, 33.16196427356835, True],\\n [-99.69108575797604, 26.58570279334035, False], [-96.1383698450465, 30.01380467777652, True],\\n [-96.65345956191142, 28.13722809686032, False], [-102.19812919352621, 27.653939350819577, False],\\n [-106.17852559635664, 34.30676459237532, False], [-97.12171059588019, 32.98547742358788, True],\\n [-97.63495481018265, 31.052912731492313, True], [-103.04179423578454, 32.565022698580854, True],\\n [-99.7663361476778, 33.93929224333747, True], [-93.96695034930963, 33.64792052285788, False],\\n [-106.43489898416725, 27.00081934085768, False], [-98.61144241454609, 26.091546414019007, False],\\n [-97.62297026159148, 29.91547499019296, True], [-102.81093959843548, 31.775967846663903, True],\\n [-98.92280973197468, 34.706031694183864, False], [-105.82454817097681, 33.60768142292876, False],\\n [-104.1703913008495, 26.30423978112628, False], [-97.03821689475404, 25.891523519897085, False],\\n [-95.96948383690238, 28.06242640122303, False], [-96.20743197977514, 32.96986917934692, True],\\n [-101.84781525566628, 30.91982689926289, True], [-96.31807840035235, 31.527410535260906, True],\\n [-100.8781500555231, 34.8227970125657, True], [-94.26355042343864, 30.94843753499924, True],\\n [-97.3429146102502, 34.73686841121185, False], [-98.07753472284375, 29.552925455931927, True],\\n [-105.04690710593536, 27.132667240961553, False], [-99.87850355720977, 32.06195375035851, True],\\n [-96.53670297300587, 26.908808751199025, False], [-101.25665086243849, 34.48897040535931, True],\\n [-97.62841641211763, 34.510828859444, False], [-98.26146628715239, 29.30444627019776, True],\\n [-94.0424931438063, 34.024181902771446, False], [-95.32764174246178, 29.026516144561093, True],\\n [-94.79487469005772, 34.064778827088944, False], [-96.8217807635728, 32.9449205143214, True],\\n [-102.65783000325504, 31.187142262599163, True], [-102.73499640672506, 28.241956569934032, False],\\n [-106.57423647984751, 26.21365468361891, False], [-101.18188053173569, 35.856064735642605, True],\\n [-103.87152954646331, 26.239969281258677, False], [-105.21761650869897, 27.276124133480618, False],\\n [-96.58824456554876, 36.01267677418892, False], [-99.10920560787146, 32.43164577872433, True],\\n [-101.93795697189412, 31.620064217834788, True], [-105.78051688469152, 34.39769579781999, False],\\n [-98.13520908953838, 28.15597786510518, True], [-103.44661785399717, 34.94625679402945, False],\\n [-93.5839550242031, 27.799377395246868, False], [-103.09029902940127, 33.20610297263985, False],\\n [-97.23285674761303, 28.03274042046823, True], [-95.34132538021933, 25.846590059853146, False],\\n [-101.75354725398458, 29.976564072236787, True], [-102.8028884021146, 36.14653256975264, True],\\n [-105.23453544451979, 35.083822581361105, False], [-95.02779486726217, 28.039905574389728, False],\\n [-105.19965155638648, 29.896855738726387, False], [-105.04729708179732, 34.59962724881616, False],\\n [-93.62110240741019, 32.29972687153207, False], [-101.91706806513982, 32.22042821274782, True],\\n [-98.7507642387652, 28.373512157202324, True], [-98.67837171745543, 29.31049604748274, True],\\n [-101.4835726546693, 35.24105797268996, True], [-99.61534262189332, 34.664146656697135, False],\\n [-102.77162178290662, 31.477015077025758, True], [-98.14965646419336, 35.506326174334816, False],\\n [-100.35687795352196, 36.428658182990375, True], [-93.75583478299006, 33.78374602526648, False],\\n [-97.35272483145133, 36.14322026779398, False], [-104.13566843512568, 32.58780129504587, False],\\n [-105.80951615950367, 30.548722565553994, False], [-106.36813961730384, 35.58713162312485, False],\\n [-97.66809642868546, 34.13059807529114, False], [-97.61612010157164, 26.31880576825889, True],\\n [-105.10689839575184, 27.13050661175676, False], [-94.42639614961973, 28.61525052001613, False],\\n [-101.0258419742403, 29.912378788493154, True], [-100.85598848851129, 27.83703095635782, False],\\n [-94.6443199603266, 29.977477497837175, True], [-101.16783935327581, 32.03976620169659, True],\\n [-95.78686711235261, 34.37099939418539, False], [-100.59275869451973, 34.36381573902874, True],\\n [-104.2707359051878, 33.43707298914277, False], [-102.69754715561436, 30.324718877958027, True],\\n [-100.31772708579322, 36.03146883077079, True], [-93.84018528740714, 36.306249385961586, False],\\n [-97.81378337323478, 25.848331371979896, False], [-104.37867619764027, 31.688609367477817, True],\\n [-100.28100102840853, 36.18155424506788, True], [-106.48975872243628, 34.10471027956753, False],\\n [-101.4453862294541, 28.535362387187064, False], [-100.05248503701085, 35.161646972337195, True],\\n [-101.37197503092796, 27.85006417239032, False], [-95.00012601768513, 36.45104201985982, False],\\n [-94.1618133883979, 34.189947778971074, False], [-100.9407537928131, 27.309175834366915, False],\\n [-104.72991115996922, 27.3139116441178, False], [-98.59532436543168, 26.287325902961726, True],\\n [-94.46884442680549, 35.68627263027676, False], [-105.31712494151611, 35.84472703216106, False],\\n [-104.64932323670762, 28.699942778858926, False], [-100.34867007633471, 29.705706918470952, True],\\n [-93.69561095836606, 32.456548936430266, False], [-98.12884276179193, 28.360889737226003, True],\\n [-96.77862792020258, 28.586529000239178, True], [-106.1873382768634, 29.404306118606442, False],\\n [-105.67789642420705, 31.716310454187514, True], [-96.00775542585319, 28.568996970414524, False],\\n [-98.0904391114445, 33.41233020042991, True], [-93.82743788526335, 27.5659388943208, False],\\n [-98.96755649758798, 31.32502880958104, True], [-96.55622361353764, 35.016203517682726, False],\\n [-99.90454174449499, 34.88971778656889, False], [-93.92308221299953, 26.93602671682176, False],\\n [-103.02775965216946, 27.526954568149137, False], [-101.70211609579965, 33.221705586015986, True],\\n [-94.65140320779773, 30.12411725325112, True], [-105.48158850264392, 25.966083503119812, False],\\n [-95.86092717890419, 30.257238607458746, True], [-94.78025397771191, 26.33573351642334, False],\\n [-102.42306855603515, 31.528148123221925, True], [-101.11557151275859, 28.23290994001276, False],\\n [-99.23764635246289, 34.03712892161272, True], [-97.18358117231713, 30.819652476530774, True],\\n [-95.52114900196523, 33.71837984822948, True], [-94.80576475349369, 32.52595208303153, True],\\n [-105.53353349524157, 33.10076381764996, False], [-104.45067861203503, 29.792014903132056, True],\\n [-100.81552999585323, 31.13371713587459, True], [-98.10244603287715, 27.062939382372114, True],\\n [-102.8183262272355, 31.63644201139868, True], [-105.48022791238954, 33.47054002907317, False],\\n [-94.54700162806725, 33.3634517345777, True], [-103.52394717869927, 29.289585818953316, True],\\n [-100.88024068589486, 28.00254322622369, False], [-105.13298501311634, 33.585842169513036, False],\\n [-95.47745420853485, 34.33206192097545, False], [-93.75279262948008, 31.85387584406531, False],\\n [-105.6408652118954, 33.38704981277846, False], [-102.68527628279271, 26.856854067490247, False],\\n [-105.22798572254378, 34.52742324390015, False], [-94.25227485978478, 36.11993169557898, False],\\n [-95.31071217313071, 30.450554401067357, True], [-104.32309381721137, 33.941981631972624, False],\\n [-93.68344966428387, 28.25720980205315, False], [-103.11762381325748, 33.05126426779246, False],\\n [-95.17637994183367, 36.37368703601287, False], [-101.09466869744112, 29.378868777118257, False],\\n [-102.3244768566622, 29.25373813014635, False], [-105.6081974667763, 35.02231128438977, False],\\n [-101.45129562213593, 27.250895271383474, False], [-97.77527080825567, 29.233601979476123, True],\\n [-101.2708728240608, 30.929678610371226, True], [-101.17628088744974, 30.807932586287112, True],\\n [-98.94314936681077, 28.962959058638244, True], [-97.5297094048325, 27.24629690610976, False],\\n [-105.24649559460273, 31.68285402434288, True], [-95.38165074760121, 30.678277565962645, True],\\n [-101.5405440205774, 35.75938014879534, True], [-106.30162345059492, 32.35717712927482, False],\\n [-95.82698786035043, 31.471380696415473, True], [-97.58132229591222, 26.76823235412943, True],\\n [-96.24754364311642, 29.148074667141763, True], [-101.60752835018079, 28.02378609076799, False],\\n [-93.66280978876574, 34.36888263435238, False], [-97.04083533693894, 32.07693083540003, True],\\n [-94.41534967058817, 34.30307828414252, False], [-94.51223027590078, 26.101565901379825, False],\\n [-95.37877455769014, 32.91182889409107, True], [-97.02169748832533, 34.77231790184875, False],\\n [-99.56938377454452, 27.98323188041011, True], [-104.71416427480177, 31.671590498127077, True],\\n [-104.48037657157643, 28.020929009314624, False], [-101.46582277815409, 29.245030464171972, False],\\n [-94.33289936897319, 29.433780707715577, False], [-102.65873114765344, 32.579375713461324, True],\\n [-94.71197474752655, 29.919750259392565, True], [-100.56224887904757, 30.870441757396232, True],\\n [-95.7680416447194, 33.381874464032556, True], [-101.30709319439809, 31.415698736346386, True],\\n [-94.17706664281508, 30.20919168191223, True], [-105.1986310512293, 32.2767819705482, False],\\n [-96.64520698321878, 32.53545316641808, True], [-101.27894696079863, 27.434282641130807, False],\\n [-103.96823391756168, 36.206818702766164, False], [-102.61287825142863, 31.52883149992497, True],\\n [-97.43688838995867, 35.35809331749178, False], [-106.3345282700814, 26.77898252396381, False],\\n [-97.84563076948461, 28.326830633856254, True], [-97.10812201190659, 27.354066620755486, False],\\n [-102.06625125192836, 31.959360067966703, True], [-94.77064907103171, 32.49772073548828, True],\\n [-103.7070672713304, 26.993474458082765, False], [-104.63528508881744, 31.77175026283308, True],\\n [-106.20330061641941, 28.71581603545491, False], [-102.93466353815762, 36.42712467119802, True],\\n [-97.02548398973192, 26.47462461285108, False], [-97.92517027601997, 33.53006657932378, True],\\n [-104.89676410831059, 32.03756980285575, False], [-95.02216317823846, 28.250092458391666, False],\\n [-102.63731145928554, 30.78785522057966, True], [-101.9626891052094, 28.607495532359852, False],\\n [-103.43019339494695, 33.757210152142996, False], [-95.52042729675107, 34.824713652167745, False],\\n [-105.6806104213336, 28.64547500599634, False], [-105.01509606690256, 26.998326186544013, False],\\n [-104.83729623744878, 28.111330049442206, False], [-99.30736722245813, 27.44271254179918, True],\\n [-96.19450914007797, 26.5070841846474, False], [-96.93250711894682, 27.465441701127965, False],\\n [-98.05769301004028, 33.34316222525198, True], [-101.70993094422322, 35.378824775340604, True],\\n [-97.78065357281011, 30.791192214255453, True], [-103.85602296523946, 33.58813675270333, False],\\n [-96.16754367241163, 27.82134326033623, False], [-93.84173858221502, 28.644678311847933, False],\\n [-95.66361201153609, 33.1782437005781, True], [-96.18610593628335, 35.66871035791395, False],\\n [-100.05778168598985, 34.34775700022905, True], [-105.3070646714683, 26.129506259811194, False],\\n [-101.60474509803998, 28.301826427498735, False], [-94.05455083451157, 35.62737695624984, False],\\n [-93.77022392951797, 33.35636018468855, False], [-99.9983492940202, 28.616796438006656, True],\\n [-103.65327712041633, 35.68635542708576, False], [-94.18836108420525, 33.519234035329205, True],\\n [-101.16524711825508, 35.21736886367663, True], [-106.63756507835402, 31.512711118486916, False],\\n [-94.64418283641962, 32.24310968022579, True], [-98.48901518901792, 26.92275583383609, True],\\n [-105.71495874564097, 30.37875836321371, False], [-103.59489508163908, 34.07565890645147, False],\\n [-104.58617756264167, 34.7175307481461, False], [-94.94979738923941, 33.53027390298981, True],\\n [-104.79237901545315, 33.643949242871386, False], [-103.6261849261433, 26.37203494674699, False],\\n [-104.12072798260623, 34.037343854052246, False], [-99.3137876161763, 28.786746195806515, True],\\n [-96.90701800480272, 26.83567175899895, False], [-105.91609848895729, 27.17006217234686, False],\\n [-94.88867966602324, 29.0650764347025, False], [-99.09445254927051, 29.165294618392306, True],\\n [-99.59646096585762, 31.547978010714818, True], [-100.35308616902222, 27.998071701955347, False],\\n [-103.65741111414567, 29.929101550941933, True], [-95.56003645452608, 33.73354146467783, True],\\n [-101.98380104745135, 27.741893994563817, False], [-100.28801029632858, 26.08376297941383, False],\\n [-100.82876490121433, 27.203171781033483, False], [-99.00038368647441, 30.227734562748875, True],\\n [-93.99273175213636, 33.172989756016705, False], [-103.28907886290975, 30.68354258877181, True],\\n [-101.58265515547387, 34.05717966984305, True], [-93.61002560748278, 33.95079910028842, False],\\n [-104.1322621794693, 31.037441969505064, True], [-94.90790561010023, 33.6667146192015, True],\\n [-99.72772840949955, 28.57426803892259, True], [-96.76750823367423, 34.238866572662864, False],\\n [-99.11285733031394, 29.297129143702183, True], [-95.34529541329582, 34.50122580606273, False],\\n [-106.2015311076861, 33.04546069130247, False], [-106.6471763299225, 35.60222852490276, False],\\n [-101.63138803719991, 27.93647861077147, False], [-99.67286004973847, 29.000600155646495, True],\\n [-102.69661571801251, 30.438208192282016, True], [-96.47920563132686, 28.187453937378827, False],\\n [-99.15701789001724, 28.754330049547363, True], [-103.63208677741055, 31.506299316322448, True],\\n [-104.6247250325306, 34.777168030468545, False], [-94.50362320672285, 28.725533817363363, False],\\n [-98.8088667387509, 29.719091220812984, True], [-104.66480293721597, 31.36766582422802, True],\\n [-100.80243453385943, 29.56664951795082, True], [-104.3184052935018, 28.368505467940153, False],\\n [-94.99687127078006, 29.056199158312214, False], [-99.18151980311957, 31.331306403933503, True],\\n [-106.58306812961843, 33.83560030586354, False], [-102.34808248763466, 30.93213593104124, True],\\n [-96.87905436496129, 31.63403473842953, True], [-101.88482545812973, 31.346536386676735, True],\\n [-102.08612983365585, 33.94091937937585, True], [-97.59374438050571, 30.710749425390954, True],\\n [-98.468759043241, 34.887864549188656, False], [-104.5600126294423, 30.769523820716284, True],\\n [-105.63321064215583, 31.706723345643436, True], [-103.39803684928096, 31.205852663870417, True],\\n [-103.74991694223343, 34.47243593420573, False], [-103.55735795090966, 29.368257266446264, True],\\n [-100.53250901956653, 34.61994711930259, True], [-106.42290807028131, 29.47435749957574, False],\\n [-100.61630496584333, 28.492897242114427, False], [-95.45897223676457, 34.99538998873486, False],\\n [-100.80796423924814, 27.597779160448237, False], [-95.59903305812487, 33.53765968472729, True],\\n [-102.71817656483864, 33.67774382239573, True], [-100.0519819831278, 31.720152603322795, True],\\n [-101.86801670742807, 29.37988286278217, False], [-93.7251604108502, 33.63648932111699, False],\\n [-93.50731366944763, 31.66131539976032, False], [-93.91408986252142, 31.91658143504109, False],\\n [-99.1976965958281, 31.846542049263352, True], [-96.70181855090833, 27.823299476943752, False],\\n [-99.05025751191671, 30.14722485144382, True], [-101.91786175888922, 33.662393020783334, True],\\n [-97.18908214543966, 26.584467319788136, False], [-102.09768463635325, 27.745869776526586, False],\\n [-105.03784779065376, 33.35089012727154, False], [-99.75443466868418, 32.340335779846406, True],\\n [-102.53950776524619, 32.48219468369184, True], [-97.38249374177907, 31.70583501812896, True],\\n [-100.23917371385507, 34.15552160975429, True], [-100.64584910978431, 33.08767497994276, True],\\n [-95.54547414843782, 28.573393441826422, False], [-98.4400667166874, 29.169883280280335, True],\\n [-101.85722555245049, 29.99952272227504, True], [-103.40127887731586, 35.954389606004995, False],\\n [-106.49277204369605, 26.3739019521645, False], [-96.42482710450412, 25.935501811569573, False],\\n [-96.49468755444158, 26.21429802291354, False], [-103.26280296149277, 36.42505933494076, False],\\n [-103.23186132072851, 26.981602236536546, False], [-95.43868017247715, 26.795551518098133, False],\\n [-104.95759598697946, 29.274620743768665, False], [-97.4627043038694, 31.264418590173566, True],\\n [-99.40922174677335, 30.859355223178202, True], [-97.62450333069754, 31.860943195654983, True],\\n [-103.28423668185653, 31.64625933078107, True], [-97.34347509751296, 32.39948448790623, True],\\n [-104.78394662628456, 32.19069943780818, False], [-94.27543944274844, 28.45111869438522, False],\\n [-105.41902431151755, 34.098705479256964, False], [-105.84856227788723, 34.401910854922086, False],\\n [-105.76944559045042, 27.541157331410925, False], [-105.96625908843005, 34.60984823477864, False],\\n [-100.45522585613661, 35.82958048104291, True], [-95.8227101752813, 26.40044772412707, False],\\n [-98.14190854947867, 28.173726785556475, True], [-103.41079917326785, 33.17358912330205, False],\\n [-106.21380947469507, 30.673049362200253, False], [-98.6181240681384, 31.57826052940466, True],\\n [-105.52347449914703, 28.45331024338554, False], [-105.87199783454764, 29.269133017660426, False],\\n [-95.72117392272776, 32.84521613150032, True], [-103.98103037156038, 29.39830154631861, True],\\n [-98.84272856308685, 27.010603508995832, True], [-103.48528511610583, 32.292795962096, False],\\n [-101.10764837358862, 34.44067771878632, True], [-99.90899218640438, 33.864602563342665, True],\\n [-99.99425094006477, 29.632299612876448, True], [-104.19954114103936, 29.481293826903272, True],\\n [-99.1617923467798, 27.24969812956527, True], [-93.94985771467012, 33.20509824852493, False],\\n [-98.74589172711391, 26.59828162369087, True], [-100.74104498226976, 28.090884473461635, False],\\n [-102.0941642949128, 29.40228872741179, False], [-103.71745434686355, 36.07717165565938, False],\\n [-103.85504023598908, 35.797619278303934, False], [-98.3178181998277, 31.80247171895742, True],\\n [-100.46831716774525, 26.395663970107364, False], [-96.6262432609301, 33.43258969257319, True],\\n [-102.12872561318167, 30.9414684197057, True], [-96.10044267209415, 31.617205739677686, True],\\n [-102.76040876099727, 30.02029055974793, True], [-100.28567173102832, 33.71564104661008, True],\\n [-101.87455244042499, 35.45783748840937, True], [-103.80647075850555, 33.75958813400894, False],\\n [-104.07465598182498, 29.829473718048853, True], [-96.80679641483542, 34.068109206459674, False],\\n [-100.21922411687524, 35.55827610846517, True], [-102.18536576459445, 35.60838848797885, True],\\n [-100.74818339320018, 32.46468922651053, True], [-98.89381745119253, 29.84927086885224, True],\\n [-95.57772284816139, 34.03118772897132, False], [-102.19208387081574, 35.47422893590955, True],\\n [-99.31176771742929, 28.159649775138398, True], [-95.08438010592444, 30.864384073337725, True],\\n [-105.62858370011037, 36.04041710371988, False], [-99.50704661690466, 26.530069415053166, False],\\n [-102.21328017280045, 28.123746616410187, False], [-93.82909083931759, 31.8346812474552, False],\\n [-99.68311577900606, 33.37514101639904, True], [-93.88914553766337, 34.40543275268286, False],\\n [-95.49031947037534, 36.15787562082431, False], [-94.04958126924683, 25.895718131012476, False],\\n [-102.31183630727872, 26.195612345971853, False], [-99.74217764726765, 34.4866834996357, False],\\n [-101.2273998455989, 31.012399597950438, True], [-93.7170401640232, 26.52296130239048, False],\\n [-106.31856530763194, 30.254195818383003, False], [-93.54539750125572, 31.968279205890525, False],\\n [-102.06176434040876, 35.96267638467066, True], [-102.21150807644786, 31.276020170678756, True],\\n [-97.59134352614593, 27.758428418449625, True], [-105.6285777230377, 36.20035827010385, False],\\n [-99.56855691529327, 27.565199944571845, False], [-93.95512959128524, 35.50257083074824, False],\\n [-104.2068757288861, 25.983428900973824, False], [-104.1534590142076, 29.90389615149271, True],\\n [-104.75891565225955, 26.17708478969608, False], [-96.34136547606607, 26.58259616840622, False],\\n [-94.35505605596222, 31.363945882683545, True], [-100.75357998539742, 27.70797766258346, False],\\n [-96.34206621365894, 29.195743358202087, True], [-96.44632535331706, 33.578167176287465, True],\\n [-100.52062683482386, 28.935836235311534, True], [-103.59488192282778, 31.145329272683313, True],\\n [-96.21513910038252, 26.71734433601959, False], [-97.74524155506616, 35.72544238150706, False],\\n [-98.15072688652688, 29.65447185320712, True], [-102.94259657821668, 28.995860793431966, False],\\n [-98.37049290964605, 28.992239589640803, True], [-101.9333665893231, 32.042668019418784, True],\\n [-100.31205895270178, 28.542423199402116, True], [-102.7842119789965, 31.351234994650703, True],\\n [-102.82118189131612, 25.936779514285522, False], [-105.06566909806352, 34.429600751175066, False],\\n [-103.95414080936615, 30.5173184712075, True], [-96.41063716230997, 35.68425390782344, False],\\n [-94.82668338005425, 34.10595925830741, False], [-105.42861829324059, 26.89985572905742, False],\\n [-94.86003017402527, 32.72190652290611, True], [-96.69442705925057, 29.12593879172168, True],\\n [-100.57898366779487, 35.697109012290476, True], [-105.77290660716999, 34.23468690232633, False],\\n [-104.3849259560512, 31.337110429238777, True], [-95.21459964105358, 33.00732978946704, True],\\n [-95.7332150421658, 27.704415504038284, False], [-104.50875122680036, 34.91526292458323, False],\\n [-102.80833873160228, 31.875937580897503, True], [-104.53224880900562, 25.940603993388773, False],\\n [-99.6884270626213, 31.04708806366109, True], [-95.76317485487704, 35.45517519387816, False],\\n [-101.84342021439619, 35.834756908559946, True], [-104.04702349088515, 26.09752753366655, False],\\n [-103.48123590122003, 34.55695985365465, False], [-101.90736610359222, 26.198871101374856, False],\\n [-95.80852972334627, 26.4884711642595, False], [-106.49602165329638, 31.587480730479957, False],\\n [-99.11540612418378, 28.76377389466793, True], [-98.81124442220992, 27.408954979897345, True],\\n [-103.54081324519612, 28.238918914656047, False], [-102.8589030540497, 33.69752159861657, True],\\n [-100.38962812985066, 36.259455441754405, True], [-100.60205967959344, 27.45237069505359, False],\\n [-104.82116135978534, 33.90726029831255, False], [-95.25951953419671, 36.427532407586796, False],\\n [-93.75127522006922, 31.774003703956872, False], [-106.50710079332187, 32.31418914724039, False],\\n [-95.38754195058371, 27.686986329488576, False], [-103.48158704856718, 28.05982044881246, False],\\n [-94.40123367677305, 32.13802908979801, True], [-98.37091796124368, 31.394805069115378, True],\\n [-99.35199253682242, 29.364231843209286, True], [-100.6371809469257, 29.485414607179138, True],\\n [-101.65847488152119, 33.055932161413, True], [-104.75073650330286, 35.477180164221664, False],\\n [-100.70424003073441, 33.33233065367354, True], [-104.9829081950403, 33.49495185425366, False],\\n [-96.28014091653374, 30.765109918972172, True], [-102.51312299795521, 34.973490202758846, True],\\n [-106.4316820557197, 28.835022330467574, False], [-98.37035640871174, 29.15982666730043, True],\\n [-103.81743393736278, 33.33070497195332, False], [-102.38044273457957, 27.128328755756332, False],\\n [-105.83310224715474, 32.69799499508526, False], [-104.47875333696165, 33.08218160363957, False],\\n [-105.08315111607386, 27.5499535808647, False], [-102.50315445382816, 32.952707100728176, True],\\n [-106.34702977388169, 28.350530651265025, False], [-100.7324706006535, 28.110070428450136, False],\\n [-98.89057718530617, 30.501635222091867, True], [-93.7973707158511, 30.332449685439883, True],\\n [-100.50817745675471, 35.933620707046416, True], [-93.62331898394628, 28.011415151343442, False],\\n [-102.40168198643366, 28.038346452109714, False], [-98.76386270364078, 32.824244011949546, True],\\n [-98.63890075873523, 28.426721830307706, True], [-103.06753906192446, 27.182546407018886, False],\\n [-103.5149916483893, 32.22702185824897, False], [-96.92704846269056, 33.56573720072518, True],\\n [-98.59191146293448, 26.717454841499933, True], [-98.21728189059557, 30.499991381612325, True],\\n [-98.96569953382873, 34.09349857812645, True], [-98.81645597171263, 31.538513035336027, True],\\n [-103.99810746775411, 34.572232011339544, False], [-97.1971994402299, 33.01231694977086, True],\\n [-97.35525400352937, 27.593348250877636, True], [-95.61047936363322, 32.915418129253844, True],\\n [-105.77325410471146, 32.220934743164854, False], [-100.31130282858123, 31.053207323928227, True],\\n [-94.27435346222804, 29.717111545751255, True], [-99.36518149272568, 29.81842676057489, True],\\n [-102.4595465810425, 29.78052913717334, True], [-104.93563833675945, 36.1553390615043, False],\\n [-96.67331825738593, 33.795256849340824, True], [-104.13912762449462, 28.90285335911741, False],\\n [-99.85650514030851, 27.082576996579743, False], [-95.46433062216431, 26.31189218916502, False],\\n [-100.84562917395462, 26.46339943905897, False], [-94.75077980314441, 30.746795428982928, True],\\n [-98.38741630868877, 32.8939361913369, True], [-101.50339387491944, 33.409893596597634, True],\\n [-102.8838322429055, 33.550509813464714, True], [-94.4241089162888, 29.987534160102904, True],\\n [-96.97724045199526, 29.413237018802626, True], [-103.26463086689401, 35.69959960363469, False],\\n [-104.22583858596425, 35.32625561149897, False], [-102.28802601849752, 35.31386927276366, True],\\n [-101.0349738411682, 25.896953488838804, False], [-103.9839821999459, 33.2679016367904, False],\\n [-105.01149642855964, 34.24130005689306, False], [-104.86876474825357, 35.97880497285345, False],\\n [-98.95300311760788, 28.23951953232239, True], [-106.44607553528402, 28.99701327445984, False],\\n [-97.15665622011281, 33.802655749490576, False], [-104.88728768211863, 26.19423408399297, False],\\n [-98.2868092522052, 26.77958013643795, True], [-96.30475465159665, 25.886256031524383, False],\\n [-93.96185258306615, 30.262131379160092, True], [-95.98431071502645, 34.074476976239524, False],\\n [-99.34592870499611, 31.77796555029789, True], [-101.23448890900838, 35.02325060675137, True],\\n [-96.60311950987519, 26.520767851753252, False], [-103.30098695011493, 33.95932432365544, False],\\n [-97.20833874248723, 30.443771327358455, True], [-100.49276808544384, 30.563391121718663, True],\\n [-106.00844672588474, 27.67304591354748, False], [-94.68045487444002, 28.380941225789602, False],\\n [-106.32581808918103, 27.457360510530357, False], [-103.90944733413775, 33.75181119086094, False],\\n [-96.62055409685594, 30.911602145241257, True], [-105.08332076154659, 35.84175548182445, False],\\n [-106.46727840740928, 30.97311215593337, False], [-98.24608713290009, 26.87548489704331, True],\\n [-99.99394976092111, 35.372523026676305, False], [-101.04275569324, 26.378571750355146, False],\\n [-99.49808015597847, 29.0197284725707, True], [-100.04278394100143, 31.138487871928806, True],\\n [-93.77580092670675, 28.679720562816012, False], [-105.69434962210484, 35.48380415396366, False],\\n [-94.76833576200043, 34.77440737306939, False], [-93.55059692835445, 32.93611160385383, False],\\n [-96.16637525156335, 35.14861120144762, False], [-102.57674991354982, 33.57167753159161, True],\\n [-104.50984249707894, 27.845184825434426, False], [-102.46681259074438, 32.876290517890325, True],\\n [-103.79635335230255, 34.68136206176115, False], [-97.37101719424614, 34.331617955613964, False],\\n [-93.78338486646257, 29.1736195506313, False], [-98.653709287249, 30.255774672109183, True],\\n [-104.78162076886001, 36.14023266162845, False], [-95.30745598333526, 26.15568755210897, False],\\n [-96.19795914229807, 29.783289215723965, True], [-93.97200790057319, 30.34872478231179, True],\\n [-102.75807129557354, 32.02568271699399, True], [-95.63613363239972, 30.17575679938203, True],\\n [-95.74058254060239, 27.830132693387228, False], [-97.28993038017775, 33.34058580949793, True],\\n [-94.782421253055, 26.37055251439716, False], [-99.01579664350437, 33.29078588254949, True],\\n [-97.2079339911563, 27.123479789817104, False], [-96.66399830213123, 35.57917944458788, False],\\n [-104.00378871415248, 33.03909098032557, False], [-98.18333736354995, 33.40304952690905, True],\\n [-99.51409889042824, 28.352125049514296, True], [-96.39878389524632, 33.80913094147424, False],\\n [-97.95457727578372, 31.304986453423908, True], [-105.41519123044006, 31.17900852073914, True],\\n [-102.55823249490591, 28.227952215383333, False], [-105.22740902391834, 28.00912246742774, False],\\n [-105.4327613051658, 30.42094293937215, False], [-99.8642636892311, 34.741799628413524, False],\\n [-104.07069003771045, 30.561044257056018, True], [-105.71580939231154, 34.73255277750661, False],\\n [-98.92331393934845, 34.757305489096225, False], [-95.1451471669803, 35.59262098012566, False],\\n [-100.78929431916742, 35.83001258653612, True], [-106.15538551006625, 33.88884085609275, False],\\n [-97.78557980515986, 33.9896913074551, False], [-94.43404183378551, 31.976310799398128, True],\\n [-102.77500581970122, 30.636815025506447, True], [-105.67967176568628, 33.47402254839546, False],\\n [-98.79160014376332, 32.79018812677753, True], [-102.84347322545034, 28.136203054123584, False],\\n [-95.24784148052099, 34.22424254638486, False], [-106.31929728808254, 30.9825641984661, False],\\n [-102.43296109133702, 32.532070674152855, True], [-105.92145087338875, 30.381356965114943, False],\\n [-106.45282535347631, 35.54158851537021, False], [-95.04777932048988, 35.82906359730707, False],\\n [-97.42369763037011, 34.37608618524585, False], [-104.57070459903527, 33.70875609054547, False],\\n [-97.41632281711793, 32.92982657064401, True], [-94.66570627408036, 27.27007338775074, False],\\n [-99.1743643002243, 27.247623481915483, True], [-104.68950862955154, 29.870865904293723, False],\\n [-98.10816880312582, 28.162238589797898, True], [-93.64216163895259, 26.298614364258444, False],\\n [-95.19102534541413, 33.389356010635154, True], [-96.62070599059086, 30.74805978317854, True],\\n [-99.3386516464026, 27.906200841991534, True], [-100.8007152801228, 32.84683422029997, True],\\n [-106.20302284683326, 32.380361469176044, False], [-94.23655356205708, 26.324497474351357, False],\\n [-99.65954455695915, 35.474000933282724, False], [-94.31553240129878, 35.66875101369414, False],\\n [-101.83519143957733, 25.873081120803842, False], [-99.97028199969046, 34.58909164776538, False],\\n [-105.71652597027627, 31.489327979058995, True], [-105.79973754647258, 28.65472050301513, False],\\n [-104.61884498465494, 31.131621852439807, True], [-102.57111696065307, 30.114279991888235, True],\\n [-103.32297212967914, 35.236882653404706, False], [-100.4249645463674, 35.01412558025736, True],\\n [-96.2664164425719, 27.27790820412447, False], [-95.49119347312927, 34.04880310368103, False],\\n [-94.76867790780145, 30.68409383373247, True], [-97.33084948761977, 35.987707032142886, False],\\n [-98.9375962329848, 27.590161796852268, True], [-100.24496746645461, 35.14003067100538, True],\\n [-97.82265827697529, 29.12546410605067, True], [-103.60831990499707, 34.420657352069206, False],\\n [-96.6211125945082, 33.06459177171514, True], [-99.74211708967393, 29.148959136838407, True],\\n [-101.74939764896713, 34.474532089579476, True], [-94.34764438114355, 30.357142981363083, True],\\n [-106.52546379307893, 30.041326961454715, False], [-101.2986640335862, 26.37652905898862, False],\\n [-106.4580153687541, 29.87759744762145, False], [-100.89335102135293, 35.52499965140305, True],\\n [-100.8248639994296, 33.40975770839312, True], [-103.93212196016398, 32.909497641552065, False],\\n [-94.67932056126476, 35.15626837470808, False], [-106.02052521025293, 29.597198775376654, False],\\n [-98.2893867410877, 29.93112729119841, True], [-99.89450058695091, 27.938220198829537, True],\\n [-97.3506130624274, 29.943100560338415, True], [-102.20272670412375, 26.935152987528188, False],\\n [-102.76414059461521, 27.054007916590372, False], [-106.0041901594681, 34.50108734620676, False],\\n [-99.34960356247895, 30.765691636568544, True], [-93.90991359101918, 29.52415548605938, False],\\n [-102.45068333144832, 29.498640082146757, False], [-93.52649708202873, 33.25384150278302, False],\\n [-98.11359820029512, 32.661143218490004, True], [-93.64776248509527, 30.4684682460894, False],\\n [-99.4498229748733, 27.335197692456124, True], [-106.3098030711422, 28.114811474983753, False],\\n [-103.19744279212784, 29.761699794107464, True], [-98.04521749365168, 29.23374276253473, True],\\n [-96.02905435107336, 30.127228292010795, True], [-98.51879935475141, 29.632065468973558, True],\\n [-97.51304854653931, 31.509276424390762, True], [-103.29390200939619, 27.318075011416106, False],\\n [-99.9824973213597, 30.110443559920434, True], [-99.50915156948314, 29.258458344281003, True],\\n [-96.41505277249307, 27.81615410871556, False], [-104.15751695040154, 28.634566430199957, False],\\n [-99.54546678775662, 30.628758593109584, True], [-94.501671157283, 26.690164729805314, False],\\n [-99.5998715300248, 29.29963433926709, True], [-96.19407966991072, 26.583996951962845, False],\\n [-94.18130561957514, 34.39183349747304, False], [-99.35457098320595, 29.19418372510661, True],\\n [-103.2439668700228, 28.7415827836878, False], [-95.94946899471344, 26.094846437871187, False],\\n [-96.29555855830898, 35.61463847091715, False], [-100.90818350967113, 32.81839948197739, True],\\n [-103.19547298017221, 33.780381119513564, False], [-103.7311831715452, 34.51901410810771, False],\\n [-104.9802204382533, 27.04133234378543, False], [-97.04516124978682, 26.74522583795225, False],\\n [-99.54055674299795, 30.957712411033505, True], [-100.75291255499768, 34.98555626576464, True],\\n [-103.08923082250261, 33.115219018353876, False], [-94.38102432053655, 33.1179055259896, True],\\n [-102.03982643927137, 29.9838170230828, True], [-105.81904014957023, 28.79765172366808, False],\\n [-96.65811064697854, 29.033441999230575, True], [-94.79391199397416, 32.26686772352405, True],\\n [-94.05970729814709, 27.578098867203245, False], [-101.34732336260434, 31.621990539913554, True],\\n [-104.3518957862908, 29.119881150805877, False], [-94.62935978446168, 30.4280012647268, True],\\n [-94.4545353979626, 35.54695331314244, False], [-95.54556621919373, 36.13412073236616, False],\\n [-95.35828131810126, 29.196029446685102, True], [-94.03367199299583, 29.998249298603696, True],\\n [-106.36092437901962, 35.88480338683122, False], [-104.36739535175568, 34.44871919970392, False],\\n [-101.23847775114616, 33.38670941589996, True], [-99.14984412490651, 33.42882053133658, True],\\n [-103.57375420847947, 36.10822666498764, False], [-105.16720721276594, 35.376479016301516, False],\\n [-97.83947903342955, 27.52109204805256, True], [-98.71405542652877, 35.7689674767476, False],\\n [-103.06998061485356, 34.82880997682268, False], [-105.28204362921868, 28.400435333576176, False],\\n [-94.15911792478674, 26.17595690168265, False], [-96.8089922559183, 28.576299745236, True],\\n [-94.55012730211439, 35.965323310709934, False], [-102.35052435497836, 35.54979117991739, True],\\n [-104.37005549234762, 27.1898216329847, False], [-95.68880266269171, 28.848538713723595, True],\\n [-99.48796021732129, 33.879870610429656, True], [-101.00413095653694, 34.33763822793282, True],\\n [-106.07730385091368, 29.134515491377414, False], [-103.45299952582074, 27.571405818685125, False],\\n [-102.68769661036903, 35.0508397444369, True], [-102.12226125487027, 31.490531154286373, True],\\n [-99.20157845594305, 31.551754104915446, True], [-102.55860273418811, 34.074770794654526, True],\\n [-106.13595097934105, 30.66643783693412, False], [-106.62769073938416, 30.65343353159766, False],\\n [-106.40940133512453, 29.82237466871204, False], [-102.1529566504516, 35.06622589749327, True],\\n [-102.80724491463563, 34.7087445437067, True], [-97.64939497688633, 30.67928132241753, True],\\n [-96.36801227272899, 27.90369756441311, False], [-94.09540454906752, 26.5340311979023, False],\\n [-100.95868651879503, 29.489244579528528, True], [-99.00791521500773, 33.15713091296997, True],\\n [-94.56949551831565, 29.097678237118387, False], [-104.30210679432342, 27.480997154392185, False],\\n [-102.89216000521263, 28.618705789328487, False], [-96.97440058322412, 33.50865616454956, True],\\n [-98.99276448264528, 33.16482908208919, True], [-104.83376414397748, 30.866597558655094, True],\\n [-105.87523535009888, 26.94560046391572, False], [-99.29766049432588, 32.83368387034709, True],\\n [-102.51690788569256, 33.11843291048262, True], [-95.8185042576338, 29.933635250495907, True],\\n [-95.64639798097132, 29.81408328213472, True], [-95.27363238555648, 26.04686490238641, False],\\n [-97.49469880046678, 28.7839351111114, True], [-102.55955572766781, 32.24579142286663, True],\\n [-102.3259956134002, 29.68040823171017, False], [-97.73863157435005, 29.996562088019196, True],\\n [-104.68631893564948, 32.01946765618769, False], [-95.04016163980175, 33.10637289096444, True],\\n [-104.60749147021224, 34.68835575652551, False], [-103.65636297920052, 30.591031777106217, True],\\n [-102.77020591146633, 28.84679685398533, False], [-93.68494562344958, 30.545382533660963, False],\\n [-105.28442207266875, 35.066432824429576, False], [-96.25390521489425, 26.494829177985668, False],\\n [-98.82250217338702, 27.932953025264148, True], [-101.74188578040746, 34.64776869635973, True],\\n [-106.04404882060925, 28.594522513035013, False], [-93.67216964673989, 29.251042306696004, False],\\n [-99.78759245690895, 33.06425606417031, True], [-98.40506092257863, 30.372595091544586, True],\\n [-102.29051625332913, 32.71012257838102, True], [-103.71880332727147, 32.69104459346947, False],\\n [-97.0545647773379, 30.76611952136734, True], [-96.38483633115239, 27.604532811233028, False],\\n [-106.26518681815887, 30.011599887072457, False], [-96.29869292442771, 28.668280098851437, False],\\n [-101.81643591481892, 26.171067127237418, False], [-99.84342847150265, 26.017698064471553, False],\\n [-104.11331752582073, 29.654316762816297, True], [-99.97301004853021, 27.730105527140825, False],\\n [-106.31647836713242, 32.17703231405249, False], [-105.53511133815337, 26.702440097120153, False],\\n [-96.73532103327318, 35.78642691945332, False], [-99.1113903696459, 34.40215160301135, False],\\n [-105.57490309093876, 36.00074957169259, False], [-96.91408056656418, 32.50309840505817, True],\\n [-97.12004011524724, 26.947775539446376, False], [-104.31177621433217, 28.977811712282257, False],\\n [-94.2821165561003, 30.71331882514141, True], [-98.29146997158631, 26.800066299911094, True],\\n [-103.116290122766, 31.46742167424961, True], [-98.56811800705276, 29.888220960970425, True],\\n [-98.08987891135445, 27.80577602559695, True], [-95.34430060625397, 35.0872381937164, False],\\n [-97.29977470332764, 28.838558342329026, True], [-99.29340339460651, 32.1659999533891, True],\\n [-98.45946176172794, 35.06767544568288, False], [-97.28077383253662, 30.77329811793486, True],\\n [-103.2046478070315, 33.95113909648831, False], [-97.41533999785908, 32.08647437970406, True],\\n [-106.24449926545937, 26.923081786350345, False], [-97.29470564456045, 36.18937223503928, False],\\n [-97.66122972103732, 34.56870670469234, False], [-102.35020419742744, 27.349690061784784, False],\\n [-93.77154189004054, 33.43617694637923, False], [-101.35103101345337, 29.463692272605073, False],\\n [-101.62926979404627, 32.803732493055875, True], [-94.90780742661717, 27.023519182303016, False],\\n [-106.20392742378257, 32.97382450322062, False], [-100.31113315995306, 29.431049347619815, True],\\n [-101.26240055732195, 36.148817757576396, True], [-98.42727511780691, 27.460837740553018, True],\\n [-98.57534771820664, 35.599414672044254, False], [-97.62020154014516, 26.369709082738453, True],\\n [-103.2986841163323, 32.6157912851791, False], [-93.93578337162835, 34.486048529590185, False],\\n [-93.64615854059947, 28.5736836659404, False], [-96.99391123102941, 28.896993703684423, True],\\n [-102.45723986918175, 35.7010832684699, True], [-105.25314374574465, 26.38581255615052, False],\\n [-100.2188547460063, 28.291673320576088, True], [-100.7877537462725, 34.49341196472571, True],\\n [-106.45021897380575, 26.72924721086809, False], [-105.02103129126913, 30.757125052138996, True],\\n [-98.53860937298697, 32.45578723025558, True], [-99.57879415297293, 33.96386507864504, True],\\n [-93.7378357236408, 27.9626758279968, False], [-100.63489750669079, 35.38304941928768, True],\\n [-106.59421404071085, 30.052955341162452, False], [-106.59172119923385, 35.689363691993364, False],\\n [-97.34149801358657, 32.67880291850629, True], [-94.73963101360403, 27.850819649646564, False],\\n [-100.94403277172583, 33.474538412919046, True], [-99.27226009251935, 27.468315184289615, True],\\n [-100.4539129843546, 34.591160165118865, True], [-106.44494557869739, 28.035999053683224, False],\\n [-94.23984184184754, 29.557288201626776, False], [-99.03587934877508, 26.59598428059316, True],\\n [-99.74353348891233, 32.82386415542986, True], [-101.86634664448142, 35.898545381710065, True],\\n [-104.82904170889573, 35.68593461490256, False], [-102.883660082079, 25.927764876566876, False],\\n [-95.10167954830852, 29.132555432953012, False], [-104.16716765381528, 32.54432440506069, False],\\n [-95.8001698490917, 30.554039020076594, True], [-98.25774265085879, 30.67468293710671, True],\\n [-104.14549182637904, 36.13448211420454, False], [-100.79273106998009, 27.687205570475957, False],\\n [-97.9031540972447, 34.04156602854073, False], [-99.48655188258273, 36.01928708820145, False],\\n [-103.78885086741725, 26.649573815350735, False], [-97.54897028080592, 26.611495630090587, True],\\n [-106.18533271033974, 26.521041809084632, False], [-102.04736124316179, 35.80143440960038, True],\\n [-103.53014416761859, 35.94251011771925, False], [-106.37072741181773, 33.56020830971726, False],\\n [-100.5087744739241, 33.68691572355519, True], [-103.14684873740707, 30.33159482347187, True],\\n [-101.04498614381122, 34.01935100090506, True], [-99.23406810345234, 36.47780260248638, False],\\n [-96.38309061733807, 28.10204238295031, False], [-106.04814322602003, 30.009165824440764, False],\\n [-99.09937261770088, 36.27541704541078, False], [-94.9236280439113, 26.908216725432283, False],\\n [-96.03138446605873, 29.48956628516225, True], [-101.79748242792357, 36.2396677016486, True],\\n [-96.7954152001291, 28.981691254375008, True], [-95.95383982488345, 33.80047001504878, True],\\n [-103.89568070095685, 26.027352965725004, False], [-104.33069038138268, 36.46092136221017, False],\\n [-99.40487331382435, 33.362496703874385, True], [-98.0390467871466, 27.286158481267943, True],\\n [-103.93051493329094, 36.21025032666974, False], [-100.89036166271175, 29.431712359982495, True],\\n [-103.01093811284001, 28.951789475547162, False], [-105.6925789844033, 26.67611273491844, False],\\n [-100.63232815476351, 35.18180560295863, True], [-95.84068243438212, 26.566440681951057, False],\\n [-101.69166851142406, 27.58570691504354, False], [-96.39192036000713, 30.76580153991847, True],\\n [-99.60575587904657, 32.844854917935244, True], [-99.88359268023875, 26.427305650516256, False],\\n [-102.49870407406512, 35.670387195714135, True], [-99.02838249064023, 34.35433748751913, False],\\n [-93.69511330973809, 28.964334494491123, False], [-102.77438414412866, 34.77587690396507, True],\\n [-97.20637129262126, 28.62351031644859, True], [-97.20760493091282, 29.66509727888832, True],\\n [-97.78279263302204, 28.650053248724216, True], [-105.10373645902229, 30.10605688088612, False],\\n [-102.29320671455936, 34.913227698065626, True], [-102.08456452797166, 35.04888378920539, True],\\n [-97.684013792577, 35.91610190976283, False], [-94.66766997135741, 28.388037123223707, False],\\n [-93.51699445904997, 30.745955788402362, False], [-100.56415276925733, 27.122598143422042, False],\\n [-105.51909002313077, 30.081775705006855, False], [-95.57290373716107, 26.724672719886662, False],\\n [-103.50352867348445, 32.004206585428776, True], [-102.8747549124684, 32.8979077719816, True],\\n [-94.54178731632837, 28.121556170094824, False], [-105.1852492618114, 34.57852818651511, False],\\n [-101.56833897599279, 32.394936636984475, True], [-102.06612007055514, 30.0654558718264, True],\\n [-104.27037065814437, 26.539037110206124, False], [-96.84449118726283, 34.303252013399494, False],\\n [-100.21448448808589, 31.640102623719255, True], [-105.11541407363484, 32.59032999242083, False],\\n [-102.47865996013053, 36.106193753181586, True], [-102.1982854302976, 30.87389402879236, True],\\n [-103.75935920410515, 34.164405398206384, False], [-100.26058874460439, 29.97152621245525, True],\\n [-99.98584687760041, 29.138422331875738, True], [-98.8136163575852, 31.471193466135066, True],\\n [-98.2634703260477, 34.441857423457066, False], [-101.31389165577758, 26.67722696068761, False],\\n [-105.25939274478021, 33.42397682936403, False], [-95.42401575533701, 36.38213160460099, False],\\n [-93.7911156924766, 26.16919479726154, False], [-106.0793837632488, 32.0426040667038, False],\\n [-101.67576371230456, 26.55813999428948, False], [-105.29328020590933, 33.317961711071874, False],\\n [-106.6282733323151, 26.640651252579072, False], [-100.97693002993205, 29.778473204159543, True],\\n [-99.81270323613123, 28.521657399940562, True], [-106.35993676923691, 32.47765856951956, False],\\n [-98.6318807925877, 27.313103487591995, True], [-105.60269402006043, 33.9266565877851, False],\\n [-96.50522425362368, 33.17862810486471, True], [-99.36585657273703, 27.918462376378407, True],\\n [-102.71165541572611, 27.26977019467567, False], [-105.26203795210641, 33.50921690053216, False],\\n [-105.45340320249285, 28.841949098625847, False], [-97.67986158008269, 31.45298937828147, True],\\n [-95.42927279657806, 30.012853799790946, True], [-94.61186352922475, 30.990817003676423, True],\\n [-98.75882027588506, 33.21933322666259, True], [-104.55525321655045, 36.35184775125859, False],\\n [-97.39087680042095, 29.262712771446328, True], [-95.32479451597851, 32.558534263953774, True],\\n [-96.17652314621081, 34.39156129414083, False], [-99.95318514227759, 29.206707699022903, True],\\n [-105.32756527254323, 29.177591819396113, False], [-104.63110828519505, 35.14036164405956, False],\\n [-101.75109732251778, 30.720543376919306, True], [-98.43013838260205, 28.14394272715192, True],\\n [-97.0734335255207, 28.750007474412804, True], [-103.21154248047685, 32.22703974346086, False],\\n [-102.39810543632244, 32.819942719538474, True], [-103.36259451330584, 27.176657526494928, False],\\n [-103.66650593230085, 36.025520559005244, False], [-101.63539174258722, 27.803279475131447, False],\\n [-96.34811589893562, 31.14578417358513, True], [-98.94976448687677, 31.767797366700666, True],\\n [-97.38029827656692, 36.27728736453143, False], [-95.93103949592769, 28.74450380455483, True],\\n [-98.8151117128684, 34.70259233670797, False], [-96.14623746963383, 30.48841309287015, True],\\n [-101.46340647601903, 30.19511307273737, True], [-100.63602533061145, 31.749219881531914, True],\\n [-101.63505098125265, 33.69021849156649, True], [-94.71406829659445, 31.90061330594235, True]\\n ]\\n for p in points:\\n assert p[2] == qtssr_texas.contains_point((p[0], p[1]))\",\n \"def bend_s(\\n size: Float2 = (10.0, 2.0),\\n nb_points: int = 99,\\n with_cladding_box: bool = True,\\n cross_section: CrossSectionFactory = strip,\\n **kwargs\\n) -> Component:\\n dx, dy = size\\n x = cross_section(**kwargs)\\n width = x.info[\\\"width\\\"]\\n layer = x.info[\\\"layer\\\"]\\n\\n c = Component()\\n\\n bend = bezier(\\n width=width,\\n control_points=[(0, 0), (dx / 2, 0), (dx / 2, dy), (dx, dy)],\\n npoints=nb_points,\\n layer=layer,\\n )\\n\\n bend_ref = c << bend\\n c.add_ports(bend_ref.ports)\\n c.copy_child_info(bend)\\n c.info[\\\"start_angle\\\"] = bend.info[\\\"start_angle\\\"]\\n c.info[\\\"end_angle\\\"] = bend.info[\\\"end_angle\\\"]\\n c.info[\\\"length\\\"] = bend.info[\\\"length\\\"]\\n c.info[\\\"min_bend_radius\\\"] = bend.info[\\\"min_bend_radius\\\"]\\n\\n if with_cladding_box and x.info[\\\"layers_cladding\\\"]:\\n layers_cladding = x.info[\\\"layers_cladding\\\"]\\n cladding_offset = x.info[\\\"cladding_offset\\\"]\\n points = get_padding_points(\\n component=c,\\n default=0,\\n bottom=cladding_offset,\\n top=cladding_offset,\\n )\\n for layer in layers_cladding or []:\\n c.add_polygon(points, layer=layer)\\n\\n auto_rename_ports(c)\\n return c\",\n \"def create_partition(mesh,polygons,enforce_exact=False):\",\n \"def circular_levelset(shape, center, sqradius, scalerow=1.0):\\n grid = np.mgrid[list(map(slice, shape))].T - center\\n phi = sqradius - np.sqrt(np.sum((grid.T)**2, 0))\\n u = np.float_(phi > 0)\\n return u\",\n \"def test_flip_loop():\\n conv = ToPointsAndSegments()\\n ring = [ (0,0), (3,0), (3.8,2), (4,0), (6,0), (6.3, 2), (7,0), (10,0), (13,4), (10,5), (7,5), (6.5, 3), (6,5), (4,5), (3.5,3), (3,5), (0,5), (-2,2), (0,0)]\\n conv.add_polygon([ring])\\n skel = calc_skel(conv, pause=True, output=True)\",\n \"def test_conv_full(self):\\n\\n points = np.array([[1, 4], [2, 1], [3, 2], [3, 3], [3, 5], [4, 2], [5, 1], [5, 3]]) # example of points \\n \\n cv_hull = convex_hull.convex_hull(points) # convex hull returned by the function \\n\\n right_conv_hull = np.array([[2, 1], [5, 1], [5, 3], [3, 5], [1, 4], [2, 1] ]) # right convex hull\\n self.assertTrue((right_conv_hull == cv_hull).all())\",\n \"def run(self, verbose=False, build_graph=False):\\n from sage.combinat.crystals.letters import CrystalOfLetters\\n letters = CrystalOfLetters(self.rigged_con.parent()._cartan_type.classical())\\n\\n # This is technically bad, but because the first thing we do is append\\n # an empty list to ret_crystal_path, we correct this. We do it this\\n # way so that we do not have to remove an empty list after the\\n # bijection has been performed.\\n ret_crystal_path = []\\n\\n for dim in self.rigged_con.parent().dims:\\n ret_crystal_path.append([])\\n\\n # Check to see if we are a spinor\\n if dim[0] == self.n:\\n # Perform the spinor bijection by converting to type A_{2n-1}^{(2)}\\n # doing the bijection there and pulling back\\n\\n from sage.combinat.rigged_configurations.bij_type_A2_odd import RCToKRTBijectionTypeA2Odd\\n from sage.combinat.rigged_configurations.rigged_configurations import RiggedConfigurations\\n from sage.combinat.rigged_configurations.rigged_partition import RiggedPartition, RiggedPartitionTypeB\\n \\n # Convert to a type A_{2n-1}^{(2)} RC\\n RC = RiggedConfigurations(['A', 2*self.n-1, 2], self.cur_dims)\\n if verbose:\\n print(\\\"====================\\\")\\n print(repr(RC(*self.cur_partitions, use_vacancy_numbers=True)))\\n print(\\\"--------------------\\\")\\n print(ret_crystal_path)\\n print(\\\"--------------------\\\\n\\\")\\n print(\\\"Applying doubling map\\\\n\\\")\\n # Convert the n-th partition into a regular rigged partition\\n self.cur_partitions[-1] = RiggedPartition(self.cur_partitions[-1]._list,\\n self.cur_partitions[-1].rigging,\\n self.cur_partitions[-1].vacancy_numbers)\\n\\n bij = RCToKRTBijectionTypeA2Odd(RC(*self.cur_partitions, use_vacancy_numbers=True))\\n for i in range(len(self.cur_dims)):\\n if bij.cur_dims[i][0] != self.n:\\n bij.cur_dims[i][1] *= 2\\n for i in range(self.n-1):\\n for j in range(len(bij.cur_partitions[i])):\\n bij.cur_partitions[i]._list[j] *= 2\\n bij.cur_partitions[i].rigging[j] *= 2\\n bij.cur_partitions[i].vacancy_numbers[j] *= 2\\n\\n if build_graph:\\n y = self.rigged_con.parent()(*[x._clone() for x in self.cur_partitions], use_vacancy_numbers=True)\\n self._graph.append([self._graph[-1][1], (y, len(self._graph)), '2x'])\\n \\n # Perform the type A_{2n-1}^{(2)} bijection\\n \\n # Iterate over each column\\n for dummy_var in range(dim[1]):\\n # Split off a new column if necessary\\n if bij.cur_dims[0][1] > 1:\\n bij.cur_dims[0][1] -= 1\\n bij.cur_dims.insert(0, [dim[0], 1])\\n \\n # Perform the corresponding splitting map on rigged configurations\\n # All it does is update the vacancy numbers on the RC side\\n for a in range(self.n):\\n bij._update_vacancy_numbers(a)\\n\\n if build_graph:\\n y = self.rigged_con.parent()(*[x._clone() for x in self.cur_partitions], use_vacancy_numbers=True)\\n self._graph.append([self._graph[-1][1], (y, len(self._graph)), 'ls'])\\n \\n while bij.cur_dims[0][0] > 0:\\n if verbose:\\n print(\\\"====================\\\")\\n print(repr(RC(*bij.cur_partitions, use_vacancy_numbers=True)))\\n print(\\\"--------------------\\\")\\n print(ret_crystal_path)\\n print(\\\"--------------------\\\\n\\\")\\n\\n bij.cur_dims[0][0] -= 1 # This takes care of the indexing\\n b = bij.next_state(bij.cur_dims[0][0])\\n # Make sure we have a crystal letter\\n ret_crystal_path[-1].append(letters(b)) # Append the rank\\n\\n if build_graph:\\n y = self.rigged_con.parent()(*[x._clone() for x in self.cur_partitions], use_vacancy_numbers=True)\\n self._graph.append([self._graph[-1][1], (y, len(self._graph)), letters(b)])\\n\\n bij.cur_dims.pop(0) # Pop off the leading column\\n\\n self.cur_dims.pop(0) # Pop off the spin rectangle\\n\\n self.cur_partitions = bij.cur_partitions\\n # Convert the n-th partition back into the special type B one\\n self.cur_partitions[-1] = RiggedPartitionTypeB(self.cur_partitions[-1])\\n\\n # Convert back to a type B_n^{(1)}\\n if verbose:\\n print(\\\"====================\\\")\\n print(repr(self.rigged_con.parent()(*bij.cur_partitions, use_vacancy_numbers=True)))\\n print(\\\"--------------------\\\")\\n print(ret_crystal_path)\\n print(\\\"--------------------\\\\n\\\")\\n print(\\\"Applying halving map\\\\n\\\")\\n\\n for i in range(self.n-1):\\n for j in range(len(self.cur_partitions[i])):\\n self.cur_partitions[i]._list[j] //= 2\\n self.cur_partitions[i].rigging[j] //= 2\\n self.cur_partitions[i].vacancy_numbers[j] //= 2\\n\\n if build_graph:\\n y = self.rigged_con.parent()(*[x._clone() for x in self.cur_partitions], use_vacancy_numbers=True)\\n self._graph.append([self._graph[-1][1], (y, len(self._graph)), '1/2x'])\\n else:\\n # Perform the regular type B_n^{(1)} bijection\\n\\n # Iterate over each column\\n for dummy_var in range(dim[1]):\\n # Split off a new column if necessary\\n if self.cur_dims[0][1] > 1:\\n if verbose:\\n print(\\\"====================\\\")\\n print(repr(self.rigged_con.parent()(*self.cur_partitions, use_vacancy_numbers=True)))\\n print(\\\"--------------------\\\")\\n print(ret_crystal_path)\\n print(\\\"--------------------\\\\n\\\")\\n print(\\\"Applying column split\\\")\\n\\n self.cur_dims[0][1] -= 1\\n self.cur_dims.insert(0, [dim[0], 1])\\n\\n # Perform the corresponding splitting map on rigged configurations\\n # All it does is update the vacancy numbers on the RC side\\n for a in range(self.n):\\n self._update_vacancy_numbers(a)\\n\\n if build_graph:\\n y = self.rigged_con.parent()(*[x._clone() for x in self.cur_partitions], use_vacancy_numbers=True)\\n self._graph.append([self._graph[-1][1], (y, len(self._graph)), '2x'])\\n\\n while self.cur_dims[0][0] > 0:\\n if verbose:\\n print(\\\"====================\\\")\\n print(repr(self.rigged_con.parent()(*self.cur_partitions, use_vacancy_numbers=True)))\\n print(\\\"--------------------\\\")\\n print(ret_crystal_path)\\n print(\\\"--------------------\\\\n\\\")\\n\\n self.cur_dims[0][0] -= 1 # This takes care of the indexing\\n b = self.next_state(self.cur_dims[0][0])\\n\\n # Make sure we have a crystal letter\\n ret_crystal_path[-1].append(letters(b)) # Append the rank\\n\\n if build_graph:\\n y = self.rigged_con.parent()(*[x._clone() for x in self.cur_partitions], use_vacancy_numbers=True)\\n self._graph.append([self._graph[-1][1], (y, len(self._graph)), letters(b)])\\n\\n self.cur_dims.pop(0) # Pop off the leading column\\n\\n if build_graph:\\n self._graph.pop(0) # Remove the dummy at the start\\n from sage.graphs.digraph import DiGraph\\n from sage.graphs.dot2tex_utils import have_dot2tex\\n self._graph = DiGraph(self._graph)\\n if have_dot2tex():\\n self._graph.set_latex_options(format=\\\"dot2tex\\\", edge_labels=True)\\n\\n return self.KRT(pathlist=ret_crystal_path)\",\n \"def drawcutline(f,layernamelist,cutline_entities_count): \\r\\n \\r\\n #layernamelist=[layernamelist[0]] \\r\\n layercount=0\\r\\n ringlist=[[[-0.215+globalconfig.CUTLINE_X_OFFSET,0.0+globalconfig.CUTLINE_Y_OFFSET],[0.215+globalconfig.CUTLINE_X_OFFSET,0.0+globalconfig.CUTLINE_Y_OFFSET]],\\r\\n [[-0.215+globalconfig.CUTLINE_X_OFFSET,171.68+globalconfig.CUTLINE_Y_OFFSET],[0.215+globalconfig.CUTLINE_X_OFFSET,171.68+globalconfig.CUTLINE_Y_OFFSET]],\\r\\n [[-0.215+globalconfig.CUTLINE_X_OFFSET,175.68+globalconfig.CUTLINE_Y_OFFSET],[0.215+globalconfig.CUTLINE_X_OFFSET,175.68+globalconfig.CUTLINE_Y_OFFSET]],\\r\\n [[171.4650+globalconfig.CUTLINE_X_OFFSET,0.0+globalconfig.CUTLINE_Y_OFFSET],[171.8950+globalconfig.CUTLINE_X_OFFSET,0.0+globalconfig.CUTLINE_Y_OFFSET]],\\r\\n [[171.4650+globalconfig.CUTLINE_X_OFFSET,171.68+globalconfig.CUTLINE_Y_OFFSET],[171.8950+globalconfig.CUTLINE_X_OFFSET,171.68+globalconfig.CUTLINE_Y_OFFSET]]]\\r\\n flashlist=buildflashlist()\\r\\n cutlineset=buildcutlineset() \\r\\n \\r\\n f.write(\\\"0\\\\nSECTION\\\\n2\\\\nENTITIES\\\\n\\\")\\r\\n \\r\\n for layername in layernamelist:\\r\\n layercount=layercount+1\\r\\n for polyline in cutlineset:\\r\\n cutline_entities_count=cutline_entities_count+1\\r\\n f.write(\\\"0\\\\nPOLYLINE\\\\n8\\\\n\\\"+layername+\\\"\\\\n5\\\\n\\\"+hex(cutline_entities_count)[2:]) # begin writing a polyline\\r\\n f.write(\\\"\\\\n66\\\\n1\\\\n10\\\\n0.0\\\\n20\\\\n0.0\\\\n30\\\\n0.0\\\\n40\\\\n0.08\\\\n41\\\\n0.08\\\\n\\\")\\r\\n cutline_entities_count=drawwidthpolyline(polyline, cutline_entities_count, f,layername)\\r\\n cutline_entities_count=drawring(ringlist, cutline_entities_count, f, layername)\\r\\n cutline_entities_count=drawflash(flashlist, cutline_entities_count, f, layername)\\r\\n cutline_entities_count=drawtext(cutline_entities_count, f, layername,layercount)\\r\\n \\r\\n return cutline_entities_count\",\n \"def ring(self):\\n pass\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.5674478","0.5674478","0.5592306","0.55478907","0.54318386","0.541907","0.5385598","0.53693736","0.53376484","0.5288099","0.5281223","0.52626747","0.5222897","0.51526165","0.51446766","0.5129756","0.5091278","0.50819427","0.5051377","0.504616","0.5023189","0.50142473","0.5006452","0.49858043","0.49526927","0.49513194","0.49437964","0.49404302","0.49381906","0.49336398","0.4931854","0.4922533","0.49110824","0.49037677","0.49007276","0.48780674","0.48689452","0.48684296","0.48644233","0.48636612","0.4860678","0.4856839","0.48558828","0.4851151","0.48372698","0.4836903","0.48313594","0.4825598","0.48252603","0.4814567","0.480609","0.48060048","0.4786226","0.47791535","0.4778875","0.4772403","0.47677624","0.4766615","0.47622868","0.47564024","0.47524434","0.4745822","0.47378907","0.47277936","0.472643","0.47262532","0.4721874","0.4711889","0.47073716","0.47070274","0.47045282","0.46998048","0.4695135","0.46918246","0.4689094","0.4688858","0.468512","0.46764058","0.467461","0.46725762","0.4664061","0.46630245","0.46390742","0.4631841","0.46314904","0.46249622","0.4616531","0.46158284","0.46143365","0.46142808","0.46120992","0.4610441","0.46103576","0.4609429","0.46081138","0.45990577","0.45948923","0.45931622","0.45861438","0.4585924","0.45808345"],"string":"[\n \"0.5674478\",\n \"0.5674478\",\n \"0.5592306\",\n \"0.55478907\",\n \"0.54318386\",\n \"0.541907\",\n \"0.5385598\",\n \"0.53693736\",\n \"0.53376484\",\n \"0.5288099\",\n \"0.5281223\",\n \"0.52626747\",\n \"0.5222897\",\n \"0.51526165\",\n \"0.51446766\",\n \"0.5129756\",\n \"0.5091278\",\n \"0.50819427\",\n \"0.5051377\",\n \"0.504616\",\n \"0.5023189\",\n \"0.50142473\",\n \"0.5006452\",\n \"0.49858043\",\n \"0.49526927\",\n \"0.49513194\",\n \"0.49437964\",\n \"0.49404302\",\n \"0.49381906\",\n \"0.49336398\",\n \"0.4931854\",\n \"0.4922533\",\n \"0.49110824\",\n \"0.49037677\",\n \"0.49007276\",\n \"0.48780674\",\n \"0.48689452\",\n \"0.48684296\",\n \"0.48644233\",\n \"0.48636612\",\n \"0.4860678\",\n \"0.4856839\",\n \"0.48558828\",\n \"0.4851151\",\n \"0.48372698\",\n \"0.4836903\",\n \"0.48313594\",\n \"0.4825598\",\n \"0.48252603\",\n \"0.4814567\",\n \"0.480609\",\n \"0.48060048\",\n \"0.4786226\",\n \"0.47791535\",\n \"0.4778875\",\n \"0.4772403\",\n \"0.47677624\",\n \"0.4766615\",\n \"0.47622868\",\n \"0.47564024\",\n \"0.47524434\",\n \"0.4745822\",\n \"0.47378907\",\n \"0.47277936\",\n \"0.472643\",\n \"0.47262532\",\n \"0.4721874\",\n \"0.4711889\",\n \"0.47073716\",\n \"0.47070274\",\n \"0.47045282\",\n \"0.46998048\",\n \"0.4695135\",\n \"0.46918246\",\n \"0.4689094\",\n \"0.4688858\",\n \"0.468512\",\n \"0.46764058\",\n \"0.467461\",\n \"0.46725762\",\n \"0.4664061\",\n \"0.46630245\",\n \"0.46390742\",\n \"0.4631841\",\n \"0.46314904\",\n \"0.46249622\",\n \"0.4616531\",\n \"0.46158284\",\n \"0.46143365\",\n \"0.46142808\",\n \"0.46120992\",\n \"0.4610441\",\n \"0.46103576\",\n \"0.4609429\",\n \"0.46081138\",\n \"0.45990577\",\n \"0.45948923\",\n \"0.45931622\",\n \"0.45861438\",\n \"0.4585924\",\n \"0.45808345\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":89887,"cells":{"query":{"kind":"string","value":"Checks that the coolant channels are placed at the correct azimuthal placement angles for a given start angle."},"document":{"kind":"string","value":"def test_start_angle(self):\n\n assert self.test_shape.azimuth_placement_angle == [\n 0,\n 45,\n 90,\n 135,\n 180,\n 225,\n 270,\n 315,\n ]\n self.test_shape.start_angle = 10\n assert self.test_shape.azimuth_placement_angle == [\n 10,\n 55,\n 100,\n 145,\n 190,\n 235,\n 280,\n 325,\n ]"},"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 check_angle_of_arcs(self):\n\n if self.thin_arc_start_angle >= 3600:\n self.thin_arc_start_angle %= 360\n self.thin_arc_start_angle += 360\n\n elif self.thin_arc_start_angle <= -3600:\n self.thin_arc_start_angle %= 360\n self.thin_arc_start_angle -= 360\n\n if self.thin_arc_end_angle >= 3600:\n self.thin_arc_end_angle %= 360\n self.thin_arc_end_angle += 360\n\n elif self.thin_arc_end_angle <= -3600:\n self.thin_arc_end_angle %= 360\n self.thin_arc_end_angle -= 360\n\n if self.thick_arc_start_angle >= 3600:\n self.thick_arc_start_angle %= 360\n self.thick_arc_start_angle += 360\n\n elif self.thick_arc_start_angle <= -3600:\n self.thick_arc_start_angle %= 360\n self.thick_arc_start_angle -= 360\n\n if self.thick_arc_end_angle >= 3600:\n self.thick_arc_end_angle %= 360\n self.thick_arc_end_angle += 360\n\n elif self.thick_arc_end_angle <= -3600:\n self.thick_arc_end_angle %= 360\n self.thick_arc_end_angle -= 360","def CheckClearance(self, via, area, clearance):\r\n p1 = via.GetPosition()\r\n corners = area.GetNumCorners()\r\n # Calculate minimum distance from corners\r\n # TODO: remove?\r\n for i in range(corners):\r\n corner = area.GetCornerPosition(i)\r\n p2 = corner.getWxPoint()\r\n the_distance = norm(p2 - p1) # sqrt((p2.x - p1.x) ** 2 + (p2.y - p1.y) ** 2)\r\n\r\n if the_distance < clearance:\r\n return False\r\n\r\n for i in range(corners):\r\n corner1 = area.GetCornerPosition(i)\r\n corner2 = area.GetCornerPosition((i + 1) % corners)\r\n pc1 = corner1.getWxPoint()\r\n pc2 = corner2.getWxPoint()\r\n the_distance, _ = pnt2line(p1, pc1, pc2)\r\n\r\n if the_distance <= clearance:\r\n return False\r\n\r\n for edge in self.board_edges:\r\n if edge.ShowShape() == 'Line':\r\n the_distance, _ = pnt2line(p1, edge.GetStart(), edge.GetEnd())\r\n if the_distance <= clearance + via.GetWidth() / 2:\r\n return False\r\n if edge.ShowShape() == 'Arc':\r\n # distance from center of Arc and with angle within Arc angle should be outside Arc radius +- clearance + via Width/2\r\n center = edge.GetPosition()\r\n start = edge.GetStart()\r\n end = edge.GetEnd()\r\n radius = norm(center - end)\r\n dist = norm(p1 - center)\r\n if radius - (self.clearance + via.GetWidth() / 2) < dist < radius + (\r\n self.clearance + via.GetWidth() / 2):\r\n # via is in range need to check the angle\r\n start_angle = math.atan2((start - center).y, (start - center).x)\r\n end_angle = math.atan2((end - center).y, (end - center).x)\r\n if end_angle < start_angle:\r\n end_angle += 2 * math.pi\r\n point_angle = math.atan2((p1 - center).y, (p1 - center).x)\r\n if start_angle <= point_angle <= end_angle:\r\n return False\r\n\r\n return True","def _check_zone_locks(self, start, end):\n color = self._board[start]\n goal = CheckersGame.opposite[color]\n\n start_zone = FULL_BOARD[start]\n end_zone = FULL_BOARD[end]\n\n # You can always get into your own goal\n # and you can always move within a zone.\n if end_zone == start_zone or end_zone == goal:\n return True\n # So now we can assume they changed zones.\n # And that if they're in a goal, it's not their own.\n\n # The first rule is that if a piece is in *its destination goal*,\n # it can't be moved outside of it.\n # The second rule is that we may not move into a zone which is\n # another player's spawn or goal\n if start_zone == goal or end_zone == color:\n return False\n return True","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 check_intercalation(coordat_list, all_coordats):\n metal_coords = [0.0, 0.0, 0.0]\n coordats = np.array(coordat_list)\n if len(coordats) > 1:\n all_coordats = np.array(all_coordats)\n test_coordats = []\n for coord in all_coordats: # Remove matched coordatoms from full list.\n good = True\n for coordat in coordats:\n if np.linalg.norm(coord-coordat) < 1e-12:\n good = False\n if good:\n test_coordats.append(coord)\n test_coordats = np.array(test_coordats)\n intercalating = False\n for pair in itertools.combinations(coordats, 2): # Take pairs of coord atoms\n if get_angle(pair[0], metal_coords, pair[1]) < 121: # If the angle is less than 121 check for intercalation\n midvect = (pair[0] + pair[1]) # Take the midpoint vector between the two cord points\n for coordat in test_coordats: # Test the remaining coordintion sites\n if get_angle(midvect, metal_coords, coordat) < 30:\n # If any of the points are within 30 degrees of the midpoint\n # Flag as intercalating\n intercalating = True\n else:\n intercalating = False\n return intercalating","def cooling_system_is_ac(bpr):\n\n if bpr.hvac['type_cs'] in {'T2', 'T3'}: # mini-split ac and central ac\n return True\n elif bpr.hvac['type_cs'] in {'T0', 'T1'}:\n return False\n else:\n print('Error: Unknown cooling system')\n return False","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_angle():\n # radians\n theta_coord = 45. * coord.degrees\n theta_astro = astropy.coordinates.Angle(pi/4., units.radian)\n\n # degrees\n np.testing.assert_almost_equal(theta_coord.rad, theta_astro.rad, decimal=12)\n np.testing.assert_almost_equal(theta_coord / coord.degrees, theta_astro.degree, decimal=12)\n np.testing.assert_almost_equal(theta_coord / coord.hours, theta_astro.hour, decimal=12)\n np.testing.assert_almost_equal(theta_coord / coord.arcmin, theta_astro.arcminute, decimal=12)\n np.testing.assert_almost_equal(theta_coord / coord.arcsec, theta_astro.arcsec, decimal=12)\n\n # Other constructors\n theta_astro2 = astropy.coordinates.Angle(23.09, units.arcsec)\n theta_coord2 = coord.Angle(23.09, coord.arcsec)\n np.testing.assert_almost_equal(theta_coord2.rad, theta_astro2.rad, decimal=12)\n\n theta_astro3 = astropy.coordinates.Angle(-0.17, unit='rad')\n theta_coord3 = coord._Angle(-0.17)\n np.testing.assert_almost_equal(theta_coord3.rad, theta_astro3.rad, decimal=12)\n\n # astropy wrapping uses a different convention than we do. Their argument is\n # the upper end of the target range, not the center.\n theta_astro4 = theta_astro3.wrap_at(360 * units.deg)\n theta_coord4 = theta_coord3.wrap(180 * coord.degrees)\n np.testing.assert_almost_equal(theta_coord4.rad, theta_astro4.rad, decimal=12)\n\n theta_astro5 = theta_astro3.wrap_at(-100 * units.deg)\n theta_coord5 = theta_coord3.wrap(-280 * coord.degrees)\n np.testing.assert_almost_equal(theta_coord5.rad, theta_astro5.rad, decimal=12)\n\n theta_astro6 = astropy.coordinates.Angle('03:34:12', unit='hourangle')\n theta_coord6 = coord.Angle.from_hms('03:34:12')\n np.testing.assert_almost_equal(theta_coord6.rad, theta_astro6.rad, decimal=12)\n\n theta_astro7 = astropy.coordinates.Angle('03:34:12', unit='deg')\n theta_coord7 = coord.Angle.from_dms('03:34:12')\n np.testing.assert_almost_equal(theta_coord7.rad, theta_astro7.rad, decimal=12)\n\n # Their default arguments to to_string are different from ours, but can make them compatible.\n print('theta_astro6.hms = ',theta_astro6.to_string(sep=':', pad=True))\n print('theta_coord6.hms = ',theta_coord6.hms())\n assert theta_coord6.hms() == theta_astro6.to_string(sep=':', pad=True)\n\n print('theta_astro7.dms = ',theta_astro7.to_string(sep=':', pad=True))\n print('theta_coord7.dms = ',theta_coord7.dms())\n assert theta_coord7.dms() == theta_astro7.to_string(sep=':', pad=True)\n\n print('theta_astro6.hms = ',theta_astro6.to_string())\n print('theta_coord6.hms = ',theta_coord6.hms(sep='hms', pad=False))\n assert theta_coord6.hms(sep='hms', pad=False) == theta_astro6.to_string()\n\n print('theta_astro7.hms = ',theta_astro7.to_string())\n print('theta_coord7.hms = ',theta_coord7.dms(sep='dms', pad=False))\n assert theta_coord7.dms(sep='dms', pad=False) == theta_astro7.to_string()","def test_center(self):\n\n self.assertTrue((self.cs.center == np.array([[0], [0]])).all())","def can_left_arc(c, correct_arcs):\n try:\n return Arc(c.buffer[0], c.sentence[c.stack[-1]].deprel, c.stack[-1]) in correct_arcs\n except IndexError:\n return False","def checkForCircle(self, points, tangents):\n if len(points)<10:\n return False, 0\n\n if all(points[0]==points[-1]): # last exactly equals the first.\n # Ignore last point for this check\n points = points[:-1]\n tangents = tangents[:-1]\n #print 'Removed last ', points\n xmin,ymin, w, h = computeBox( points)\n diag2=(w*w+h*h)\n \n diag = sqrt(diag2)*0.5\n norms = numpy.sqrt(numpy.sum( tangents**2, 1 ))\n\n angles = numpy.arctan2( tangents[:,1], tangents[:,0] ) \n #debug( 'angle = ', repr(angles))\n N = len(angles)\n \n deltas = points[1:] - points[:-1] \n deltasD = numpy.concatenate([ [D(points[0],points[-1])/diag], numpy.sqrt(numpy.sum( deltas**2, 1 )) / diag] )\n\n # locate and avoid the point when swicthing\n # from -pi to +pi. The point is around the minimum\n imin = numpy.argmin(angles)\n debug(' imin ',imin)\n angles = numpy.roll(angles, -imin)\n deltasD = numpy.roll(deltasD, -imin)\n n=int(N*0.1)\n # avoid fluctuations by removing points around the min\n angles=angles[n:-n]\n deltasD=deltasD[n:-n]\n deltasD = deltasD.cumsum()\n N = len(angles)\n\n # smooth angles to avoid artificial bumps\n angles = smoothArray(angles, n=max(int(N*0.03),2) )\n\n deltaA = angles[1:] - angles[:-1]\n deltasDD = (deltasD[1:] -deltasD[:-1])\n deltasDD[numpy.where(deltasDD==0.)] = 1e-5*deltasD[0]\n dAdD = abs(deltaA/deltasDD)\n belowT, count = True,0\n for v in dAdD:\n if v>6 and belowT:\n count+=1\n belowT = False\n belowT= (v<6)\n\n self.temp = (deltasD,angles, tangents, dAdD )\n fracStraight = numpy.sum(deltasDD[numpy.where(dAdD<0.3)])/(deltasD[-1]-deltasD[0])\n curveLength = deltasD[-1]/3.14\n #print \"SSS \",count , fracStraight\n if curveLength> 1.4 or fracStraight>0.4 or count > 6:\n isCircle =False\n else: \n isCircle= (count < 4 and fracStraight<=0.3) or \\\n (fracStraight<=0.1 and count<5)\n\n if not isCircle:\n return False, 0\n \n # It's a circle !\n radius = points - numpy.array([xmin+w*0.5,ymin+h*0.5])\n radius_n = numpy.sqrt(numpy.sum( radius**2, 1 )) # normalize\n\n mini = numpy.argmin(radius_n) \n rmin = radius_n[mini]\n maxi = numpy.argmax(radius_n) \n rmax = radius_n[maxi]\n # void points around maxi and mini to make sure the 2nd max is found\n # on the \"other\" side\n n = len(radius_n)\n radius_n[maxi]=0 \n radius_n[mini]=0 \n for i in range(1,n/8+1):\n radius_n[(maxi+i)%n]=0\n radius_n[(maxi-i)%n]=0\n radius_n[(mini+i)%n]=0\n radius_n[(mini-i)%n]=0\n radius_n_2 = [ r for r in radius_n if r>0]\n rmax_2 = max(radius_n_2)\n rmin_2 = min(radius_n_2) # not good !!\n anglemax = numpy.arccos( radius[maxi][0]/rmax)*numpy.sign(radius[maxi][1])\n return True, (xmin+w*0.5,ymin+h*0.5, 0.5*(rmin+rmin_2), 0.5*(rmax+rmax_2), anglemax)","def is_angle_valid(self, angle):\n\n self.random_range = list(np.array(self.friendly_range) * self.conversion)\n if (angle < self.random_range[0]) or (angle > self.random_range[1]):\n return False\n else:\n return True","def is_on_course_with(start, heading, target):\n v = Volant(*(tuple(start) + (heading,)))\n\n if start == target:\n return True\n \n for _ in range(distance_between_hex_cells(start, target)):\n v = v.advance()\n if v.xyh == (tuple(target) + (heading,)):\n return True\n\n return False","def isAcute(trpl):\n vd = vectorFormat(trpl)\n if angle_between(*vd) < np.pi/2:\n return True\n else:\n return False","def arccenter(c):\n start=c[1][1] \n end=c[1][2]\n if start == 0 and end == 360:\n return c[0]\n else:\n return samplearc(c,0.5)","def test_accel_centripetal(self):\n for deg in np.linspace(0, 360, 9):\n self.assertEqual(ab[2,0].subs(psi, deg*pi/180).\\\n subs(phi, 60*pi/180).\\\n subs(theta,0).\\\n subs(g, 1).evalf(), -2.0)\n self.assertEqual(ab[2,0].subs(psi, deg*pi/180).\\\n subs(phi, -60*pi/180).\\\n subs(theta,0).\\\n subs(g, 1).evalf(), -2.0)\n # Coordinated turn should only have accel in body z direction.\n # Check that x and y are zero.\n for ax in range(2):\n val = ab[ax,0].subs(psi, deg*pi/180).\\\n subs(phi, 60*pi/180).\\\n subs(theta,0).\\\n subs(g, 1).evalf()\n self.assertTrue(np.isclose(float(val), 0.0))\n val = ab[ax,0].subs(psi, deg*pi/180).\\\n subs(phi, -60*pi/180).\\\n subs(theta,0).\\\n subs(g, 1).evalf()\n self.assertTrue(np.isclose(float(val), 0.0))","def is_legal(self, start, end) -> bool:\n return self.board(end) == 0 \\\n and self.board(start) > 0 \\\n and self._check_zone_locks(start, end) \\\n and self.exists_path(start, end)","def test_guider_start_arcsOn(self):\n sopTester.updateModel('mcp', TestHelper.mcpState['arcs'])\n self._guider_start(8, 20, 0, 0)","def isinsidearcXY(c,p):\n\n x = c[0]\n r = c[1][0]\n if dist(x,p) > r:\n return False\n if iscircle(c):\n return True\n start = c[1][1]%360.0\n end = c[1][2]%360.0\n if end < start:\n end+= 360.0\n p2 = sub(p,x)\n ang = (atan2(p2[1],p2[0]) % pi2)*360/pi2\n\n if end <= 360.0:\n return (ang >= start and ang <= end)\n else:\n return ang >= start or ang <= (end-360.0)","def test_point_is_in_arc_range(p):\n arc = ConstructionArc((0, 0), 1, -90, 90)\n assert arc._is_point_in_arc_range(Vec2(p)) is True","def check_obstruction(self, start_x, start_y, end_x, end_y, piece):\n\n # Displacement for any single point in the area\n disp_x = end_x - start_x\n disp_y = end_y - start_y\n\n # Piece's area to shift for obstructions\n space = piece.get_area()\n\n # Game board area, initialize check spaces for while loop\n board_space = self._game_board.get_board_area()\n check_x = 0\n check_y = 0\n\n # Assign correct shift value for displacement\n if disp_x > 0:\n shift_x = 1\n elif disp_x == 0:\n shift_x = 0\n else:\n shift_x = -1\n\n if disp_y > 0:\n shift_y = 1\n elif disp_y == 0:\n shift_y = 0\n else:\n shift_y = -1\n\n # For each point in space\n for point in space:\n scale = 1\n # Gradually shift values in piece area up to displacement and check if the space is occupied\n while (check_x, check_y) != (point[0] + disp_x, point[1] + disp_y):\n check_x = point[0] + shift_x * scale\n check_y = point[1] + shift_y * scale\n\n # If an obstruction is found, and it is not a piece meant to be captured\n # ie, a piece in the end-position, return True\n if ((check_x, check_y) not in space) and board_space[check_x][check_y] != \" \":\n if (check_x, check_y) != (point[0] + disp_x, point[1] + disp_y):\n return True\n scale += 1\n # Return False if not obstructed\n return False","def check_heading(heading):\n if not (heading >= -180 and heading <= 360):\n raise CompassRangeError(\n 'Not in a valid compass range of -180 to 180 degrees, or '\n '0 to 360 degrees')","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_rotation_angle(self):\n\n self.test_shape.azimuth_placement_angle = [45, 135, 225, 315]\n test_volume = self.test_shape.volume()\n self.test_shape.rotation_angle = 180\n assert self.test_shape.volume() == pytest.approx(test_volume * 0.5)","def test_attempt_bc_correction_golay12_exceeds_range(self):\r\n\r\n # Has 4 changes from a valid golay code\r\n curr_bc = \"TCGTGCACTTGT\"\r\n all_bcs = [\"AGCAGCACTTGT\", \"ACAGAGTCGGCT\"]\r\n barcode_type = \"golay_12\"\r\n actual_bc, actual_errs = attempt_bc_correction(curr_bc,\r\n all_bcs, barcode_type)\r\n\r\n expected_bc = None\r\n expected_errs = 4\r\n self.assertEqual(actual_bc, expected_bc)\r\n self.assertEqual(actual_errs, expected_errs)","def has_start_stop_acqtamps(self):\n try:\n if not all([isinstance(x, datetime) for x in self.start_acq]):\n raise Exception(\"Invalid value encountered in start_acq\")\n if not all([isinstance(x, datetime) for x in self.stop_acq]):\n raise Exception(\"Invalid value encountered in stop_acq\")\n if not all([len(self) == len(x) for x in [self.start_acq,\\\n self.stop_acq]]):\n raise Exception(\"Lengths of arrays do not match...\")\n return True\n except Exception as e:\n print((repr(e)))\n return False","def test_point_is_not_in_arc_range(p):\n arc = ConstructionArc((0, 0), 1, -90, 90)\n assert arc._is_point_in_arc_range(Vec2(p)) is False","def test_is_mountain_in_range(self):\n self.assertTrue(self.user_location.is_mountain_in_range(self.mountain_one))\n self.assertFalse(self.user_location.is_mountain_in_range(self.mountain_two))","def test_Z_start(self):\t\t\n self.assertAlmostEqual(attempt.Z[0], 40)","def _exceeds_critical_angle(angle: float, s0: float, s1: float) -> bool:\n if s1 > s0: # if the second speed is faster, there is a critical angle\n critical_angle = get_critical_angle(s0, s1)\n if abs(angle) >= critical_angle:\n return True\n return False","def goal_test(self, state):\n \"*** YOUR CODE HERE ***\"\n shoot_loc_arr = []\n for allowed_state in self.allowed:\n for goal_state in self.goals:\n if allowed_state[0] == goal_state[0] and allowed_state[1] < goal_state[1]: shoot_loc_arr.append((allowed_state[0], allowed_state[1], 0)) # Head North\n if allowed_state[0] > goal_state[0] and allowed_state[1] == goal_state[1]: shoot_loc_arr.append((allowed_state[0], allowed_state[1], 1)) # Head West\n if allowed_state[0] == goal_state[0] and allowed_state[1] > goal_state[1]: shoot_loc_arr.append((allowed_state[0], allowed_state[1], 2)) # Head South\n if allowed_state[0] < goal_state[0] and allowed_state[1] == goal_state[1]: shoot_loc_arr.append((allowed_state[0], allowed_state[1], 3)) # Head East\n if state in shoot_loc_arr:\n return True\n else:\n return False","def _step(self, start):\n #angle = np.random.uniform(0,2*np.pi) # only 2-dim\n #direction = angle2vec(angle)\n\n angle = np.random.randn(self.dim)\n direction = angle / la.norm(angle)\n \n if not self.query(start):\n print(f\"Given an invalid point! {start}\")\n \n testCounter = 0\n max_iter = 1000\n \n ## Case for adding to direction ##\n high = 1\n testCounter = 0\n while(self.query(start + high*direction)):\n high = high*2\n testCounter += 1\n if testCounter > max_iter:\n print(f\"Warning: Stuck in t_plus high loop with: \\n\\\n high = {high}\\n\")\n \n low = high/2\n testCounter = 0\n while(not self.query(start + low*direction)):\n low = low/2\n testCounter += 1\n if testCounter > max_iter:\n print(f\"Warning: Stuck in t_plus low loop with: \\n\\\n low = {low}\\n\")\n \n # now we know that (start + low * direction) is inside\n #assert(zonoid_membership_def(A, start+low*direction))\n # and that (start + high * direction) is outside\n #assert(not zonoid_membership_def(A, start+high*direction))\n \n tol = 1e-5\n t_plus = (high-low)/2\n old_t = 1\n current = start\n testCounter = 0\n while(abs(t_plus-old_t) > tol):\n old_t = t_plus\n t_plus = (high+low)/2\n testpoint = current + t_plus*direction\n if( self.query(testpoint) ):\n low = t_plus\n else:\n high = t_plus\n \n testCounter += 1\n if testCounter > max_iter:\n print(f\"Warning: Stuck in t_plus loop with: \\n\\\n t_plus = {t_plus}\\n\\\n t_old = {t_old}\\n\\\n high = {high}\\n\\\n low = {low}\\n\")\n t_plus = old_t\n \n ## Case for subtracting from direction\n high = -1\n testCounter = 0\n while(self.query(start + high*direction)):\n high = high*2\n testCounter += 1\n if testCounter > max_iter:\n print(f\"Warning: Stuck in t_minus high loop with: \\n\\\n high = {high}\\n\")\n \n low = high/2\n testCounter = 0\n while(not self.query(start + low*direction)):\n low = low/2\n testCounter += 1\n if testCounter > max_iter:\n print(f\"Warning: Stuck in t_minus low loop with: \\n\\\n low = {low}\\n\")\n \n # now we know that (start + low * direction) is inside\n #assert(zonoid_membership_def(A, start+low*direction))\n # and that (start + high * direction) is outside\n #assert(not zonoid_membership_def(A, start+high*direction))\n \n tol = 1e-10\n t_minus = (high-low)/2\n old_t = 1\n current = start\n testCounter = 0\n while(abs(t_minus-old_t) > tol):\n old_t = t_minus\n t_minus = (high+low)/2\n testpoint = current + t_minus*direction\n if( self.query(testpoint) ):\n low = t_minus\n else:\n high = t_minus\n \n testCounter += 1\n if testCounter > max_iter:\n print(f\"Warning: Stuck in t_minus loop with: \\n\\\n t_minus = {t_minus}\\n\\\n t_old = {t_old}\\n\\\n high = {high}\\n\\\n low = {low}\\n\")\n t_minus = old_t\n \n # Make the step\n final_t = np.random.uniform(t_minus, t_plus)\n #print(f\"Final t = {final_t}\")\n \n # remove extra returns for now for other compatibility\n return start + final_t*direction #, start+t_plus*direction, start+t_minus*direction","def Ez_area(position, angle, detect):\n# a = range(round(-2*Ez_height),round(2*Ez_height))\n# b = range(round(-2*Ez_height),round(2*Ez_height))\n# a_valid = []\n# b_valid= []\n \n # These are the grid points in a coordinate system based on the Ez's angle\n if detect:\n a_valid = [-11, -11, -11, -11, -11, -11, -11, -11, -11, -11, -11, -11, -11, -10, -10, -10, -10, -10, -10, -10, -10, -10, -10, -10, -10, -10, -9, -9, -9, -9, -9, -9, -9, -9, -9, -9, -9, -9, -9, -8, -8, -8, -8, -8, -8, -8, -8, -8, -8, -8, -8, -8, -7, -7, -7, -7, -7, -7, -7, -7, -7, -7, -7, -7, -7, -6, -6, -6, -6, -6, -6, -6, -6, -6, -6, -6, -6, -6, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 5, 5, 5, 5, 5, 5, 5, 5, 5, 6, 6, 6, 6, 6, 6, 6]\n b_valid = [-6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, -4, -3, -2, -1, 0, 1, 2, 3, 4, -3, -2, -1, 0, 1, 2, 3]\n else:\n a_valid = [-9, -9, -9, -9, -9, -9, -9, -9, -9, -8, -8, -8, -8, -8, -8, -8, -8, -8, -7, -7, -7, -7, -7, -7, -7, -7, -7, -6, -6, -6, -6, -6, -6, -6, -6, -6, -5, -5, -5, -5, -5, -5, -5, -5, -5, -4, -4, -4, -4, -4, -4, -4, -4, -4, -3, -3, -3, -3, -3, -3, -3, -3, -3, -2, -2, -2, -2, -2, -2, -2, -2, -2, -1, -1, -1, -1, -1, -1, -1, -1, -1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 4, 4, 4, 4, 4]#[-19, -19, -19, -19, -19, -19, -19, -19, -19, -19, -19, -19, -19, -19, -19, -19, -19, -19, -19, -18, -18, -18, -18, -18, -18, -18, -18, -18, -18, -18, -18, -18, -18, -18, -18, -18, -18, -18, -17, -17, -17, -17, -17, -17, -17, -17, -17, -17, -17, -17, -17, -17, -17, -17, -17, -17, -17, -16, -16, -16, -16, -16, -16, -16, -16, -16, -16, -16, -16, -16, -16, -16, -16, -16, -16, -16, -15, -15, -15, -15, -15, -15, -15, -15, -15, -15, -15, -15, -15, -15, -15, -15, -15, -15, -15, -14, -14, -14, -14, -14, -14, -14, -14, -14, -14, -14, -14, -14, -14, -14, -14, -14, -14, -14, -13, -13, -13, -13, -13, -13, -13, -13, -13, -13, -13, -13, -13, -13, -13, -13, -13, -13, -13, -12, -12, -12, -12, -12, -12, -12, -12, -12, -12, -12, -12, -12, -12, -12, -12, -12, -12, -12, -11, -11, -11, -11, -11, -11, -11, -11, -11, -11, -11, -11, -11, -11, -11, -11, -11, -11, -11, -10, -10, -10, -10, -10, -10, -10, -10, -10, -10, -10, -10, -10, -10, -10, -10, -10, -10, -10, -9, -9, -9, -9, -9, -9, -9, -9, -9, -9, -9, -9, -9, -9, -9, -9, -9, -9, -9, -8, -8, -8, -8, -8, -8, -8, -8, -8, -8, -8, -8, -8, -8, -8, -8, -8, -8, -8, -7, -7, -7, -7, -7, -7, -7, -7, -7, -7, -7, -7, -7, -7, -7, -7, -7, -7, -7, -6, -6, -6, -6, -6, -6, -6, -6, -6, -6, -6, -6, -6, -6, -6, -6, -6, -6, -6, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 9, 9, 9, 9, 9, 9, 9, 9, 9]\n b_valid = [-4, -3, -2, -1, 0, 1, 2, 3, 4, -4, -3, -2, -1, 0, 1, 2, 3, 4, -4, -3, -2, -1, 0, 1, 2, 3, 4, -4, -3, -2, -1, 0, 1, 2, 3, 4, -4, -3, -2, -1, 0, 1, 2, 3, 4, -4, -3, -2, -1, 0, 1, 2, 3, 4, -4, -3, -2, -1, 0, 1, 2, 3, 4, -4, -3, -2, -1, 0, 1, 2, 3, 4, -4, -3, -2, -1, 0, 1, 2, 3, 4, -4, -3, -2, -1, 0, 1, 2, 3, 4, -4, -3, -2, -1, 0, 1, 2, 3, 4, -3, -2, -1, 0, 1, 2, 3, -2, -1, 0, 1, 2]#[-9, -8, -7, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, -9, -8, -7, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, -9, -8, -7, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, -9, -8, -7, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, -9, -8, -7, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, -9, -8, -7, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, -9, -8, -7, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, -9, -8, -7, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, -9, -8, -7, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, -9, -8, -7, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, -9, -8, -7, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, -9, -8, -7, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, -9, -8, -7, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, -9, -8, -7, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, -9, -8, -7, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, -9, -8, -7, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, -9, -8, -7, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, -9, -8, -7, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, -9, -8, -7, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, -9, -8, -7, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, -9, -8, -7, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, -9, -8, -7, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, -9, -8, -7, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, -8, -7, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, -7, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7, -7, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, -4, -3, -2, -1, 0, 1, 2, 3, 4]\n positions = []\n# for i in a:\n# for j in b:\n# if (i > ((Ez_width/2)-Ez_height-detect_length) and abs(j) < (Ez_width/2+detect_length) and i < 0) or (i > 0 and np.sqrt(i**2 + j**2) < Ez_width/2+detect_length):\n# a_valid.append(i)\n# b_valid.append(j)\n# print('AAAA', a_valid)\n# print(' ')\n# print('BBBB', b_valid)\n# print(' ')\n \n # This is a coordinate transfromation to x,y\n for i in range(len(a_valid)):\n positions.append((int(round(a_valid[i]*np.cos(angle) + b_valid[i]*np.sin(angle) + position[0])), int(round(a_valid[i]*np.sin(angle) - b_valid[i]*np.cos(angle) + position[1]))))\n return positions","def is_valid_cord(x, y, w, h):\n return x >=0 and x < w and y >= 0 and y < h;","def setAzEncoderOffset(ant) :\n \n # Retrieve current azimuth offset (arcmin), elevation (degrees) \n # and az encoder pointing offset (implementation specific).\n\n azOffMpName = \"Control.Antenna%d.azimuthOffset\"%ant\n pointingConstants = pointingSetup( ant )\n\n if device.CarmaAnt().isOvro(ant):\n actualElMpName = \"Ovro%d.AntennaCommon.Drive.Track.actualElevation\"%ant\n elif device.CarmaAnt().isBima(ant): \n bimaAntNo = ant - 6\n actualElMpName = \"Bima%d.AntennaCommon.Drive.Track.actualElevation\"%bimaAntNo\n [azOffset,actualEl ] = queryMpValues([azOffMpName, actualElMpName])\n elif device.CarmaAnt().isSza(ant): \n szaAntNo = ant - 15\n actualElMpName = \"Sza%d.AntennaCommon.Drive.Track.actualElevation\"%szaAntNo\n [azOffset,actualEl ] = queryMpValues([azOffMpName, actualElMpName])\n else:\n raise Exception, \"Invalid ant\"\n\n [azOffset,actualEl ] = queryMpValues([azOffMpName, actualElMpName])\n cosEl = math.cos( actualEl * math.pi / 180.0 )\n\n if device.CarmaAnt().isOvro(ant):\n pointingConstants[0] = pointingConstants[0] + azOffset/cosEl\n ovroMountPointingConstants( pointingConstants[0],\n pointingConstants[1],\n pointingConstants[2],\n pointingConstants[3],\n pointingConstants[4], ant )\n elif device.CarmaAnt().isBima(ant): \n pointingConstants[0][0] = pointingConstants[0][0] + azOffset/cosEl\n bimaMountPointingConstants( pointingConstants[0], pointingConstants[1], ant )\n elif device.CarmaAnt().isSza(ant): \n # For SZA, the az zero (term 7 in the pointing constants) is in degrees \n pointingConstants[6] += ( ( azOffset/cosEl ) / 60.0 );\n # Avoid having to spell out all 19 arguments by using the special \n # form '*args' with a list of ordered args.\n args = pointingConstants \n args.append( ant )\n szaMountPointingConstants( *args )\n else:\n raise Exception, \"Invalid ant\"\n\n return offset(0, 0, ant)","def iscircle(a):\n if isarc(a):\n start=a[1][1] \n end=a[1][2]\n ## these are special, integer values that flag a true full\n ## circle.\n if start==0 and end==360:\n return True\n else:\n return False","def test_Calc_accuracy(self, start, end, expected_len_result, expected_first_angles, expected_LHumerus):\n angles, jcs = pycgmCalc.Calc(start, end, self.motion_data, self.cal_SM)\n np.testing.assert_equal(len(angles), expected_len_result)\n np.testing.assert_equal(len(jcs), expected_len_result)\n np.testing.assert_almost_equal(angles[0][:5], expected_first_angles, self.rounding_precision)\n np.testing.assert_almost_equal(jcs[0]['LHumerus'], expected_LHumerus, self.rounding_precision)","def _can_component_fuse_assumption(self, assumption: TrackingAssumption) -> bool:\n gps = [\n GriddedPerm.point_perm(self.first_cell),\n GriddedPerm.point_perm(self.second_cell),\n ]\n return ( # if right type\n (\n isinstance(assumption, SumComponentAssumption)\n and self.is_sum_component_fusion()\n )\n or (\n isinstance(assumption, SkewComponentAssumption)\n and self.is_skew_component_fusion()\n ) # or covers whole region or none of it\n or all(gp in assumption.gps for gp in gps)\n or all(gp not in assumption.gps for gp in gps)\n )","def _dwd_channel_preparation(self,\n channels,\n sun_zenith_angle_correction=True,\n backup_orig_data=False\n ):\n result = True\n\n if not isinstance(channels, list):\n channels = [channels]\n\n for c in channels:\n if sun_zenith_angle_correction:\n self._dwd_apply_sun_zenith_angle_correction(\n c,\n backup_orig_data=backup_orig_data)\n else:\n self._dwd_undo_sun_zenith_angle_correction(c)\n self._dwd_apply_view_zenith_angle_correction(c)\n self._dwd_kelvin_to_celsius(c)\n if self[c].info['units'] != 'C' and \\\n self[c].info['units'] not in ['%', 'ALBEDO(%)', 'percent']:\n result = False\n LOGGER.error(\n \"Calibration for channel \" + str(c) +\n \" failed due to unknown unit \" + self[c].info['units'])\n return result","def test_comp_angle_opening(self, test_dict):\n test_obj = test_dict[\"test_obj\"]\n a = test_obj.slot.comp_angle_opening()\n self.assertEqual(a, 2 * pi / test_obj.slot.Zs)\n\n b = comp_angle_opening(test_obj.slot)\n msg = \"Return \" + str(a) + \" expected \" + str(b)\n self.assertAlmostEqual((a - b) / a, 0, delta=DELTA, msg=msg)","def test_galactic():\n center = coord.CelestialCoord(coord.Angle.from_hms('17:45:37.1991'),\n coord.Angle.from_dms('-28:56:10.2207'))\n north = coord.CelestialCoord(coord.Angle.from_hms('12:51:26.27549'),\n coord.Angle.from_dms('27:07:41.7043'))\n south = coord.CelestialCoord(coord.Angle.from_hms('00:51:26.27549'),\n coord.Angle.from_dms('-27:07:41.7043'))\n anticenter = coord.CelestialCoord(coord.Angle.from_hms('05:45:37.1991'),\n coord.Angle.from_dms('28:56:10.2207'))\n random = coord.CelestialCoord(0.234 * coord.radians, 0.342 * coord.radians)\n\n for c1 in [center, north, south, anticenter, random]:\n a1 = astropy.coordinates.SkyCoord(*c1.rad, unit=units.rad, frame='fk5')\n #print('c1.galactic() = ',c1.galactic())\n #print('a1.galactic = ',a1.galactic)\n el, b = c1.galactic()\n # Wrap el to the same phase as a1\n el = el.wrap(a1.galactic.l.rad * coord.radians)\n if c1 not in [north, south]:\n np.testing.assert_almost_equal(el.rad, a1.galactic.l.rad, decimal=6)\n np.testing.assert_almost_equal(b.rad, a1.galactic.b.rad, decimal=6)\n\n c2 = coord.CelestialCoord.from_galactic(el,b)\n a2 = astropy.coordinates.SkyCoord(el.rad, b.rad, unit=units.radian, frame='galactic')\n a2 = a2.transform_to('fk5')\n c2_ra = c2.ra.wrap(a2.ra.rad * coord.radians)\n np.testing.assert_almost_equal(c2_ra.rad, a2.ra.rad, decimal=6)\n np.testing.assert_almost_equal(c2.dec.rad, a2.dec.rad, decimal=6)","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 has_arc(self, a, b):\n return self.matrix[a][b] != 0","def check_directionality_viable(self):\n\n direction_viable = True\n nose_cords, ear_left_cords, ear_right_cords = [], [], []\n for animal_name in self.animal_bp_dict.keys():\n for bp_cord in [\"X_bps\", \"Y_bps\"]:\n bp_list = self.animal_bp_dict[animal_name][bp_cord]\n for bp_name in bp_list:\n bp_name_components = bp_name.split(\"_\")\n bp_name_components = [x.lower() for x in bp_name_components]\n if \"nose\" in bp_name_components:\n nose_cords.append(bp_name)\n elif (\"ear\" in bp_name_components) and (\n \"left\" in bp_name_components\n ):\n ear_left_cords.append(bp_name)\n elif (\"ear\" in bp_name_components) and (\n \"right\" in bp_name_components\n ):\n ear_right_cords.append(bp_name)\n else:\n pass\n\n for cord in [nose_cords, ear_left_cords, ear_right_cords]:\n if len(cord) != len(self.animal_bp_dict.keys()) * 2:\n direction_viable = False\n\n if direction_viable:\n nose_cords = [\n nose_cords[i * 2 : (i + 1) * 2]\n for i in range((len(nose_cords) + 2 - 1) // 2)\n ]\n ear_left_cords = [\n ear_left_cords[i * 2 : (i + 1) * 2]\n for i in range((len(ear_left_cords) + 2 - 1) // 2)\n ]\n ear_right_cords = [\n ear_right_cords[i * 2 : (i + 1) * 2]\n for i in range((len(ear_right_cords) + 2 - 1) // 2)\n ]\n\n return direction_viable, nose_cords, ear_left_cords, ear_right_cords","def is_ccw(a, b, c):\n p = b - a\n q = c - a\n area = p.x * q.y - q.x * p.y\n\t # May want to throw an exception if area == 0\n return area > 0","def valid(a,b,x,y):\n\t# Size of the square grid that encases rectagle x,y\n\tsquare = x + y - 2\n\t# Taxi cab distance (no diagonals) from (p_a, p_b) to (a,b)\n\tsteps = lambda p_a, p_b: abs(p_a - a) + abs(p_b - b)\n\t# Top/Bottom/Left/Right bound\n\tif min(a,b) < 0 or max(a,b) >= square: return False\n\t# Upper left/Lower right corner check\n\tif steps(0,0) < (x - 2) or steps(square - 1, square - 1) < (x - 2): return False \n\t# Lower left/Upper right corner check\n\telif steps(square - 1, 0) < (y - 2) or steps( 0, square - 1) < (y - 2): return False\n\treturn True","def test_calcAngles_angles_and_axis(self, kargs, expected_len_result, expected_first_angle, expected_first_axis):\n kargs['vsk'] = self.cal_SM\n angles, axis = pycgmCalc.calcAngles(self.motion_data, **kargs)\n np.testing.assert_equal(len(angles), expected_len_result)\n np.testing.assert_equal(len(axis), expected_len_result)\n np.testing.assert_almost_equal(angles[0][0], expected_first_angle, self.rounding_precision)\n np.testing.assert_almost_equal(axis[0][0], expected_first_axis, self.rounding_precision)","def do_polar_alignment_test(self, *arg):\n if self.ready is False:\n return\n\n start_time = current_time(flatten=True)\n\n base_dir = '{}/images/drift_align/{}'.format(\n os.getenv('PANDIR'), start_time)\n plot_fn = '{}/{}_center_overlay.jpg'.format(base_dir, start_time)\n\n mount = self.pocs.observatory.mount\n\n print_info(\"Moving to home position\")\n self.pocs.say(\"Moving to home position\")\n mount.slew_to_home()\n\n # Polar Rotation\n pole_fn = polar_rotation(self.pocs, base_dir=base_dir)\n pole_fn = pole_fn.replace('.cr2', '.fits')\n\n # Mount Rotation\n rotate_fn = mount_rotation(self.pocs, base_dir=base_dir)\n rotate_fn = rotate_fn.replace('.cr2', '.fits')\n\n print_info(\"Moving back to home\")\n self.pocs.say(\"Moving back to home\")\n mount.slew_to_home()\n\n print_info(\"Solving celestial pole image\")\n self.pocs.say(\"Solving celestial pole image\")\n try:\n pole_center = polar_alignment_utils.analyze_polar_rotation(pole_fn)\n except error.SolveError:\n print_warning(\"Unable to solve pole image.\")\n print_warning(\"Will proceeed with rotation image but analysis not possible\")\n pole_center = None\n else:\n pole_center = (float(pole_center[0]), float(pole_center[1]))\n\n print_info(\"Starting analysis of rotation image\")\n self.pocs.say(\"Starting analysis of rotation image\")\n try:\n rotate_center = polar_alignment_utils.analyze_ra_rotation(rotate_fn)\n except Exception:\n print_warning(\"Unable to process rotation image\")\n rotate_center = None\n\n if pole_center is not None and rotate_center is not None:\n print_info(\"Plotting centers\")\n self.pocs.say(\"Plotting centers\")\n\n print_info(\"Pole: {} {}\".format(pole_center, pole_fn))\n self.pocs.say(\"Pole : {:0.2f} x {:0.2f}\".format(\n pole_center[0], pole_center[1]))\n\n print_info(\"Rotate: {} {}\".format(rotate_center, rotate_fn))\n self.pocs.say(\"Rotate: {:0.2f} x {:0.2f}\".format(\n rotate_center[0], rotate_center[1]))\n\n d_x = pole_center[0] - rotate_center[0]\n d_y = pole_center[1] - rotate_center[1]\n\n self.pocs.say(\"d_x: {:0.2f}\".format(d_x))\n self.pocs.say(\"d_y: {:0.2f}\".format(d_y))\n\n fig = polar_alignment_utils.plot_center(\n pole_fn, rotate_fn, pole_center, rotate_center)\n\n print_info(\"Plot image: {}\".format(plot_fn))\n fig.tight_layout()\n fig.savefig(plot_fn)\n\n try:\n os.unlink('/var/panoptes/images/latest.jpg')\n except Exception:\n pass\n try:\n os.symlink(plot_fn, '/var/panoptes/images/latest.jpg')\n except Exception:\n print_warning(\"Can't link latest image\")\n\n with open('/var/panoptes/images/drift_align/center.txt'.format(base_dir), 'a') as f:\n f.write('{}.{},{},{},{},{},{}\\n'.format(start_time, pole_center[0], pole_center[\n 1], rotate_center[0], rotate_center[1], d_x, d_y))\n\n print_info(\"Done with polar alignment test\")\n self.pocs.say(\"Done with polar alignment test\")","def test_az_za():\n Nside = 128\n obs = observatory.Observatory(latitude, longitude, fov=20, nside=Nside)\n center = [0, 0]\n lon, lat = [5, 0]\n ind0 = hp.ang2pix(Nside, lon, lat, lonlat=True)\n lon, lat = hp.pix2ang(Nside, ind0, lonlat=True)\n za, az, pix = obs.calc_azza(center, return_inds=True)\n ind = np.where(pix == ind0)\n # lon = longitude of the source, which is set to 5deg off zenith (hence, zenith angle)\n assert np.isclose(np.degrees(za[ind]), lon)\n assert np.isclose(np.degrees(az[ind]), 90.0)","def test_calcAngles_angles_or_axis(self, kargs, expected_len_result, expected_truncated_results):\n kargs['vsk'] = self.cal_SM\n result = pycgmCalc.calcAngles(self.motion_data, **kargs)\n np.testing.assert_equal(len(result), expected_len_result)\n np.testing.assert_almost_equal(result[0:5], expected_truncated_results)","def check_boundaries(data, theta1, theta2):\n x, y = np.indices((data.shape))\n center = np.array([(x.max() - x.min()) / 2.0, (y.max() - y.min()) / 2.0])\n theta = np.degrees(np.arctan2(y - center[1], x - center[0])) + 180\n\n in_theta = (theta < theta1) | (theta > theta2)\n\n data2 = data.copy()\n data2[in_theta] = np.nan\n return data2","def bearing(start,finish):\n\n s = math.pi * np.squeeze(np.array(start)) / 180\n f = math.pi * np.squeeze(np.array(finish)) / 180\n\n y = math.sin(f[1] - s[1]) * math.cos(f[0])\n x = math.cos(s[0])*math.sin(f[0]) - math.sin(s[0])*math.cos(f[0])*math.cos(f[1] - s[1])\n\n return math.atan2(y,x)/math.pi * 180 % 360","def check_reached(self):\n m_x, m_y = self.destination.get_pos()\n m_radius = self.destination.radius\n distance_centre = math.sqrt((m_x - self.x)**2 + (m_y - self.y)**2)\n sum_radii = m_radius + self.radius\n if distance_centre < sum_radii:\n self.color = pygame.colordict.THECOLORS['green']\n self.has_reached = True","def test_central(self):\n self.assertTrue(self.cs.isCentral)","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_availibity(self, starts_at: datetime.datetime, ends_at: datetime.datetime):\n for unavailable in self.unavailable:\n if unavailable[0] <= starts_at <= unavailable[1]:\n return False\n if unavailable[0] <= ends_at <= unavailable[1]:\n return False\n return True","def test_climb(self):\n fcs = flight_control.FlightControl(**self.start)\n\n altitude = 120.0\n pitch_angle = 10.0\n alt_cmd = cmds.SetAltitudeCmd(120.0, 10.0)\n fcs.set_altitude_cmd(alt_cmd)\n\n #heading = 150.0\n #heading_cmd = cmds.SetHeadingCmd(heading)\n #fcs.set_direction_cmd(heading_cmd)\n\n t = self.tmin\n while t < self.tmax:\n fcs.tick(t, self.dt)\n t += self.dt\n\n self.assertAlmostEqual(fcs.platform.z, altitude, delta=1.0)\n self.assertAlmostEqual(fcs.platform.theta_c, 0.0, delta=1.0)","def test_absolute_areas(self):\n\n assert len(self.test_shape.areas) == 4\n assert len(set([round(i) for i in self.test_shape.areas])) == 3\n assert self.test_shape.areas.count(pytest.approx(60 * math.pi * 2 * 1000)) == 2\n assert self.test_shape.areas.count(pytest.approx(50 * math.pi * 2 * 970)) == 1\n assert self.test_shape.areas.count(pytest.approx(50 * math.pi * 2 * 1030)) == 1","def angle_between(vecs, baseline):\n vecs = CA_coords(vecs)\n baseline = CA_coords(baseline)\n return np.arccos(np.clip(vecs @ baseline.T, -1.0, 1.0))","def _sample_angle(self):\n active_names = (\"N\", \"CA\", \"C\", \"O\", \"CB\", \"H\", \"HA\")\n selection = self.covalent_residue.select(\"name\", active_names)\n self.covalent_residue._active = False\n self.covalent_residue._active[selection] = True\n self.covalent_residue.update_clash_mask()\n active = self.covalent_residue.active\n angles = np.arange(\n -self.options.sample_angle_range,\n self.options.sample_angle_range + 0.001,\n self.options.sample_angle_step,\n )\n new_coor_set = []\n new_bs = []\n for coor in self._coor_set:\n self.covalent_residue.coor = coor\n rotator = CBAngleRotator(self.covalent_residue)\n for angle in angles:\n rotator(angle)\n coor = self.covalent_residue.coor\n if self.options.remove_conformers_below_cutoff:\n values = self.xmap.interpolate(coor[active])\n mask = self.covalent_residue.e[active] != \"H\"\n if np.min(values[mask]) < self.options.density_cutoff:\n continue\n if self.options.external_clash:\n if self._cd() or self.covalent_residue.clashes():\n continue\n elif self.covalent_residue.clashes():\n continue\n new_coor_set.append(self.covalent_residue.coor)\n new_bs.append(self.conformer.b)\n\n self._coor_set = new_coor_set\n self._bs = new_bs\n # logger.debug(f\"Bond angle sampling generated {len(self._coor_set)} conformers.\")","def Cool_per_Grain(grain_size, grain_type, ZZ, fdist, ntot, xe, temp):\n import numpy as np\n import math\n import compute_charge_dist as fz\n \n tau = grain_size * fz.AAtocm * fz.kb * temp / fz.echarge**2\n \n # Loop over species!\n Cool_spec = 0\n for partner in [\"electron\", \"hydrogen\", \"carbon\"]:\n \n Cool_Zall = 0\n # Loop over charge\n for zi in range(len(ZZ)):\n \n if partner == \"electron\":\n nu = -1*ZZ[zi]\n stick_coef = fz.get_stickCoef(ZZ[zi], grain_size, grain_type)\n charge_frac = xe\n mass = fz.me\n \n elif partner == \"hydrogen\":\n nu = ZZ[zi]\n stick_coef = 1.0\n charge_frac = xe\n mass = fz.mH\n \n elif partner == \"carbon\":\n nu = ZZ[zi]\n stick_coef = 1.0\n # Maximum fraction of ionized Carbon is 1e-4*ntot.\n charge_frac = min(1.0e-4, xe)\n mass = fz.mC\n \n Cooltilde = 1.0\n \n if nu < 0:\n Cooltilde = fz.Jtilde_neg(tau, nu)\n elif nu == 0:\n Cooltilde = fz.Jtilde_0(tau, nu)\n else:\n Cooltilde = fz.Jtilde_pos(tau, nu)\n \n #print(zi)\n Cool_Zhere = fdist[zi]*Cooltilde*fz.kb*temp\n Cool_Zall += Cool_Zhere\n \n #print(\"Collisional Partner = \", partner)\n Cool_spec += ntot*charge_frac*stick_coef*np.sqrt(8.0*fz.kb*temp/(np.pi*mass))*Cool_Zall\n \n Cool_tot = math.pi * (grain_size*AAtocm)**2 * Cool_spec\n \n return Cool_tot","def can_rotate(self) -> (bool, list, list):\n arms, axis = self.get_arms()\n rotation = self.get_rotation()\n if rotation[1][0] == 0:\n return False\n coord_axis = np.array([[axis.x_obj], [axis.y_obj]])\n coord_arms = [np.array([[arm.x_obj], [arm.y_obj]])\n for arm in arms]\n coord_new_arms = []\n # Collecting arm coordinates in the situation there turnstile rotates\n for i in range(len(arms)):\n coord_arm = coord_arms[i]\n coord_new_arms.append(\n np.dot(rotation, coord_arm - coord_axis) + coord_axis)\n can_rotate = True\n for i in range(len(arms)):\n coord_arm = coord_arms[i]\n coord_new_arm = coord_new_arms[i]\n # Object turnstile should push\n coord_front = coord_arm + coord_new_arm - coord_axis\n coord_character = np.array(\n [[self.moving_character.x_obj], [self.moving_character.y_obj]])\n obj_front = self.grid.obj_list[\n coord_front[0][0], coord_front[1][0]]\n if not (isinstance(obj_front, ob.Void) or (coord_front == coord_character).all()):\n can_rotate = False\n # Object being at the destination of the arm\n obj_target = self.grid.obj_list[\n coord_new_arm[0][0], coord_new_arm[1][0]]\n if not isinstance(obj_target, (ob.Void, ob.TurnstileBloc)):\n can_rotate = False\n return can_rotate, coord_arms, coord_new_arms","def _cal_meaningful_corners(self):\n corners = np.where(self._free_of_clash)\n corners = np.array(corners, dtype=int)\n corners = corners.transpose()\n return corners","def __contains__(self, angle):\n angle = normalize(angle, min(self.start, self.finish), max(self.start, self.finish))\n return (self.start <= angle < self.finish) or (self.finish <= angle < self.start)","def check_course_start_end_dates(self, start_date, end_date, env):\n self.assertEquals(\n start_date, courses.Course.get_named_course_setting_from_environ(\n constants.START_DATE_SETTING, env))\n self.assertEquals(\n end_date, courses.Course.get_named_course_setting_from_environ(\n constants.END_DATE_SETTING, env))","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 check_invalid_actions(y):\n inval_actions = [\n [ 0.0, 1.0, 0.4], # ACCEL_BRAKE\n [ 1.0, 1.0, 0.4], # RIGHT_ACCEL_BRAKE\n [-1.0, 1.0, 0.4], # LEFT_ACCEL_BRAKE\n [ 1.0, 1.0, 0.0], # RIGHT_ACCEL\n [-1.0, 1.0, 0.0], # LEFT_ACCEL\n ]\n ia_count = 0\n for ia in inval_actions:\n ia_count += np.sum(np.all(y == ia, axis=1))\n if ia_count > 0:\n raise Exception('Invalid actions. Do something developer!')","def checkObstaclesAhead(ldr_compl,tireAngle, maxLen=0.3,threshold=2):\n #within the car-width and the maxLen\n # at 45 degrees shift real for 0.05m\n madeUpHeuristic = tireAngle*0.07/45 #shifts real-axis dependent on tire angle\n madeUpHeuristic2= abs(tireAngle*0.14/45) #at 45degrees append CAR_WIDTH with 0.15m\n obstacleIdx = (ldr_compl.imag<maxLen)*(abs(ldr_compl.real+madeUpHeuristic)<((CAR_WIDTH/100+madeUpHeuristic2)/2))\n if is_debugging:\n plt.plot(ldr_compl.real,ldr_compl.imag,'.')\n plt.show()\n print(sum(obstacleIdx))\n return sum(obstacleIdx)>threshold","def test_align_points(self):\n mv = [\n [0, 0, 5],\n [5, 0, 5],\n [0, 5, 5]\n ]\n sv = [\n [0, 0, 0],\n [5, 0, 0],\n [0, 5, 0]\n ]\n al = align(self.amp1, self.amp2, mv=mv, sv=sv, method='contPoints').m\n zMax = self.amp1.vert[:, 2].max() - 5\n # Both objects are already centered, so should be close to origin (allowing for some inaccuracy)\n self.assertAlmostEqual(al.vert[:, 2].max(), zMax, delta=TestAlign.DELTA)","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 Check(self):\n cleared = False\n while not cleared:\n for i in list(combinations([cell.Check() for cell in self.cells], 2)):\n # for i in list(combinations(zip(self.locations.x,self.locations.y,self.locations.length,self.locations.index),2)):\n x1 = i[0][0]\n y1 = i[0][1]\n r1 = i[0][2] / 2\n idx1 = i[0][3]\n x2 = i[1][0]\n y2 = i[1][1]\n r2 = i[1][2] / 2\n idx1 = i[0][3]\n idx2 = i[1][3]\n distance = (x1 - x2) * (x1 - x2) + (y1 - y2) * (y1 - y2)\n radii = (r1 + r2) * (r1 + r2)\n if distance == radii:\n cleared = True\n elif distance > radii:\n cleared = True\n else:\n if x1 > x2 and y1 > y2:\n if (\n x1 + r1 > 0\n and x1 + r1 < self.boundaries[0]\n and y1 + r1 > 0\n and y1 + r1 < self.boundaries[1]\n ):\n self.cells[idx1].x = x1 + r1 / 2\n self.cells[idx1].y = y1 + r1 / 2\n elif x1 > x2 and y1 < y2:\n if (\n x1 + r1 > 0\n and x1 + r1 < self.boundaries[0]\n and y1 - r1 > 0\n and y1 - r1 < self.boundaries[1]\n ):\n self.cells[idx1].x = x1 + r1 / 2\n self.cells[idx1].y = y1 - r1 / 2\n elif x1 < x2 and y1 > y2:\n if (\n x1 - r1 > 0\n and x1 - r1 < self.boundaries[0]\n and y1 + r1 > 0\n and y1 + r1 < self.boundaries[1]\n ):\n self.cells[idx1].x = x1 - r1 / 2\n self.cells[idx1].y = y1 + r1 / 2\n else:\n if (\n x1 - r1 > 0\n and x1 - r1 < self.boundaries[0]\n and y1 - r1 > 0\n and y1 - r1 < self.boundaries[1]\n ):\n self.cells[idx1].x = x1 - r1 / 2\n self.cells[idx1].y = y1 - r1 / 2\n _logger.debug(\n f\"Bumped from {x1 :.2e}, {y1 :.2e} to {self.cells[idx1].x :.2e}, {self.cells[idx1].y :.2e}\"\n )\n cleared = False\n return","def ensure_outside_conus(ls):\n # First and last point of the ls need to be exterior to the CONUS\n for idx in [0, -1]:\n pt = Point(ls.coords[idx])\n # If point is safely outside CONUS, done.\n if point_outside_conus(pt):\n continue\n # Get new point that may be too close for comfort\n pt = get_conus_point(pt)\n if pt.within(CONUS[\"poly\"]) or pt.distance(CONUS[\"poly\"]) < 0.001:\n LOG.warning(\" idx: %s is still within, evasive action\", idx)\n done = False\n for multi in [0.01, 0.1, 1.0]:\n if done:\n break\n for xoff, yoff in [\n [-0.01 * multi, -0.01 * multi],\n [-0.01 * multi, 0.0 * multi],\n [-0.01 * multi, 0.01 * multi],\n [0.0 * multi, -0.01 * multi],\n [0.0 * multi, 0.0 * multi],\n [0.0 * multi, 0.01 * multi],\n [0.01 * multi, -0.01 * multi],\n [0.01 * multi, 0.0 * multi],\n [0.01 * multi, 0.01 * multi],\n ]:\n pt2 = translate(pt, xoff=xoff, yoff=yoff)\n if not pt2.within(CONUS[\"poly\"]):\n pt = pt2\n LOG.warning(\" idx: %s is now %s\", idx, pt)\n done = True\n break\n LOG.warning(\n \" fix idx: %s to new: %.4f %.4f Inside: %s\",\n idx,\n pt.x,\n pt.y,\n pt.within(CONUS[\"poly\"]),\n )\n coords = list(ls.coords)\n coords[idx] = (pt.x, pt.y)\n ls = LineString(coords)\n return ls","def test_relative_shape_volume(self):\n\n test_volume = self.test_shape.volume()\n self.test_shape.azimuth_placement_angle = [0, 90, 180, 270]\n assert test_volume * 4 == pytest.approx(self.test_shape.volume())","def _isLineTanToArc(self, x1, y1, x2, y2, cx, cy, d):\n p = QPointF(x2, y2)\n # line start -> end\n v1 = QVector2D(p - QPointF(x1, y1)).normalized()\n # arc center -> arc start\n v2 = QVector2D(p - QPointF(cx, cy)).normalized()\n if abs(v1.dotProduct(v1, v2)) <= 1e-6:\n # TODO: handle case where arc turns back into the line\n return True\n else:\n return False","def heating_system_is_ac(bpr):\n\n if bpr.hvac['type_hs'] in {'T3'}: # central ac\n return True\n elif bpr.hvac['type_hs'] in {'T0', 'T1', 'T2', 'T4'}:\n return False\n else:\n print('Error: Unknown heating system')\n return False","def azizen(self):\n # x0,y0 array pixel coordinates relative to cx,cy\n# ndy0,ndx0=img.shape\n ndy0=self.ndy0\n ndx0=self.ndx0\n x0,y0=np.meshgrid(np.linspace(0,ndx0-1,ndx0)-self.cx,np.linspace(0,ndy0-1,ndy0)-self.cy)\n r0=np.sqrt(x0**2+y0**2)/self.pr0 # fractional radial distance from 0,0\n# self.roi=np.s_[ystart:ystart+self.ny0,xstart:xstart+self.nx0]\n # why not model the zenith angle dependence with polynomial directly\n # rather than linear interpolation between roots.\n roots=np.zeros(51)\n rr=np.arange(51)/100.0\n for i,ref in enumerate(rr):\n roots[i]=np.real(np.roots([self.c3,0,self.c2,0,self.c1,-ref])[-1])\n theta0 = np.interp(r0/2,rr,roots)\n \n phi0 = np.arctan2(x0,y0) - self.rot ####phi (i.e., azimuth) is reckoned with -pi corresponding to north, increasing clockwise, NOTE: pysolar use sub-standard definition\n phi0 = phi0%(2*np.pi)\n\n #####correction for the tilt of the camera\n k=np.array((np.sin(self.azm),np.cos(self.azm),0))\n a=np.array([np.sin(theta0)*np.cos(phi0),np.sin(theta0)*np.sin(phi0),np.cos(theta0)]); \n a = np.transpose(a,[1,2,0])\n b=np.cos(self.beta)*a + np.sin(self.beta)*np.cross(k,a,axisb=2) \\\n + np.reshape(np.outer(np.dot(a,k),k),(self.ndy0,self.ndx0,3))*(1-np.cos(self.beta))\n theta0=np.arctan(np.sqrt(b[:,:,0]**2+b[:,:,1]**2)/b[:,:,2])\n phi0=np.arctan2(b[:,:,1],b[:,:,0])%(2*np.pi)\n# max_theta *= deg2rad \n# valid0 = (theta0<max_theta) & (theta0>0); \n# theta0[valid0]=np.nan;\n self.theta0,self.phi0=theta0,phi0","def quick_check(self):\n for ang in range(self.MIDPOINT-150, self.MIDPOINT+151, 150):\n self.servo(ang)\n if self.read_distance() < self.SAFE_DIST:\n return False\n return True","def test_far_out_coordinates(rotationangle):\n\n eps = 1e-7\n\n # Get the limits\n lim = rotationangle[\"cs\"].limits()[2:]\n lim0 = max(lim)\n lim1 = min(lim)\n\n # Setting c2 and c3 to zero\n c3 = lim0 - eps\n\n # A large value which is still valid\n phi_dash = rotationangle[\"cs\"].to_rotation_angle(c3)\n\n # Setting c2 and c3 to zero\n c3 = lim1 + eps\n\n # A large value which is still valid\n phi_dash = rotationangle[\"cs\"].to_rotation_angle(c3)\n\n # A large value which is raises an exception\n with pytest.raises(RuntimeError):\n c3 = lim0 + eps\n phi_dash = rotationangle[\"cs\"].to_rotation_angle(c3)\n print(phi_dash)\n\n with pytest.raises(RuntimeError):\n c3 = lim1 - eps\n phi_dash = rotationangle[\"cs\"].to_rotation_angle(c3)","def goal_test(c):\n return c == GOAL_CUBE","def crosstrackdistance(lon1,lat1,\n lon2,lat2,\n lon3,lat3,\n rearth=6.370949e3,\n altitude=0,\n deg=True,\n DEBUG=False):\n\n rearth += altitude\n\n if deg:\n lat1, lat2, lat3, lon1, lon2, lon3 = map(np.deg2rad, (lat1, lat2, lat3,\n lon1, lon2, lon3))\n \n # Angular distance between point 1 and point 3 \n d13 = geo_dist(lon1,lat1,lon3,lat3,\n deg=False,\n rearth=rearth,\n altitude=0)/rearth\n\n #initial bearing, 1 to 2 (in DEGREES)\n b12 = bearing(lat1,lat2,lon1,lon2,deg=False)\n\n #initial bearing, 1 to 3 (in DEGREES)\n b13 = bearing(lat1,lat3,lon1,lon3,deg=False)\n\n b12,b13 = map(np.deg2rad, (b12,b13))\n\n dist = np.arcsin(np.sin(d13)*np.sin(b13-b12))*rearth\n\n if DEBUG:\n print(\"lon1, lat1 : {:5.2f}°, {:5.2f}°\".format(np.rad2deg(lon1),np.rad2deg(lat1)))\n print(\"lon2, lat2 : {:5.2f}°, {:5.2f}°\".format(np.rad2deg(lon2),np.rad2deg(lat2)))\n print(\"lon3, lat3 : {:5.2f}°, {:5.2f}°\".format(np.rad2deg(lon3),np.rad2deg(lat3)))\n print(\"Sphere radius: {:7.2g}\".format(rearth))\n\n print(\"Distance between P3 and great circle formed by P1 and P2: \")\n print(\"{:7.2g}\".format(dist))\n\n print(\"Angular distance (deg) between P3 and great circle formed by P1 and P2: \")\n print(\"{:7.2g}\".format(np.rad2deg(dist/rearth)))\n\n return dist","def check_obstacle_ahead(distances, angles, save_index = None, length_to_check = 250, half_robot_width = 180, threshold_low = 12, threshold_high = 100):\n distances = np.array(distances)\n angles = np.array(angles)\n # compute angle to differentiate regions\n delta = np.arctan(half_robot_width / length_to_check) * 57.3\n\n # compute the indices for the 2 regions of interest\n idcs1 = np.logical_or(np.logical_and(angles <= 90, angles >= delta), np.logical_and(angles >= 270, angles <= (360 - delta)))\n idcs2 = np.logical_or(np.logical_and(angles >= 0, angles <= delta), np.logical_and(angles <= 360, angles >= (360 - delta)))\n\n # compute the critical ditance for those regions (set of angles)\n critical_distance_1 = half_robot_width / np.abs(np.sin(angles[idcs1] / 57.3))\n critical_distance_2 = length_to_check / np.abs(np.cos(angles[idcs2] / 57.3))\n\n # compare actual distances with critical distances\n obstacles1 = distances[idcs1] < critical_distance_1\n obstacles2 = distances[idcs2] < critical_distance_2\n \n # save for debug\n if save_index is not None:\n np.save(\"/home/arthur/dev/ros/data/lidar/angles_{}.npy\".format(save_index), angles)\n np.save(\"/home/arthur/dev/ros/data/lidar/distances_{}.npy\".format(save_index), distances)\n \n # return true depending on the obstacle detection\n count = (np.count_nonzero(obstacles1) + np.count_nonzero(obstacles2))\n return count >= threshold_low and count <= threshold_high","def test_calcAngles_joint_centers(self):\n _,joint_centers = pycgmCalc.calcAngles(self.motion_data, vsk=self.cal_SM, frame=0,\\\n formatData=False, splitAnglesAxis=False, returnjoints=True)\n #Verify that several the expected joint_centers are returned.\n expected_Front_Head = np.array([ 255.19071198, 406.12081909, 1721.92053223])\n expected_LHip = np.array([182.57097863, 339.43231855, 935.52900126])\n expected_RHand = np.array([ 859.80614366, 517.28239823, 1051.97278944])\n expected_Thorax = np.array([256.149810236564, 364.3090603933987, 1459.6553639290375])\n expected_LKnee = np.array([143.55478579, 279.90370346, 524.78408753])\n expected_result = [expected_Front_Head, expected_LHip, expected_RHand, expected_Thorax, expected_LKnee]\n result = [\n joint_centers[0]['Front_Head'],\n joint_centers[0]['LHip'],\n joint_centers[0]['RHand'],\n joint_centers[0]['Thorax'],\n joint_centers[0]['LKnee']\n ]\n np.testing.assert_almost_equal(result, expected_result, self.rounding_precision)","def test_astrounits_validate_list(self):\n au = inches_to.astronomical_units([1.0, 2.0, 3.0, 4.0])\n comparison = np.array([1.69789e-13, 2*1.69789e-13, 3*1.69789e-13, 4*1.69789e-13])\n\n try:\n for i in range(len(comparison)):\n self.assertTrue(math.isclose(au[i], comparison[i], rel_tol=self.accepted_error))\n print('{:.40s}{}'.format(sys._getframe().f_code.co_name + self.padding, self.passed))\n except AssertionError:\n print('{:.40s}{}'.format(sys._getframe().f_code.co_name + self.padding, self.failed))","def test_c(self):\n self.failIf(cgs.speed_of_light/mks.speed_of_light!=100)","def test_cross_support_region(self):\n # Computes cross support for the reference image, with cbca_intensity=5 and cbca_distance=3\n csr_ = cbca.cross_support(self.ref['im'].data, 3, 5.)\n\n # Cross support region top arm ground truth for the reference image self.ref\n csr_ground_truth_top_arm = np.array([[0, 0, 0, 0, 0],\n [1, 1, 1, 1, 1],\n [1, 1, 1, 2, 1]])\n # Check if the calculated Cross support region top arm is equal to the ground truth\n # (same shape and all elements equals)\n\n np.testing.assert_array_equal(csr_[:, :, 2], csr_ground_truth_top_arm)\n\n # Cross support region bottom arm ground truth for the reference image self.ref\n csr_ground_truth_bottom_arm = np.array([[1, 1, 1, 2, 1],\n [1, 1, 1, 1, 1],\n [0, 0, 0, 0, 0]])\n # Check if the calculated Cross support region bottom arm is equal to the ground truth\n # (same shape and all elements equals)\n np.testing.assert_array_equal(csr_[:, :, 3], csr_ground_truth_bottom_arm)\n\n # Cross support region left arm ground truth for the reference image self.ref\n csr_ground_truth_left_arm = np.array([[0, 1, 1, 1, 1],\n [0, 1, 2, 2, 1],\n [0, 1, 1, 1, 1]])\n # Check if the calculated Cross support region left arm is equal to the ground truth\n # (same shape and all elements equals)\n np.testing.assert_array_equal(csr_[:, :, 0], csr_ground_truth_left_arm)\n\n # Cross support region right arm ground truth for the reference image self.ref\n csr_ground_truth_right_arm = np.array([[1, 1, 1, 1, 0],\n [2, 2, 1, 1, 0],\n [1, 1, 1, 1, 0]])\n # Check if the calculated Cross support region right arm is equal to the ground truth\n # (same shape and all elements equals)\n np.testing.assert_array_equal(csr_[:, :, 1], csr_ground_truth_right_arm)","def areColinear(self, other):\n perpVect = np.array([-self.vector[c.Y], self.vector[c.X]])\n vect1 = other.end[:2]-self.start[:2]\n vect2 = other.start[:2]-self.start[:2]\n cosTheda1 = (np.dot(perpVect, vect1)/\n (np.linalg.norm(perpVect)*np.linalg.norm(vect1)))\n if abs(cosTheda1) > 0.0001:\n return False\n cosTheda2 = (np.dot(perpVect, vect2)/\n (np.linalg.norm(perpVect)*np.linalg.norm(vect2)))\n return not(abs(cosTheda2) > 0.0001)","def test01(self):\n a = np.arange(3, self.N)\n ac = bcolz.arange(3, self.N, rootdir=self.rootdir)\n self.assertTrue(np.all(a == ac))","def goodPlace(contour):\n perimeter = cv2.arcLength(contour, True)\n x, y, w, h = cv2.boundingRect(contour)\n if y<=0 or x<=0:\n return False\n elif y+h >=2016 or x+w>=3840:\n return False\n return True","def test_concentration_profile(self):\n\n # TODO: uncomment when have average concentrations\n # small number so that can use array less\n # epsilon = 0.001\n\n # if self.operating_condition == \"discharge\":\n # np.testing.assert_array_less(\n # -self.c_e_n_av.entries, self.c_e_av.entries + epsilon\n # )\n # np.testing.assert_array_less(\n # self.c_e_p_av.entries, self.c_e_av.entries + epsilon\n # )\n # elif self.operating_condition == \"charge\":\n # np.testing.assert_array_less(\n # -self.c_e_n_av.entries, self.c_e_av.entries + epsilon\n # )\n # np.testing.assert_array_less(\n # self.c_e_p_av.entries, self.c_e_av.entries + epsilon\n # )\n # elif self.operating_condition == \"off\":\n # np.testing.assert_array_equal(self.c_e_n_av.entries, self.c_e_av.entries)\n # np.testing.assert_array_equal(self.c_e_s_av.entries, self.c_e_av.entries)\n # np.testing.assert_array_equal(self.c_e_p_av.entries, self.c_e_av.entries)","def test_polar_angle_normal_case(self):\n point1 = np.array([1, 1])\n point2 = np.array([2, 2])\n pol_angle = convex_hull.polar_angle(point2, point1)\n\n self.assertEqual(round(math.tan(pol_angle)), 1)","def is_codon_correct(input_codon):\n if type(input_codon) == float:\n return False\n\t\t\n allowed_bases = ['A', 'T', 'C', 'G', 'N', '?', '-']\n\n for base in input_codon:\n if base in allowed_bases:\n continue\n else:\n print(\"Your codon is incorrect\")\n return False\n\n return True","def inrange(cc, point):\n return point.row in range(cc.top, cc.bottom+1) and point.col in range(cc.left, cc.right+1)","def _isArcTangentToArc(self, px, py, cx1, cy1, cx2, cy2):\n p = QPointF(px, py)\n v1 = QVector2D(p - QPointF(cx1, cy1)).normalized()\n v2 = QVector2D(p - QPointF(cx1, cy1)).normalized()\n if abs(v1.dotProduct(v1, v2)) - 1.0 <= 1e-6:\n # TODO: handle case where arc turns back into the other arc\n return True\n else:\n return False","def check_correctness(S, bc_start='not-a-knot', bc_end='not-a-knot',\n tol=1e-14):\n x = S.x\n c = S.c\n dx = np.diff(x)\n dx = dx.reshape([dx.shape[0]] + [1] * (c.ndim - 2))\n dxi = dx[:-1]\n\n # Check C2 continuity.\n assert_allclose(c[3, 1:], c[0, :-1] * dxi**3 + c[1, :-1] * dxi**2 +\n c[2, :-1] * dxi + c[3, :-1], rtol=tol, atol=tol)\n assert_allclose(c[2, 1:], 3 * c[0, :-1] * dxi**2 +\n 2 * c[1, :-1] * dxi + c[2, :-1], rtol=tol, atol=tol)\n assert_allclose(c[1, 1:], 3 * c[0, :-1] * dxi + c[1, :-1],\n rtol=tol, atol=tol)\n\n # Check that we found a parabola, the third derivative is 0.\n if x.size == 3 and bc_start == 'not-a-knot' and bc_end == 'not-a-knot':\n assert_allclose(c[0], 0, rtol=tol, atol=tol)\n return\n\n # Check periodic boundary conditions.\n if bc_start == 'periodic':\n assert_allclose(S(x[0], 0), S(x[-1], 0), rtol=tol, atol=tol)\n assert_allclose(S(x[0], 1), S(x[-1], 1), rtol=tol, atol=tol)\n assert_allclose(S(x[0], 2), S(x[-1], 2), rtol=tol, atol=tol)\n return\n\n # Check other boundary conditions.\n if bc_start == 'not-a-knot':\n if x.size == 2:\n slope = (S(x[1]) - S(x[0])) / dx[0]\n assert_allclose(S(x[0], 1), slope, rtol=tol, atol=tol)\n else:\n assert_allclose(c[0, 0], c[0, 1], rtol=tol, atol=tol)\n elif bc_start == 'clamped':\n assert_allclose(S(x[0], 1), 0, rtol=tol, atol=tol)\n elif bc_start == 'natural':\n assert_allclose(S(x[0], 2), 0, rtol=tol, atol=tol)\n else:\n order, value = bc_start\n assert_allclose(S(x[0], order), value, rtol=tol, atol=tol)\n\n if bc_end == 'not-a-knot':\n if x.size == 2:\n slope = (S(x[1]) - S(x[0])) / dx[0]\n assert_allclose(S(x[1], 1), slope, rtol=tol, atol=tol)\n else:\n assert_allclose(c[0, -1], c[0, -2], rtol=tol, atol=tol)\n elif bc_end == 'clamped':\n assert_allclose(S(x[-1], 1), 0, rtol=tol, atol=tol)\n elif bc_end == 'natural':\n assert_allclose(S(x[-1], 2), 0, rtol=2*tol, atol=2*tol)\n else:\n order, value = bc_end\n assert_allclose(S(x[-1], order), value, rtol=tol, atol=tol)","def are_angles_allowed(self, angles, return_reason=False):\n #The base goniometer can reach all angles.\n if return_reason:\n return (True, \"\")\n else:\n return True","def all_covered(matches, molecule) -> bool:\n # check atoms\n for i in range(molecule.n_atoms):\n assert (i, ) in matches\n # check bonds\n for bond in molecule.bonds:\n bond = (bond.atom1_index, bond.atom2_index)\n assert bond in matches or tuple(reversed(bond)) in matches\n # check angles\n for angle in molecule.angles:\n angle = tuple([atom.molecule_atom_index for atom in angle])\n assert angle in matches or tuple(reversed(angle)) in matches\n # check torsions\n for torsion in molecule.propers:\n dihedral = tuple([atom.molecule_atom_index for atom in torsion])\n assert dihedral in matches or tuple(reversed(dihedral)) in matches\n\n return True","def azimuth(vv, v0, v1):\n with np.errstate(divide='ignore', invalid='ignore'):\n n0 = np.cross(v0, v1)\n n0 /= np.dual.norm(n0, axis=-1)[..., np.newaxis]\n nn = np.cross(v0, vv)\n nn /= np.dual.norm(nn, axis=-1)[..., np.newaxis]\n\n azi = np.arccos(np.sum(nn * n0, -1))\n if len(np.shape(azi)) > 0:\n azi[np.dot(vv, n0) < 0] *= -1\n # arbitrary angle where vv is (anti)parallel to v0\n azi[np.isnan(azi)] = 0\n elif np.isnan(azi):\n return 0\n elif np.dot(vv, v0) < 1 and azi > 0:\n azi *= -1\n\n return azi","def _is_trivial_angle(rad: float, atol: float) -> bool:\n return abs(rad) < atol or abs(abs(rad) - np.pi / 4) < atol","def check_tele_coords(coords, is_alt_az):\n\t\n\t#Stuff check coords are OK values?\n\tif len(coords)!= 2:\n\t\tlogger.error('Incorrect length for coords parameter, should be 2')\n\telse:\n\t\tfor i in range(len(coords)):\n\t\t\n\t\t\t#print('Checking', coords[i], 'index:',i)\n\t\t\tvalid_Coords = True\n\t\t\ttry:\n\t\t\t\tj = str(coords[i])\n\t\t\t\t\n\t\t\texcept:\n\t\t\t\tvalid_Coords = False\n\t\t\telse:\n\t\t\t\tspace_split = j.split(' ')\n\t\t\t\tcolon_split = j.split(':')\n\t\t\t\tif len(space_split) == 3 or len(colon_split) == 3: \n\t\t\t\t\tif len(space_split) == 3:\n\t\t\t\t\t\tvalid_one = space_split\n\t\t\t\t\tif len(colon_split)==3:\n\t\t\t\t\t\tvalid_one = colon_split\n\t\t\t\telse:\n\t\t\t\t\tvalid_Coords = False\n\t\t\t\n\t\t\ttry:\n\t\t\t\tvalid_one = [float(valid_one[k]) for k in range(len(valid_one))]\n\t\t\texcept:\n\t\t\t\tvalid_Coords = False\n\t\t\t#Check the values entered are in valid ranges\n\t\t\tif valid_Coords == True:\n\t\t\t\t#Check mintues for all RA, DEC, Alt, Az,\n\t\t\t\tif valid_one[1] < 0 or valid_one[1] >= 60:\n\t\t\t\t\tvalid_Coords =False\n\t\t\t\t# Check seconds for all RA, DEC, ALt, Az\n\t\t\t\tif valid_one[2] < 0 or valid_one[2]>= 60:\n\t\t\t\t\tvalid_Coords =False\n\t\t\t\t\n\t\t\t\t# First value will have different ranges for RA, DEC, Alt, Az\n\t\t\t\t# i == 0 will be either RA or Alt..\n\t\t\t\t# is_alt_az==False for RA\n\t\t\t\tif i == 0 and is_alt_az == False:\n\t\t\t\t\tif valid_one[0] < 0 or valid_one[0] >=24:\n\t\t\t\t\t\tvalid_Coords = False\n\t\t\t\telif i == 0 and is_alt_az == True:\n\t\t\t\t\tif valid_one[0] <0 or valid_one[0] >90:\n\t\t\t\t\t\tvalid_Coords =False\n\t\t\t\t# i == 1 will be DEC or Az\n\t\t\t\t# is_alt_az==False for DEC\n\t\t\t\telif i== 1 and is_alt_az ==False:\n\t\t\t\t\tif valid_one[0] <-90 or valid_one[0] > 90:\n\t\t\t\t\t\tvalid_Coords = False\n\t\t\t\telif i == 1 and is_alt_az == True:\n\t\t\t\t\tif valid_one[0] <0 or valid_one[0] >=360:\n\t\t\t\t\t\tvalid_Coords =False\n\t\t\t\telse:\n\t\t\t\t\tprint(\"Issue with 'i' or 'is_alt_az'\")\n\t\t\t\t\t\n\t\t\tif valid_Coords ==False:\n\t\t\t\traise ValueError('Invalid Coordinates provided')","def test02(self):\n a = np.arange(3, self.N, 4)\n ac = bcolz.arange(3, self.N, 4, rootdir=self.rootdir)\n self.assertTrue(np.all(a == ac))"],"string":"[\n \"def check_angle_of_arcs(self):\\n\\n if self.thin_arc_start_angle >= 3600:\\n self.thin_arc_start_angle %= 360\\n self.thin_arc_start_angle += 360\\n\\n elif self.thin_arc_start_angle <= -3600:\\n self.thin_arc_start_angle %= 360\\n self.thin_arc_start_angle -= 360\\n\\n if self.thin_arc_end_angle >= 3600:\\n self.thin_arc_end_angle %= 360\\n self.thin_arc_end_angle += 360\\n\\n elif self.thin_arc_end_angle <= -3600:\\n self.thin_arc_end_angle %= 360\\n self.thin_arc_end_angle -= 360\\n\\n if self.thick_arc_start_angle >= 3600:\\n self.thick_arc_start_angle %= 360\\n self.thick_arc_start_angle += 360\\n\\n elif self.thick_arc_start_angle <= -3600:\\n self.thick_arc_start_angle %= 360\\n self.thick_arc_start_angle -= 360\\n\\n if self.thick_arc_end_angle >= 3600:\\n self.thick_arc_end_angle %= 360\\n self.thick_arc_end_angle += 360\\n\\n elif self.thick_arc_end_angle <= -3600:\\n self.thick_arc_end_angle %= 360\\n self.thick_arc_end_angle -= 360\",\n \"def CheckClearance(self, via, area, clearance):\\r\\n p1 = via.GetPosition()\\r\\n corners = area.GetNumCorners()\\r\\n # Calculate minimum distance from corners\\r\\n # TODO: remove?\\r\\n for i in range(corners):\\r\\n corner = area.GetCornerPosition(i)\\r\\n p2 = corner.getWxPoint()\\r\\n the_distance = norm(p2 - p1) # sqrt((p2.x - p1.x) ** 2 + (p2.y - p1.y) ** 2)\\r\\n\\r\\n if the_distance < clearance:\\r\\n return False\\r\\n\\r\\n for i in range(corners):\\r\\n corner1 = area.GetCornerPosition(i)\\r\\n corner2 = area.GetCornerPosition((i + 1) % corners)\\r\\n pc1 = corner1.getWxPoint()\\r\\n pc2 = corner2.getWxPoint()\\r\\n the_distance, _ = pnt2line(p1, pc1, pc2)\\r\\n\\r\\n if the_distance <= clearance:\\r\\n return False\\r\\n\\r\\n for edge in self.board_edges:\\r\\n if edge.ShowShape() == 'Line':\\r\\n the_distance, _ = pnt2line(p1, edge.GetStart(), edge.GetEnd())\\r\\n if the_distance <= clearance + via.GetWidth() / 2:\\r\\n return False\\r\\n if edge.ShowShape() == 'Arc':\\r\\n # distance from center of Arc and with angle within Arc angle should be outside Arc radius +- clearance + via Width/2\\r\\n center = edge.GetPosition()\\r\\n start = edge.GetStart()\\r\\n end = edge.GetEnd()\\r\\n radius = norm(center - end)\\r\\n dist = norm(p1 - center)\\r\\n if radius - (self.clearance + via.GetWidth() / 2) < dist < radius + (\\r\\n self.clearance + via.GetWidth() / 2):\\r\\n # via is in range need to check the angle\\r\\n start_angle = math.atan2((start - center).y, (start - center).x)\\r\\n end_angle = math.atan2((end - center).y, (end - center).x)\\r\\n if end_angle < start_angle:\\r\\n end_angle += 2 * math.pi\\r\\n point_angle = math.atan2((p1 - center).y, (p1 - center).x)\\r\\n if start_angle <= point_angle <= end_angle:\\r\\n return False\\r\\n\\r\\n return True\",\n \"def _check_zone_locks(self, start, end):\\n color = self._board[start]\\n goal = CheckersGame.opposite[color]\\n\\n start_zone = FULL_BOARD[start]\\n end_zone = FULL_BOARD[end]\\n\\n # You can always get into your own goal\\n # and you can always move within a zone.\\n if end_zone == start_zone or end_zone == goal:\\n return True\\n # So now we can assume they changed zones.\\n # And that if they're in a goal, it's not their own.\\n\\n # The first rule is that if a piece is in *its destination goal*,\\n # it can't be moved outside of it.\\n # The second rule is that we may not move into a zone which is\\n # another player's spawn or goal\\n if start_zone == goal or end_zone == color:\\n return False\\n return True\",\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 check_intercalation(coordat_list, all_coordats):\\n metal_coords = [0.0, 0.0, 0.0]\\n coordats = np.array(coordat_list)\\n if len(coordats) > 1:\\n all_coordats = np.array(all_coordats)\\n test_coordats = []\\n for coord in all_coordats: # Remove matched coordatoms from full list.\\n good = True\\n for coordat in coordats:\\n if np.linalg.norm(coord-coordat) < 1e-12:\\n good = False\\n if good:\\n test_coordats.append(coord)\\n test_coordats = np.array(test_coordats)\\n intercalating = False\\n for pair in itertools.combinations(coordats, 2): # Take pairs of coord atoms\\n if get_angle(pair[0], metal_coords, pair[1]) < 121: # If the angle is less than 121 check for intercalation\\n midvect = (pair[0] + pair[1]) # Take the midpoint vector between the two cord points\\n for coordat in test_coordats: # Test the remaining coordintion sites\\n if get_angle(midvect, metal_coords, coordat) < 30:\\n # If any of the points are within 30 degrees of the midpoint\\n # Flag as intercalating\\n intercalating = True\\n else:\\n intercalating = False\\n return intercalating\",\n \"def cooling_system_is_ac(bpr):\\n\\n if bpr.hvac['type_cs'] in {'T2', 'T3'}: # mini-split ac and central ac\\n return True\\n elif bpr.hvac['type_cs'] in {'T0', 'T1'}:\\n return False\\n else:\\n print('Error: Unknown cooling system')\\n return False\",\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_angle():\\n # radians\\n theta_coord = 45. * coord.degrees\\n theta_astro = astropy.coordinates.Angle(pi/4., units.radian)\\n\\n # degrees\\n np.testing.assert_almost_equal(theta_coord.rad, theta_astro.rad, decimal=12)\\n np.testing.assert_almost_equal(theta_coord / coord.degrees, theta_astro.degree, decimal=12)\\n np.testing.assert_almost_equal(theta_coord / coord.hours, theta_astro.hour, decimal=12)\\n np.testing.assert_almost_equal(theta_coord / coord.arcmin, theta_astro.arcminute, decimal=12)\\n np.testing.assert_almost_equal(theta_coord / coord.arcsec, theta_astro.arcsec, decimal=12)\\n\\n # Other constructors\\n theta_astro2 = astropy.coordinates.Angle(23.09, units.arcsec)\\n theta_coord2 = coord.Angle(23.09, coord.arcsec)\\n np.testing.assert_almost_equal(theta_coord2.rad, theta_astro2.rad, decimal=12)\\n\\n theta_astro3 = astropy.coordinates.Angle(-0.17, unit='rad')\\n theta_coord3 = coord._Angle(-0.17)\\n np.testing.assert_almost_equal(theta_coord3.rad, theta_astro3.rad, decimal=12)\\n\\n # astropy wrapping uses a different convention than we do. Their argument is\\n # the upper end of the target range, not the center.\\n theta_astro4 = theta_astro3.wrap_at(360 * units.deg)\\n theta_coord4 = theta_coord3.wrap(180 * coord.degrees)\\n np.testing.assert_almost_equal(theta_coord4.rad, theta_astro4.rad, decimal=12)\\n\\n theta_astro5 = theta_astro3.wrap_at(-100 * units.deg)\\n theta_coord5 = theta_coord3.wrap(-280 * coord.degrees)\\n np.testing.assert_almost_equal(theta_coord5.rad, theta_astro5.rad, decimal=12)\\n\\n theta_astro6 = astropy.coordinates.Angle('03:34:12', unit='hourangle')\\n theta_coord6 = coord.Angle.from_hms('03:34:12')\\n np.testing.assert_almost_equal(theta_coord6.rad, theta_astro6.rad, decimal=12)\\n\\n theta_astro7 = astropy.coordinates.Angle('03:34:12', unit='deg')\\n theta_coord7 = coord.Angle.from_dms('03:34:12')\\n np.testing.assert_almost_equal(theta_coord7.rad, theta_astro7.rad, decimal=12)\\n\\n # Their default arguments to to_string are different from ours, but can make them compatible.\\n print('theta_astro6.hms = ',theta_astro6.to_string(sep=':', pad=True))\\n print('theta_coord6.hms = ',theta_coord6.hms())\\n assert theta_coord6.hms() == theta_astro6.to_string(sep=':', pad=True)\\n\\n print('theta_astro7.dms = ',theta_astro7.to_string(sep=':', pad=True))\\n print('theta_coord7.dms = ',theta_coord7.dms())\\n assert theta_coord7.dms() == theta_astro7.to_string(sep=':', pad=True)\\n\\n print('theta_astro6.hms = ',theta_astro6.to_string())\\n print('theta_coord6.hms = ',theta_coord6.hms(sep='hms', pad=False))\\n assert theta_coord6.hms(sep='hms', pad=False) == theta_astro6.to_string()\\n\\n print('theta_astro7.hms = ',theta_astro7.to_string())\\n print('theta_coord7.hms = ',theta_coord7.dms(sep='dms', pad=False))\\n assert theta_coord7.dms(sep='dms', pad=False) == theta_astro7.to_string()\",\n \"def test_center(self):\\n\\n self.assertTrue((self.cs.center == np.array([[0], [0]])).all())\",\n \"def can_left_arc(c, correct_arcs):\\n try:\\n return Arc(c.buffer[0], c.sentence[c.stack[-1]].deprel, c.stack[-1]) in correct_arcs\\n except IndexError:\\n return False\",\n \"def checkForCircle(self, points, tangents):\\n if len(points)<10:\\n return False, 0\\n\\n if all(points[0]==points[-1]): # last exactly equals the first.\\n # Ignore last point for this check\\n points = points[:-1]\\n tangents = tangents[:-1]\\n #print 'Removed last ', points\\n xmin,ymin, w, h = computeBox( points)\\n diag2=(w*w+h*h)\\n \\n diag = sqrt(diag2)*0.5\\n norms = numpy.sqrt(numpy.sum( tangents**2, 1 ))\\n\\n angles = numpy.arctan2( tangents[:,1], tangents[:,0] ) \\n #debug( 'angle = ', repr(angles))\\n N = len(angles)\\n \\n deltas = points[1:] - points[:-1] \\n deltasD = numpy.concatenate([ [D(points[0],points[-1])/diag], numpy.sqrt(numpy.sum( deltas**2, 1 )) / diag] )\\n\\n # locate and avoid the point when swicthing\\n # from -pi to +pi. The point is around the minimum\\n imin = numpy.argmin(angles)\\n debug(' imin ',imin)\\n angles = numpy.roll(angles, -imin)\\n deltasD = numpy.roll(deltasD, -imin)\\n n=int(N*0.1)\\n # avoid fluctuations by removing points around the min\\n angles=angles[n:-n]\\n deltasD=deltasD[n:-n]\\n deltasD = deltasD.cumsum()\\n N = len(angles)\\n\\n # smooth angles to avoid artificial bumps\\n angles = smoothArray(angles, n=max(int(N*0.03),2) )\\n\\n deltaA = angles[1:] - angles[:-1]\\n deltasDD = (deltasD[1:] -deltasD[:-1])\\n deltasDD[numpy.where(deltasDD==0.)] = 1e-5*deltasD[0]\\n dAdD = abs(deltaA/deltasDD)\\n belowT, count = True,0\\n for v in dAdD:\\n if v>6 and belowT:\\n count+=1\\n belowT = False\\n belowT= (v<6)\\n\\n self.temp = (deltasD,angles, tangents, dAdD )\\n fracStraight = numpy.sum(deltasDD[numpy.where(dAdD<0.3)])/(deltasD[-1]-deltasD[0])\\n curveLength = deltasD[-1]/3.14\\n #print \\\"SSS \\\",count , fracStraight\\n if curveLength> 1.4 or fracStraight>0.4 or count > 6:\\n isCircle =False\\n else: \\n isCircle= (count < 4 and fracStraight<=0.3) or \\\\\\n (fracStraight<=0.1 and count<5)\\n\\n if not isCircle:\\n return False, 0\\n \\n # It's a circle !\\n radius = points - numpy.array([xmin+w*0.5,ymin+h*0.5])\\n radius_n = numpy.sqrt(numpy.sum( radius**2, 1 )) # normalize\\n\\n mini = numpy.argmin(radius_n) \\n rmin = radius_n[mini]\\n maxi = numpy.argmax(radius_n) \\n rmax = radius_n[maxi]\\n # void points around maxi and mini to make sure the 2nd max is found\\n # on the \\\"other\\\" side\\n n = len(radius_n)\\n radius_n[maxi]=0 \\n radius_n[mini]=0 \\n for i in range(1,n/8+1):\\n radius_n[(maxi+i)%n]=0\\n radius_n[(maxi-i)%n]=0\\n radius_n[(mini+i)%n]=0\\n radius_n[(mini-i)%n]=0\\n radius_n_2 = [ r for r in radius_n if r>0]\\n rmax_2 = max(radius_n_2)\\n rmin_2 = min(radius_n_2) # not good !!\\n anglemax = numpy.arccos( radius[maxi][0]/rmax)*numpy.sign(radius[maxi][1])\\n return True, (xmin+w*0.5,ymin+h*0.5, 0.5*(rmin+rmin_2), 0.5*(rmax+rmax_2), anglemax)\",\n \"def is_angle_valid(self, angle):\\n\\n self.random_range = list(np.array(self.friendly_range) * self.conversion)\\n if (angle < self.random_range[0]) or (angle > self.random_range[1]):\\n return False\\n else:\\n return True\",\n \"def is_on_course_with(start, heading, target):\\n v = Volant(*(tuple(start) + (heading,)))\\n\\n if start == target:\\n return True\\n \\n for _ in range(distance_between_hex_cells(start, target)):\\n v = v.advance()\\n if v.xyh == (tuple(target) + (heading,)):\\n return True\\n\\n return False\",\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 arccenter(c):\\n start=c[1][1] \\n end=c[1][2]\\n if start == 0 and end == 360:\\n return c[0]\\n else:\\n return samplearc(c,0.5)\",\n \"def test_accel_centripetal(self):\\n for deg in np.linspace(0, 360, 9):\\n self.assertEqual(ab[2,0].subs(psi, deg*pi/180).\\\\\\n subs(phi, 60*pi/180).\\\\\\n subs(theta,0).\\\\\\n subs(g, 1).evalf(), -2.0)\\n self.assertEqual(ab[2,0].subs(psi, deg*pi/180).\\\\\\n subs(phi, -60*pi/180).\\\\\\n subs(theta,0).\\\\\\n subs(g, 1).evalf(), -2.0)\\n # Coordinated turn should only have accel in body z direction.\\n # Check that x and y are zero.\\n for ax in range(2):\\n val = ab[ax,0].subs(psi, deg*pi/180).\\\\\\n subs(phi, 60*pi/180).\\\\\\n subs(theta,0).\\\\\\n subs(g, 1).evalf()\\n self.assertTrue(np.isclose(float(val), 0.0))\\n val = ab[ax,0].subs(psi, deg*pi/180).\\\\\\n subs(phi, -60*pi/180).\\\\\\n subs(theta,0).\\\\\\n subs(g, 1).evalf()\\n self.assertTrue(np.isclose(float(val), 0.0))\",\n \"def is_legal(self, start, end) -> bool:\\n return self.board(end) == 0 \\\\\\n and self.board(start) > 0 \\\\\\n and self._check_zone_locks(start, end) \\\\\\n and self.exists_path(start, end)\",\n \"def test_guider_start_arcsOn(self):\\n sopTester.updateModel('mcp', TestHelper.mcpState['arcs'])\\n self._guider_start(8, 20, 0, 0)\",\n \"def isinsidearcXY(c,p):\\n\\n x = c[0]\\n r = c[1][0]\\n if dist(x,p) > r:\\n return False\\n if iscircle(c):\\n return True\\n start = c[1][1]%360.0\\n end = c[1][2]%360.0\\n if end < start:\\n end+= 360.0\\n p2 = sub(p,x)\\n ang = (atan2(p2[1],p2[0]) % pi2)*360/pi2\\n\\n if end <= 360.0:\\n return (ang >= start and ang <= end)\\n else:\\n return ang >= start or ang <= (end-360.0)\",\n \"def test_point_is_in_arc_range(p):\\n arc = ConstructionArc((0, 0), 1, -90, 90)\\n assert arc._is_point_in_arc_range(Vec2(p)) is True\",\n \"def check_obstruction(self, start_x, start_y, end_x, end_y, piece):\\n\\n # Displacement for any single point in the area\\n disp_x = end_x - start_x\\n disp_y = end_y - start_y\\n\\n # Piece's area to shift for obstructions\\n space = piece.get_area()\\n\\n # Game board area, initialize check spaces for while loop\\n board_space = self._game_board.get_board_area()\\n check_x = 0\\n check_y = 0\\n\\n # Assign correct shift value for displacement\\n if disp_x > 0:\\n shift_x = 1\\n elif disp_x == 0:\\n shift_x = 0\\n else:\\n shift_x = -1\\n\\n if disp_y > 0:\\n shift_y = 1\\n elif disp_y == 0:\\n shift_y = 0\\n else:\\n shift_y = -1\\n\\n # For each point in space\\n for point in space:\\n scale = 1\\n # Gradually shift values in piece area up to displacement and check if the space is occupied\\n while (check_x, check_y) != (point[0] + disp_x, point[1] + disp_y):\\n check_x = point[0] + shift_x * scale\\n check_y = point[1] + shift_y * scale\\n\\n # If an obstruction is found, and it is not a piece meant to be captured\\n # ie, a piece in the end-position, return True\\n if ((check_x, check_y) not in space) and board_space[check_x][check_y] != \\\" \\\":\\n if (check_x, check_y) != (point[0] + disp_x, point[1] + disp_y):\\n return True\\n scale += 1\\n # Return False if not obstructed\\n return False\",\n \"def check_heading(heading):\\n if not (heading >= -180 and heading <= 360):\\n raise CompassRangeError(\\n 'Not in a valid compass range of -180 to 180 degrees, or '\\n '0 to 360 degrees')\",\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_rotation_angle(self):\\n\\n self.test_shape.azimuth_placement_angle = [45, 135, 225, 315]\\n test_volume = self.test_shape.volume()\\n self.test_shape.rotation_angle = 180\\n assert self.test_shape.volume() == pytest.approx(test_volume * 0.5)\",\n \"def test_attempt_bc_correction_golay12_exceeds_range(self):\\r\\n\\r\\n # Has 4 changes from a valid golay code\\r\\n curr_bc = \\\"TCGTGCACTTGT\\\"\\r\\n all_bcs = [\\\"AGCAGCACTTGT\\\", \\\"ACAGAGTCGGCT\\\"]\\r\\n barcode_type = \\\"golay_12\\\"\\r\\n actual_bc, actual_errs = attempt_bc_correction(curr_bc,\\r\\n all_bcs, barcode_type)\\r\\n\\r\\n expected_bc = None\\r\\n expected_errs = 4\\r\\n self.assertEqual(actual_bc, expected_bc)\\r\\n self.assertEqual(actual_errs, expected_errs)\",\n \"def has_start_stop_acqtamps(self):\\n try:\\n if not all([isinstance(x, datetime) for x in self.start_acq]):\\n raise Exception(\\\"Invalid value encountered in start_acq\\\")\\n if not all([isinstance(x, datetime) for x in self.stop_acq]):\\n raise Exception(\\\"Invalid value encountered in stop_acq\\\")\\n if not all([len(self) == len(x) for x in [self.start_acq,\\\\\\n self.stop_acq]]):\\n raise Exception(\\\"Lengths of arrays do not match...\\\")\\n return True\\n except Exception as e:\\n print((repr(e)))\\n return False\",\n \"def test_point_is_not_in_arc_range(p):\\n arc = ConstructionArc((0, 0), 1, -90, 90)\\n assert arc._is_point_in_arc_range(Vec2(p)) is False\",\n \"def test_is_mountain_in_range(self):\\n self.assertTrue(self.user_location.is_mountain_in_range(self.mountain_one))\\n self.assertFalse(self.user_location.is_mountain_in_range(self.mountain_two))\",\n \"def test_Z_start(self):\\t\\t\\n self.assertAlmostEqual(attempt.Z[0], 40)\",\n \"def _exceeds_critical_angle(angle: float, s0: float, s1: float) -> bool:\\n if s1 > s0: # if the second speed is faster, there is a critical angle\\n critical_angle = get_critical_angle(s0, s1)\\n if abs(angle) >= critical_angle:\\n return True\\n return False\",\n \"def goal_test(self, state):\\n \\\"*** YOUR CODE HERE ***\\\"\\n shoot_loc_arr = []\\n for allowed_state in self.allowed:\\n for goal_state in self.goals:\\n if allowed_state[0] == goal_state[0] and allowed_state[1] < goal_state[1]: shoot_loc_arr.append((allowed_state[0], allowed_state[1], 0)) # Head North\\n if allowed_state[0] > goal_state[0] and allowed_state[1] == goal_state[1]: shoot_loc_arr.append((allowed_state[0], allowed_state[1], 1)) # Head West\\n if allowed_state[0] == goal_state[0] and allowed_state[1] > goal_state[1]: shoot_loc_arr.append((allowed_state[0], allowed_state[1], 2)) # Head South\\n if allowed_state[0] < goal_state[0] and allowed_state[1] == goal_state[1]: shoot_loc_arr.append((allowed_state[0], allowed_state[1], 3)) # Head East\\n if state in shoot_loc_arr:\\n return True\\n else:\\n return False\",\n \"def _step(self, start):\\n #angle = np.random.uniform(0,2*np.pi) # only 2-dim\\n #direction = angle2vec(angle)\\n\\n angle = np.random.randn(self.dim)\\n direction = angle / la.norm(angle)\\n \\n if not self.query(start):\\n print(f\\\"Given an invalid point! {start}\\\")\\n \\n testCounter = 0\\n max_iter = 1000\\n \\n ## Case for adding to direction ##\\n high = 1\\n testCounter = 0\\n while(self.query(start + high*direction)):\\n high = high*2\\n testCounter += 1\\n if testCounter > max_iter:\\n print(f\\\"Warning: Stuck in t_plus high loop with: \\\\n\\\\\\n high = {high}\\\\n\\\")\\n \\n low = high/2\\n testCounter = 0\\n while(not self.query(start + low*direction)):\\n low = low/2\\n testCounter += 1\\n if testCounter > max_iter:\\n print(f\\\"Warning: Stuck in t_plus low loop with: \\\\n\\\\\\n low = {low}\\\\n\\\")\\n \\n # now we know that (start + low * direction) is inside\\n #assert(zonoid_membership_def(A, start+low*direction))\\n # and that (start + high * direction) is outside\\n #assert(not zonoid_membership_def(A, start+high*direction))\\n \\n tol = 1e-5\\n t_plus = (high-low)/2\\n old_t = 1\\n current = start\\n testCounter = 0\\n while(abs(t_plus-old_t) > tol):\\n old_t = t_plus\\n t_plus = (high+low)/2\\n testpoint = current + t_plus*direction\\n if( self.query(testpoint) ):\\n low = t_plus\\n else:\\n high = t_plus\\n \\n testCounter += 1\\n if testCounter > max_iter:\\n print(f\\\"Warning: Stuck in t_plus loop with: \\\\n\\\\\\n t_plus = {t_plus}\\\\n\\\\\\n t_old = {t_old}\\\\n\\\\\\n high = {high}\\\\n\\\\\\n low = {low}\\\\n\\\")\\n t_plus = old_t\\n \\n ## Case for subtracting from direction\\n high = -1\\n testCounter = 0\\n while(self.query(start + high*direction)):\\n high = high*2\\n testCounter += 1\\n if testCounter > max_iter:\\n print(f\\\"Warning: Stuck in t_minus high loop with: \\\\n\\\\\\n high = {high}\\\\n\\\")\\n \\n low = high/2\\n testCounter = 0\\n while(not self.query(start + low*direction)):\\n low = low/2\\n testCounter += 1\\n if testCounter > max_iter:\\n print(f\\\"Warning: Stuck in t_minus low loop with: \\\\n\\\\\\n low = {low}\\\\n\\\")\\n \\n # now we know that (start + low * direction) is inside\\n #assert(zonoid_membership_def(A, start+low*direction))\\n # and that (start + high * direction) is outside\\n #assert(not zonoid_membership_def(A, start+high*direction))\\n \\n tol = 1e-10\\n t_minus = (high-low)/2\\n old_t = 1\\n current = start\\n testCounter = 0\\n while(abs(t_minus-old_t) > tol):\\n old_t = t_minus\\n t_minus = (high+low)/2\\n testpoint = current + t_minus*direction\\n if( self.query(testpoint) ):\\n low = t_minus\\n else:\\n high = t_minus\\n \\n testCounter += 1\\n if testCounter > max_iter:\\n print(f\\\"Warning: Stuck in t_minus loop with: \\\\n\\\\\\n t_minus = {t_minus}\\\\n\\\\\\n t_old = {t_old}\\\\n\\\\\\n high = {high}\\\\n\\\\\\n low = {low}\\\\n\\\")\\n t_minus = old_t\\n \\n # Make the step\\n final_t = np.random.uniform(t_minus, t_plus)\\n #print(f\\\"Final t = {final_t}\\\")\\n \\n # remove extra returns for now for other compatibility\\n return start + final_t*direction #, start+t_plus*direction, start+t_minus*direction\",\n \"def Ez_area(position, angle, detect):\\n# a = range(round(-2*Ez_height),round(2*Ez_height))\\n# b = range(round(-2*Ez_height),round(2*Ez_height))\\n# a_valid = []\\n# b_valid= []\\n \\n # These are the grid points in a coordinate system based on the Ez's angle\\n if detect:\\n a_valid = [-11, -11, -11, -11, -11, -11, -11, -11, -11, -11, -11, -11, -11, -10, -10, -10, -10, -10, -10, -10, -10, -10, -10, -10, -10, -10, -9, -9, -9, -9, -9, -9, -9, -9, -9, -9, -9, -9, -9, -8, -8, -8, -8, -8, -8, -8, -8, -8, -8, -8, -8, -8, -7, -7, -7, -7, -7, -7, -7, -7, -7, -7, -7, -7, -7, -6, -6, -6, -6, -6, -6, -6, -6, -6, -6, -6, -6, -6, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 5, 5, 5, 5, 5, 5, 5, 5, 5, 6, 6, 6, 6, 6, 6, 6]\\n b_valid = [-6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, -4, -3, -2, -1, 0, 1, 2, 3, 4, -3, -2, -1, 0, 1, 2, 3]\\n else:\\n a_valid = [-9, -9, -9, -9, -9, -9, -9, -9, -9, -8, -8, -8, -8, -8, -8, -8, -8, -8, -7, -7, -7, -7, -7, -7, -7, -7, -7, -6, -6, -6, -6, -6, -6, -6, -6, -6, -5, -5, -5, -5, -5, -5, -5, -5, -5, -4, -4, -4, -4, -4, -4, -4, -4, -4, -3, -3, -3, -3, -3, -3, -3, -3, -3, -2, -2, -2, -2, -2, -2, -2, -2, -2, -1, -1, -1, -1, -1, -1, -1, -1, -1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 4, 4, 4, 4, 4]#[-19, -19, -19, -19, -19, -19, -19, -19, -19, -19, -19, -19, -19, -19, -19, -19, -19, -19, -19, -18, -18, -18, -18, -18, -18, -18, -18, -18, -18, -18, -18, -18, -18, -18, -18, -18, -18, -18, -17, -17, -17, -17, -17, -17, -17, -17, -17, -17, -17, -17, -17, -17, -17, -17, -17, -17, -17, -16, -16, -16, -16, -16, -16, -16, -16, -16, -16, -16, -16, -16, -16, -16, -16, -16, -16, -16, -15, -15, -15, -15, -15, -15, -15, -15, -15, -15, -15, -15, -15, -15, -15, -15, -15, -15, -15, -14, -14, -14, -14, -14, -14, -14, -14, -14, -14, -14, -14, -14, -14, -14, -14, -14, -14, -14, -13, -13, -13, -13, -13, -13, -13, -13, -13, -13, -13, -13, -13, -13, -13, -13, -13, -13, -13, -12, -12, -12, -12, -12, -12, -12, -12, -12, -12, -12, -12, -12, -12, -12, -12, -12, -12, -12, -11, -11, -11, -11, -11, -11, -11, -11, -11, -11, -11, -11, -11, -11, -11, -11, -11, -11, -11, -10, -10, -10, -10, -10, -10, -10, -10, -10, -10, -10, -10, -10, -10, -10, -10, -10, -10, -10, -9, -9, -9, -9, -9, -9, -9, -9, -9, -9, -9, -9, -9, -9, -9, -9, -9, -9, -9, -8, -8, -8, -8, -8, -8, -8, -8, -8, -8, -8, -8, -8, -8, -8, -8, -8, -8, -8, -7, -7, -7, -7, -7, -7, -7, -7, -7, -7, -7, -7, -7, -7, -7, -7, -7, -7, -7, -6, -6, -6, -6, -6, -6, -6, -6, -6, -6, -6, -6, -6, -6, -6, -6, -6, -6, -6, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 9, 9, 9, 9, 9, 9, 9, 9, 9]\\n b_valid = [-4, -3, -2, -1, 0, 1, 2, 3, 4, -4, -3, -2, -1, 0, 1, 2, 3, 4, -4, -3, -2, -1, 0, 1, 2, 3, 4, -4, -3, -2, -1, 0, 1, 2, 3, 4, -4, -3, -2, -1, 0, 1, 2, 3, 4, -4, -3, -2, -1, 0, 1, 2, 3, 4, -4, -3, -2, -1, 0, 1, 2, 3, 4, -4, -3, -2, -1, 0, 1, 2, 3, 4, -4, -3, -2, -1, 0, 1, 2, 3, 4, -4, -3, -2, -1, 0, 1, 2, 3, 4, -4, -3, -2, -1, 0, 1, 2, 3, 4, -3, -2, -1, 0, 1, 2, 3, -2, -1, 0, 1, 2]#[-9, -8, -7, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, -9, -8, -7, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, -9, -8, -7, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, -9, -8, -7, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, -9, -8, -7, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, -9, -8, -7, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, -9, -8, -7, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, -9, -8, -7, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, -9, -8, -7, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, -9, -8, -7, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, -9, -8, -7, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, -9, -8, -7, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, -9, -8, -7, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, -9, -8, -7, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, -9, -8, -7, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, -9, -8, -7, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, -9, -8, -7, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, -9, -8, -7, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, -9, -8, -7, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, -9, -8, -7, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, -9, -8, -7, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, -9, -8, -7, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, -9, -8, -7, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, -8, -7, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, -7, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7, -7, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, -4, -3, -2, -1, 0, 1, 2, 3, 4]\\n positions = []\\n# for i in a:\\n# for j in b:\\n# if (i > ((Ez_width/2)-Ez_height-detect_length) and abs(j) < (Ez_width/2+detect_length) and i < 0) or (i > 0 and np.sqrt(i**2 + j**2) < Ez_width/2+detect_length):\\n# a_valid.append(i)\\n# b_valid.append(j)\\n# print('AAAA', a_valid)\\n# print(' ')\\n# print('BBBB', b_valid)\\n# print(' ')\\n \\n # This is a coordinate transfromation to x,y\\n for i in range(len(a_valid)):\\n positions.append((int(round(a_valid[i]*np.cos(angle) + b_valid[i]*np.sin(angle) + position[0])), int(round(a_valid[i]*np.sin(angle) - b_valid[i]*np.cos(angle) + position[1]))))\\n return positions\",\n \"def is_valid_cord(x, y, w, h):\\n return x >=0 and x < w and y >= 0 and y < h;\",\n \"def setAzEncoderOffset(ant) :\\n \\n # Retrieve current azimuth offset (arcmin), elevation (degrees) \\n # and az encoder pointing offset (implementation specific).\\n\\n azOffMpName = \\\"Control.Antenna%d.azimuthOffset\\\"%ant\\n pointingConstants = pointingSetup( ant )\\n\\n if device.CarmaAnt().isOvro(ant):\\n actualElMpName = \\\"Ovro%d.AntennaCommon.Drive.Track.actualElevation\\\"%ant\\n elif device.CarmaAnt().isBima(ant): \\n bimaAntNo = ant - 6\\n actualElMpName = \\\"Bima%d.AntennaCommon.Drive.Track.actualElevation\\\"%bimaAntNo\\n [azOffset,actualEl ] = queryMpValues([azOffMpName, actualElMpName])\\n elif device.CarmaAnt().isSza(ant): \\n szaAntNo = ant - 15\\n actualElMpName = \\\"Sza%d.AntennaCommon.Drive.Track.actualElevation\\\"%szaAntNo\\n [azOffset,actualEl ] = queryMpValues([azOffMpName, actualElMpName])\\n else:\\n raise Exception, \\\"Invalid ant\\\"\\n\\n [azOffset,actualEl ] = queryMpValues([azOffMpName, actualElMpName])\\n cosEl = math.cos( actualEl * math.pi / 180.0 )\\n\\n if device.CarmaAnt().isOvro(ant):\\n pointingConstants[0] = pointingConstants[0] + azOffset/cosEl\\n ovroMountPointingConstants( pointingConstants[0],\\n pointingConstants[1],\\n pointingConstants[2],\\n pointingConstants[3],\\n pointingConstants[4], ant )\\n elif device.CarmaAnt().isBima(ant): \\n pointingConstants[0][0] = pointingConstants[0][0] + azOffset/cosEl\\n bimaMountPointingConstants( pointingConstants[0], pointingConstants[1], ant )\\n elif device.CarmaAnt().isSza(ant): \\n # For SZA, the az zero (term 7 in the pointing constants) is in degrees \\n pointingConstants[6] += ( ( azOffset/cosEl ) / 60.0 );\\n # Avoid having to spell out all 19 arguments by using the special \\n # form '*args' with a list of ordered args.\\n args = pointingConstants \\n args.append( ant )\\n szaMountPointingConstants( *args )\\n else:\\n raise Exception, \\\"Invalid ant\\\"\\n\\n return offset(0, 0, ant)\",\n \"def iscircle(a):\\n if isarc(a):\\n start=a[1][1] \\n end=a[1][2]\\n ## these are special, integer values that flag a true full\\n ## circle.\\n if start==0 and end==360:\\n return True\\n else:\\n return False\",\n \"def test_Calc_accuracy(self, start, end, expected_len_result, expected_first_angles, expected_LHumerus):\\n angles, jcs = pycgmCalc.Calc(start, end, self.motion_data, self.cal_SM)\\n np.testing.assert_equal(len(angles), expected_len_result)\\n np.testing.assert_equal(len(jcs), expected_len_result)\\n np.testing.assert_almost_equal(angles[0][:5], expected_first_angles, self.rounding_precision)\\n np.testing.assert_almost_equal(jcs[0]['LHumerus'], expected_LHumerus, self.rounding_precision)\",\n \"def _can_component_fuse_assumption(self, assumption: TrackingAssumption) -> bool:\\n gps = [\\n GriddedPerm.point_perm(self.first_cell),\\n GriddedPerm.point_perm(self.second_cell),\\n ]\\n return ( # if right type\\n (\\n isinstance(assumption, SumComponentAssumption)\\n and self.is_sum_component_fusion()\\n )\\n or (\\n isinstance(assumption, SkewComponentAssumption)\\n and self.is_skew_component_fusion()\\n ) # or covers whole region or none of it\\n or all(gp in assumption.gps for gp in gps)\\n or all(gp not in assumption.gps for gp in gps)\\n )\",\n \"def _dwd_channel_preparation(self,\\n channels,\\n sun_zenith_angle_correction=True,\\n backup_orig_data=False\\n ):\\n result = True\\n\\n if not isinstance(channels, list):\\n channels = [channels]\\n\\n for c in channels:\\n if sun_zenith_angle_correction:\\n self._dwd_apply_sun_zenith_angle_correction(\\n c,\\n backup_orig_data=backup_orig_data)\\n else:\\n self._dwd_undo_sun_zenith_angle_correction(c)\\n self._dwd_apply_view_zenith_angle_correction(c)\\n self._dwd_kelvin_to_celsius(c)\\n if self[c].info['units'] != 'C' and \\\\\\n self[c].info['units'] not in ['%', 'ALBEDO(%)', 'percent']:\\n result = False\\n LOGGER.error(\\n \\\"Calibration for channel \\\" + str(c) +\\n \\\" failed due to unknown unit \\\" + self[c].info['units'])\\n return result\",\n \"def test_comp_angle_opening(self, test_dict):\\n test_obj = test_dict[\\\"test_obj\\\"]\\n a = test_obj.slot.comp_angle_opening()\\n self.assertEqual(a, 2 * pi / test_obj.slot.Zs)\\n\\n b = comp_angle_opening(test_obj.slot)\\n msg = \\\"Return \\\" + str(a) + \\\" expected \\\" + str(b)\\n self.assertAlmostEqual((a - b) / a, 0, delta=DELTA, msg=msg)\",\n \"def test_galactic():\\n center = coord.CelestialCoord(coord.Angle.from_hms('17:45:37.1991'),\\n coord.Angle.from_dms('-28:56:10.2207'))\\n north = coord.CelestialCoord(coord.Angle.from_hms('12:51:26.27549'),\\n coord.Angle.from_dms('27:07:41.7043'))\\n south = coord.CelestialCoord(coord.Angle.from_hms('00:51:26.27549'),\\n coord.Angle.from_dms('-27:07:41.7043'))\\n anticenter = coord.CelestialCoord(coord.Angle.from_hms('05:45:37.1991'),\\n coord.Angle.from_dms('28:56:10.2207'))\\n random = coord.CelestialCoord(0.234 * coord.radians, 0.342 * coord.radians)\\n\\n for c1 in [center, north, south, anticenter, random]:\\n a1 = astropy.coordinates.SkyCoord(*c1.rad, unit=units.rad, frame='fk5')\\n #print('c1.galactic() = ',c1.galactic())\\n #print('a1.galactic = ',a1.galactic)\\n el, b = c1.galactic()\\n # Wrap el to the same phase as a1\\n el = el.wrap(a1.galactic.l.rad * coord.radians)\\n if c1 not in [north, south]:\\n np.testing.assert_almost_equal(el.rad, a1.galactic.l.rad, decimal=6)\\n np.testing.assert_almost_equal(b.rad, a1.galactic.b.rad, decimal=6)\\n\\n c2 = coord.CelestialCoord.from_galactic(el,b)\\n a2 = astropy.coordinates.SkyCoord(el.rad, b.rad, unit=units.radian, frame='galactic')\\n a2 = a2.transform_to('fk5')\\n c2_ra = c2.ra.wrap(a2.ra.rad * coord.radians)\\n np.testing.assert_almost_equal(c2_ra.rad, a2.ra.rad, decimal=6)\\n np.testing.assert_almost_equal(c2.dec.rad, a2.dec.rad, decimal=6)\",\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 has_arc(self, a, b):\\n return self.matrix[a][b] != 0\",\n \"def check_directionality_viable(self):\\n\\n direction_viable = True\\n nose_cords, ear_left_cords, ear_right_cords = [], [], []\\n for animal_name in self.animal_bp_dict.keys():\\n for bp_cord in [\\\"X_bps\\\", \\\"Y_bps\\\"]:\\n bp_list = self.animal_bp_dict[animal_name][bp_cord]\\n for bp_name in bp_list:\\n bp_name_components = bp_name.split(\\\"_\\\")\\n bp_name_components = [x.lower() for x in bp_name_components]\\n if \\\"nose\\\" in bp_name_components:\\n nose_cords.append(bp_name)\\n elif (\\\"ear\\\" in bp_name_components) and (\\n \\\"left\\\" in bp_name_components\\n ):\\n ear_left_cords.append(bp_name)\\n elif (\\\"ear\\\" in bp_name_components) and (\\n \\\"right\\\" in bp_name_components\\n ):\\n ear_right_cords.append(bp_name)\\n else:\\n pass\\n\\n for cord in [nose_cords, ear_left_cords, ear_right_cords]:\\n if len(cord) != len(self.animal_bp_dict.keys()) * 2:\\n direction_viable = False\\n\\n if direction_viable:\\n nose_cords = [\\n nose_cords[i * 2 : (i + 1) * 2]\\n for i in range((len(nose_cords) + 2 - 1) // 2)\\n ]\\n ear_left_cords = [\\n ear_left_cords[i * 2 : (i + 1) * 2]\\n for i in range((len(ear_left_cords) + 2 - 1) // 2)\\n ]\\n ear_right_cords = [\\n ear_right_cords[i * 2 : (i + 1) * 2]\\n for i in range((len(ear_right_cords) + 2 - 1) // 2)\\n ]\\n\\n return direction_viable, nose_cords, ear_left_cords, ear_right_cords\",\n \"def is_ccw(a, b, c):\\n p = b - a\\n q = c - a\\n area = p.x * q.y - q.x * p.y\\n\\t # May want to throw an exception if area == 0\\n return area > 0\",\n \"def valid(a,b,x,y):\\n\\t# Size of the square grid that encases rectagle x,y\\n\\tsquare = x + y - 2\\n\\t# Taxi cab distance (no diagonals) from (p_a, p_b) to (a,b)\\n\\tsteps = lambda p_a, p_b: abs(p_a - a) + abs(p_b - b)\\n\\t# Top/Bottom/Left/Right bound\\n\\tif min(a,b) < 0 or max(a,b) >= square: return False\\n\\t# Upper left/Lower right corner check\\n\\tif steps(0,0) < (x - 2) or steps(square - 1, square - 1) < (x - 2): return False \\n\\t# Lower left/Upper right corner check\\n\\telif steps(square - 1, 0) < (y - 2) or steps( 0, square - 1) < (y - 2): return False\\n\\treturn True\",\n \"def test_calcAngles_angles_and_axis(self, kargs, expected_len_result, expected_first_angle, expected_first_axis):\\n kargs['vsk'] = self.cal_SM\\n angles, axis = pycgmCalc.calcAngles(self.motion_data, **kargs)\\n np.testing.assert_equal(len(angles), expected_len_result)\\n np.testing.assert_equal(len(axis), expected_len_result)\\n np.testing.assert_almost_equal(angles[0][0], expected_first_angle, self.rounding_precision)\\n np.testing.assert_almost_equal(axis[0][0], expected_first_axis, self.rounding_precision)\",\n \"def do_polar_alignment_test(self, *arg):\\n if self.ready is False:\\n return\\n\\n start_time = current_time(flatten=True)\\n\\n base_dir = '{}/images/drift_align/{}'.format(\\n os.getenv('PANDIR'), start_time)\\n plot_fn = '{}/{}_center_overlay.jpg'.format(base_dir, start_time)\\n\\n mount = self.pocs.observatory.mount\\n\\n print_info(\\\"Moving to home position\\\")\\n self.pocs.say(\\\"Moving to home position\\\")\\n mount.slew_to_home()\\n\\n # Polar Rotation\\n pole_fn = polar_rotation(self.pocs, base_dir=base_dir)\\n pole_fn = pole_fn.replace('.cr2', '.fits')\\n\\n # Mount Rotation\\n rotate_fn = mount_rotation(self.pocs, base_dir=base_dir)\\n rotate_fn = rotate_fn.replace('.cr2', '.fits')\\n\\n print_info(\\\"Moving back to home\\\")\\n self.pocs.say(\\\"Moving back to home\\\")\\n mount.slew_to_home()\\n\\n print_info(\\\"Solving celestial pole image\\\")\\n self.pocs.say(\\\"Solving celestial pole image\\\")\\n try:\\n pole_center = polar_alignment_utils.analyze_polar_rotation(pole_fn)\\n except error.SolveError:\\n print_warning(\\\"Unable to solve pole image.\\\")\\n print_warning(\\\"Will proceeed with rotation image but analysis not possible\\\")\\n pole_center = None\\n else:\\n pole_center = (float(pole_center[0]), float(pole_center[1]))\\n\\n print_info(\\\"Starting analysis of rotation image\\\")\\n self.pocs.say(\\\"Starting analysis of rotation image\\\")\\n try:\\n rotate_center = polar_alignment_utils.analyze_ra_rotation(rotate_fn)\\n except Exception:\\n print_warning(\\\"Unable to process rotation image\\\")\\n rotate_center = None\\n\\n if pole_center is not None and rotate_center is not None:\\n print_info(\\\"Plotting centers\\\")\\n self.pocs.say(\\\"Plotting centers\\\")\\n\\n print_info(\\\"Pole: {} {}\\\".format(pole_center, pole_fn))\\n self.pocs.say(\\\"Pole : {:0.2f} x {:0.2f}\\\".format(\\n pole_center[0], pole_center[1]))\\n\\n print_info(\\\"Rotate: {} {}\\\".format(rotate_center, rotate_fn))\\n self.pocs.say(\\\"Rotate: {:0.2f} x {:0.2f}\\\".format(\\n rotate_center[0], rotate_center[1]))\\n\\n d_x = pole_center[0] - rotate_center[0]\\n d_y = pole_center[1] - rotate_center[1]\\n\\n self.pocs.say(\\\"d_x: {:0.2f}\\\".format(d_x))\\n self.pocs.say(\\\"d_y: {:0.2f}\\\".format(d_y))\\n\\n fig = polar_alignment_utils.plot_center(\\n pole_fn, rotate_fn, pole_center, rotate_center)\\n\\n print_info(\\\"Plot image: {}\\\".format(plot_fn))\\n fig.tight_layout()\\n fig.savefig(plot_fn)\\n\\n try:\\n os.unlink('/var/panoptes/images/latest.jpg')\\n except Exception:\\n pass\\n try:\\n os.symlink(plot_fn, '/var/panoptes/images/latest.jpg')\\n except Exception:\\n print_warning(\\\"Can't link latest image\\\")\\n\\n with open('/var/panoptes/images/drift_align/center.txt'.format(base_dir), 'a') as f:\\n f.write('{}.{},{},{},{},{},{}\\\\n'.format(start_time, pole_center[0], pole_center[\\n 1], rotate_center[0], rotate_center[1], d_x, d_y))\\n\\n print_info(\\\"Done with polar alignment test\\\")\\n self.pocs.say(\\\"Done with polar alignment test\\\")\",\n \"def test_az_za():\\n Nside = 128\\n obs = observatory.Observatory(latitude, longitude, fov=20, nside=Nside)\\n center = [0, 0]\\n lon, lat = [5, 0]\\n ind0 = hp.ang2pix(Nside, lon, lat, lonlat=True)\\n lon, lat = hp.pix2ang(Nside, ind0, lonlat=True)\\n za, az, pix = obs.calc_azza(center, return_inds=True)\\n ind = np.where(pix == ind0)\\n # lon = longitude of the source, which is set to 5deg off zenith (hence, zenith angle)\\n assert np.isclose(np.degrees(za[ind]), lon)\\n assert np.isclose(np.degrees(az[ind]), 90.0)\",\n \"def test_calcAngles_angles_or_axis(self, kargs, expected_len_result, expected_truncated_results):\\n kargs['vsk'] = self.cal_SM\\n result = pycgmCalc.calcAngles(self.motion_data, **kargs)\\n np.testing.assert_equal(len(result), expected_len_result)\\n np.testing.assert_almost_equal(result[0:5], expected_truncated_results)\",\n \"def check_boundaries(data, theta1, theta2):\\n x, y = np.indices((data.shape))\\n center = np.array([(x.max() - x.min()) / 2.0, (y.max() - y.min()) / 2.0])\\n theta = np.degrees(np.arctan2(y - center[1], x - center[0])) + 180\\n\\n in_theta = (theta < theta1) | (theta > theta2)\\n\\n data2 = data.copy()\\n data2[in_theta] = np.nan\\n return data2\",\n \"def bearing(start,finish):\\n\\n s = math.pi * np.squeeze(np.array(start)) / 180\\n f = math.pi * np.squeeze(np.array(finish)) / 180\\n\\n y = math.sin(f[1] - s[1]) * math.cos(f[0])\\n x = math.cos(s[0])*math.sin(f[0]) - math.sin(s[0])*math.cos(f[0])*math.cos(f[1] - s[1])\\n\\n return math.atan2(y,x)/math.pi * 180 % 360\",\n \"def check_reached(self):\\n m_x, m_y = self.destination.get_pos()\\n m_radius = self.destination.radius\\n distance_centre = math.sqrt((m_x - self.x)**2 + (m_y - self.y)**2)\\n sum_radii = m_radius + self.radius\\n if distance_centre < sum_radii:\\n self.color = pygame.colordict.THECOLORS['green']\\n self.has_reached = True\",\n \"def test_central(self):\\n self.assertTrue(self.cs.isCentral)\",\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_availibity(self, starts_at: datetime.datetime, ends_at: datetime.datetime):\\n for unavailable in self.unavailable:\\n if unavailable[0] <= starts_at <= unavailable[1]:\\n return False\\n if unavailable[0] <= ends_at <= unavailable[1]:\\n return False\\n return True\",\n \"def test_climb(self):\\n fcs = flight_control.FlightControl(**self.start)\\n\\n altitude = 120.0\\n pitch_angle = 10.0\\n alt_cmd = cmds.SetAltitudeCmd(120.0, 10.0)\\n fcs.set_altitude_cmd(alt_cmd)\\n\\n #heading = 150.0\\n #heading_cmd = cmds.SetHeadingCmd(heading)\\n #fcs.set_direction_cmd(heading_cmd)\\n\\n t = self.tmin\\n while t < self.tmax:\\n fcs.tick(t, self.dt)\\n t += self.dt\\n\\n self.assertAlmostEqual(fcs.platform.z, altitude, delta=1.0)\\n self.assertAlmostEqual(fcs.platform.theta_c, 0.0, delta=1.0)\",\n \"def test_absolute_areas(self):\\n\\n assert len(self.test_shape.areas) == 4\\n assert len(set([round(i) for i in self.test_shape.areas])) == 3\\n assert self.test_shape.areas.count(pytest.approx(60 * math.pi * 2 * 1000)) == 2\\n assert self.test_shape.areas.count(pytest.approx(50 * math.pi * 2 * 970)) == 1\\n assert self.test_shape.areas.count(pytest.approx(50 * math.pi * 2 * 1030)) == 1\",\n \"def angle_between(vecs, baseline):\\n vecs = CA_coords(vecs)\\n baseline = CA_coords(baseline)\\n return np.arccos(np.clip(vecs @ baseline.T, -1.0, 1.0))\",\n \"def _sample_angle(self):\\n active_names = (\\\"N\\\", \\\"CA\\\", \\\"C\\\", \\\"O\\\", \\\"CB\\\", \\\"H\\\", \\\"HA\\\")\\n selection = self.covalent_residue.select(\\\"name\\\", active_names)\\n self.covalent_residue._active = False\\n self.covalent_residue._active[selection] = True\\n self.covalent_residue.update_clash_mask()\\n active = self.covalent_residue.active\\n angles = np.arange(\\n -self.options.sample_angle_range,\\n self.options.sample_angle_range + 0.001,\\n self.options.sample_angle_step,\\n )\\n new_coor_set = []\\n new_bs = []\\n for coor in self._coor_set:\\n self.covalent_residue.coor = coor\\n rotator = CBAngleRotator(self.covalent_residue)\\n for angle in angles:\\n rotator(angle)\\n coor = self.covalent_residue.coor\\n if self.options.remove_conformers_below_cutoff:\\n values = self.xmap.interpolate(coor[active])\\n mask = self.covalent_residue.e[active] != \\\"H\\\"\\n if np.min(values[mask]) < self.options.density_cutoff:\\n continue\\n if self.options.external_clash:\\n if self._cd() or self.covalent_residue.clashes():\\n continue\\n elif self.covalent_residue.clashes():\\n continue\\n new_coor_set.append(self.covalent_residue.coor)\\n new_bs.append(self.conformer.b)\\n\\n self._coor_set = new_coor_set\\n self._bs = new_bs\\n # logger.debug(f\\\"Bond angle sampling generated {len(self._coor_set)} conformers.\\\")\",\n \"def Cool_per_Grain(grain_size, grain_type, ZZ, fdist, ntot, xe, temp):\\n import numpy as np\\n import math\\n import compute_charge_dist as fz\\n \\n tau = grain_size * fz.AAtocm * fz.kb * temp / fz.echarge**2\\n \\n # Loop over species!\\n Cool_spec = 0\\n for partner in [\\\"electron\\\", \\\"hydrogen\\\", \\\"carbon\\\"]:\\n \\n Cool_Zall = 0\\n # Loop over charge\\n for zi in range(len(ZZ)):\\n \\n if partner == \\\"electron\\\":\\n nu = -1*ZZ[zi]\\n stick_coef = fz.get_stickCoef(ZZ[zi], grain_size, grain_type)\\n charge_frac = xe\\n mass = fz.me\\n \\n elif partner == \\\"hydrogen\\\":\\n nu = ZZ[zi]\\n stick_coef = 1.0\\n charge_frac = xe\\n mass = fz.mH\\n \\n elif partner == \\\"carbon\\\":\\n nu = ZZ[zi]\\n stick_coef = 1.0\\n # Maximum fraction of ionized Carbon is 1e-4*ntot.\\n charge_frac = min(1.0e-4, xe)\\n mass = fz.mC\\n \\n Cooltilde = 1.0\\n \\n if nu < 0:\\n Cooltilde = fz.Jtilde_neg(tau, nu)\\n elif nu == 0:\\n Cooltilde = fz.Jtilde_0(tau, nu)\\n else:\\n Cooltilde = fz.Jtilde_pos(tau, nu)\\n \\n #print(zi)\\n Cool_Zhere = fdist[zi]*Cooltilde*fz.kb*temp\\n Cool_Zall += Cool_Zhere\\n \\n #print(\\\"Collisional Partner = \\\", partner)\\n Cool_spec += ntot*charge_frac*stick_coef*np.sqrt(8.0*fz.kb*temp/(np.pi*mass))*Cool_Zall\\n \\n Cool_tot = math.pi * (grain_size*AAtocm)**2 * Cool_spec\\n \\n return Cool_tot\",\n \"def can_rotate(self) -> (bool, list, list):\\n arms, axis = self.get_arms()\\n rotation = self.get_rotation()\\n if rotation[1][0] == 0:\\n return False\\n coord_axis = np.array([[axis.x_obj], [axis.y_obj]])\\n coord_arms = [np.array([[arm.x_obj], [arm.y_obj]])\\n for arm in arms]\\n coord_new_arms = []\\n # Collecting arm coordinates in the situation there turnstile rotates\\n for i in range(len(arms)):\\n coord_arm = coord_arms[i]\\n coord_new_arms.append(\\n np.dot(rotation, coord_arm - coord_axis) + coord_axis)\\n can_rotate = True\\n for i in range(len(arms)):\\n coord_arm = coord_arms[i]\\n coord_new_arm = coord_new_arms[i]\\n # Object turnstile should push\\n coord_front = coord_arm + coord_new_arm - coord_axis\\n coord_character = np.array(\\n [[self.moving_character.x_obj], [self.moving_character.y_obj]])\\n obj_front = self.grid.obj_list[\\n coord_front[0][0], coord_front[1][0]]\\n if not (isinstance(obj_front, ob.Void) or (coord_front == coord_character).all()):\\n can_rotate = False\\n # Object being at the destination of the arm\\n obj_target = self.grid.obj_list[\\n coord_new_arm[0][0], coord_new_arm[1][0]]\\n if not isinstance(obj_target, (ob.Void, ob.TurnstileBloc)):\\n can_rotate = False\\n return can_rotate, coord_arms, coord_new_arms\",\n \"def _cal_meaningful_corners(self):\\n corners = np.where(self._free_of_clash)\\n corners = np.array(corners, dtype=int)\\n corners = corners.transpose()\\n return corners\",\n \"def __contains__(self, angle):\\n angle = normalize(angle, min(self.start, self.finish), max(self.start, self.finish))\\n return (self.start <= angle < self.finish) or (self.finish <= angle < self.start)\",\n \"def check_course_start_end_dates(self, start_date, end_date, env):\\n self.assertEquals(\\n start_date, courses.Course.get_named_course_setting_from_environ(\\n constants.START_DATE_SETTING, env))\\n self.assertEquals(\\n end_date, courses.Course.get_named_course_setting_from_environ(\\n constants.END_DATE_SETTING, env))\",\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 check_invalid_actions(y):\\n inval_actions = [\\n [ 0.0, 1.0, 0.4], # ACCEL_BRAKE\\n [ 1.0, 1.0, 0.4], # RIGHT_ACCEL_BRAKE\\n [-1.0, 1.0, 0.4], # LEFT_ACCEL_BRAKE\\n [ 1.0, 1.0, 0.0], # RIGHT_ACCEL\\n [-1.0, 1.0, 0.0], # LEFT_ACCEL\\n ]\\n ia_count = 0\\n for ia in inval_actions:\\n ia_count += np.sum(np.all(y == ia, axis=1))\\n if ia_count > 0:\\n raise Exception('Invalid actions. Do something developer!')\",\n \"def checkObstaclesAhead(ldr_compl,tireAngle, maxLen=0.3,threshold=2):\\n #within the car-width and the maxLen\\n # at 45 degrees shift real for 0.05m\\n madeUpHeuristic = tireAngle*0.07/45 #shifts real-axis dependent on tire angle\\n madeUpHeuristic2= abs(tireAngle*0.14/45) #at 45degrees append CAR_WIDTH with 0.15m\\n obstacleIdx = (ldr_compl.imag<maxLen)*(abs(ldr_compl.real+madeUpHeuristic)<((CAR_WIDTH/100+madeUpHeuristic2)/2))\\n if is_debugging:\\n plt.plot(ldr_compl.real,ldr_compl.imag,'.')\\n plt.show()\\n print(sum(obstacleIdx))\\n return sum(obstacleIdx)>threshold\",\n \"def test_align_points(self):\\n mv = [\\n [0, 0, 5],\\n [5, 0, 5],\\n [0, 5, 5]\\n ]\\n sv = [\\n [0, 0, 0],\\n [5, 0, 0],\\n [0, 5, 0]\\n ]\\n al = align(self.amp1, self.amp2, mv=mv, sv=sv, method='contPoints').m\\n zMax = self.amp1.vert[:, 2].max() - 5\\n # Both objects are already centered, so should be close to origin (allowing for some inaccuracy)\\n self.assertAlmostEqual(al.vert[:, 2].max(), zMax, delta=TestAlign.DELTA)\",\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 Check(self):\\n cleared = False\\n while not cleared:\\n for i in list(combinations([cell.Check() for cell in self.cells], 2)):\\n # for i in list(combinations(zip(self.locations.x,self.locations.y,self.locations.length,self.locations.index),2)):\\n x1 = i[0][0]\\n y1 = i[0][1]\\n r1 = i[0][2] / 2\\n idx1 = i[0][3]\\n x2 = i[1][0]\\n y2 = i[1][1]\\n r2 = i[1][2] / 2\\n idx1 = i[0][3]\\n idx2 = i[1][3]\\n distance = (x1 - x2) * (x1 - x2) + (y1 - y2) * (y1 - y2)\\n radii = (r1 + r2) * (r1 + r2)\\n if distance == radii:\\n cleared = True\\n elif distance > radii:\\n cleared = True\\n else:\\n if x1 > x2 and y1 > y2:\\n if (\\n x1 + r1 > 0\\n and x1 + r1 < self.boundaries[0]\\n and y1 + r1 > 0\\n and y1 + r1 < self.boundaries[1]\\n ):\\n self.cells[idx1].x = x1 + r1 / 2\\n self.cells[idx1].y = y1 + r1 / 2\\n elif x1 > x2 and y1 < y2:\\n if (\\n x1 + r1 > 0\\n and x1 + r1 < self.boundaries[0]\\n and y1 - r1 > 0\\n and y1 - r1 < self.boundaries[1]\\n ):\\n self.cells[idx1].x = x1 + r1 / 2\\n self.cells[idx1].y = y1 - r1 / 2\\n elif x1 < x2 and y1 > y2:\\n if (\\n x1 - r1 > 0\\n and x1 - r1 < self.boundaries[0]\\n and y1 + r1 > 0\\n and y1 + r1 < self.boundaries[1]\\n ):\\n self.cells[idx1].x = x1 - r1 / 2\\n self.cells[idx1].y = y1 + r1 / 2\\n else:\\n if (\\n x1 - r1 > 0\\n and x1 - r1 < self.boundaries[0]\\n and y1 - r1 > 0\\n and y1 - r1 < self.boundaries[1]\\n ):\\n self.cells[idx1].x = x1 - r1 / 2\\n self.cells[idx1].y = y1 - r1 / 2\\n _logger.debug(\\n f\\\"Bumped from {x1 :.2e}, {y1 :.2e} to {self.cells[idx1].x :.2e}, {self.cells[idx1].y :.2e}\\\"\\n )\\n cleared = False\\n return\",\n \"def ensure_outside_conus(ls):\\n # First and last point of the ls need to be exterior to the CONUS\\n for idx in [0, -1]:\\n pt = Point(ls.coords[idx])\\n # If point is safely outside CONUS, done.\\n if point_outside_conus(pt):\\n continue\\n # Get new point that may be too close for comfort\\n pt = get_conus_point(pt)\\n if pt.within(CONUS[\\\"poly\\\"]) or pt.distance(CONUS[\\\"poly\\\"]) < 0.001:\\n LOG.warning(\\\" idx: %s is still within, evasive action\\\", idx)\\n done = False\\n for multi in [0.01, 0.1, 1.0]:\\n if done:\\n break\\n for xoff, yoff in [\\n [-0.01 * multi, -0.01 * multi],\\n [-0.01 * multi, 0.0 * multi],\\n [-0.01 * multi, 0.01 * multi],\\n [0.0 * multi, -0.01 * multi],\\n [0.0 * multi, 0.0 * multi],\\n [0.0 * multi, 0.01 * multi],\\n [0.01 * multi, -0.01 * multi],\\n [0.01 * multi, 0.0 * multi],\\n [0.01 * multi, 0.01 * multi],\\n ]:\\n pt2 = translate(pt, xoff=xoff, yoff=yoff)\\n if not pt2.within(CONUS[\\\"poly\\\"]):\\n pt = pt2\\n LOG.warning(\\\" idx: %s is now %s\\\", idx, pt)\\n done = True\\n break\\n LOG.warning(\\n \\\" fix idx: %s to new: %.4f %.4f Inside: %s\\\",\\n idx,\\n pt.x,\\n pt.y,\\n pt.within(CONUS[\\\"poly\\\"]),\\n )\\n coords = list(ls.coords)\\n coords[idx] = (pt.x, pt.y)\\n ls = LineString(coords)\\n return ls\",\n \"def test_relative_shape_volume(self):\\n\\n test_volume = self.test_shape.volume()\\n self.test_shape.azimuth_placement_angle = [0, 90, 180, 270]\\n assert test_volume * 4 == pytest.approx(self.test_shape.volume())\",\n \"def _isLineTanToArc(self, x1, y1, x2, y2, cx, cy, d):\\n p = QPointF(x2, y2)\\n # line start -> end\\n v1 = QVector2D(p - QPointF(x1, y1)).normalized()\\n # arc center -> arc start\\n v2 = QVector2D(p - QPointF(cx, cy)).normalized()\\n if abs(v1.dotProduct(v1, v2)) <= 1e-6:\\n # TODO: handle case where arc turns back into the line\\n return True\\n else:\\n return False\",\n \"def heating_system_is_ac(bpr):\\n\\n if bpr.hvac['type_hs'] in {'T3'}: # central ac\\n return True\\n elif bpr.hvac['type_hs'] in {'T0', 'T1', 'T2', 'T4'}:\\n return False\\n else:\\n print('Error: Unknown heating system')\\n return False\",\n \"def azizen(self):\\n # x0,y0 array pixel coordinates relative to cx,cy\\n# ndy0,ndx0=img.shape\\n ndy0=self.ndy0\\n ndx0=self.ndx0\\n x0,y0=np.meshgrid(np.linspace(0,ndx0-1,ndx0)-self.cx,np.linspace(0,ndy0-1,ndy0)-self.cy)\\n r0=np.sqrt(x0**2+y0**2)/self.pr0 # fractional radial distance from 0,0\\n# self.roi=np.s_[ystart:ystart+self.ny0,xstart:xstart+self.nx0]\\n # why not model the zenith angle dependence with polynomial directly\\n # rather than linear interpolation between roots.\\n roots=np.zeros(51)\\n rr=np.arange(51)/100.0\\n for i,ref in enumerate(rr):\\n roots[i]=np.real(np.roots([self.c3,0,self.c2,0,self.c1,-ref])[-1])\\n theta0 = np.interp(r0/2,rr,roots)\\n \\n phi0 = np.arctan2(x0,y0) - self.rot ####phi (i.e., azimuth) is reckoned with -pi corresponding to north, increasing clockwise, NOTE: pysolar use sub-standard definition\\n phi0 = phi0%(2*np.pi)\\n\\n #####correction for the tilt of the camera\\n k=np.array((np.sin(self.azm),np.cos(self.azm),0))\\n a=np.array([np.sin(theta0)*np.cos(phi0),np.sin(theta0)*np.sin(phi0),np.cos(theta0)]); \\n a = np.transpose(a,[1,2,0])\\n b=np.cos(self.beta)*a + np.sin(self.beta)*np.cross(k,a,axisb=2) \\\\\\n + np.reshape(np.outer(np.dot(a,k),k),(self.ndy0,self.ndx0,3))*(1-np.cos(self.beta))\\n theta0=np.arctan(np.sqrt(b[:,:,0]**2+b[:,:,1]**2)/b[:,:,2])\\n phi0=np.arctan2(b[:,:,1],b[:,:,0])%(2*np.pi)\\n# max_theta *= deg2rad \\n# valid0 = (theta0<max_theta) & (theta0>0); \\n# theta0[valid0]=np.nan;\\n self.theta0,self.phi0=theta0,phi0\",\n \"def quick_check(self):\\n for ang in range(self.MIDPOINT-150, self.MIDPOINT+151, 150):\\n self.servo(ang)\\n if self.read_distance() < self.SAFE_DIST:\\n return False\\n return True\",\n \"def test_far_out_coordinates(rotationangle):\\n\\n eps = 1e-7\\n\\n # Get the limits\\n lim = rotationangle[\\\"cs\\\"].limits()[2:]\\n lim0 = max(lim)\\n lim1 = min(lim)\\n\\n # Setting c2 and c3 to zero\\n c3 = lim0 - eps\\n\\n # A large value which is still valid\\n phi_dash = rotationangle[\\\"cs\\\"].to_rotation_angle(c3)\\n\\n # Setting c2 and c3 to zero\\n c3 = lim1 + eps\\n\\n # A large value which is still valid\\n phi_dash = rotationangle[\\\"cs\\\"].to_rotation_angle(c3)\\n\\n # A large value which is raises an exception\\n with pytest.raises(RuntimeError):\\n c3 = lim0 + eps\\n phi_dash = rotationangle[\\\"cs\\\"].to_rotation_angle(c3)\\n print(phi_dash)\\n\\n with pytest.raises(RuntimeError):\\n c3 = lim1 - eps\\n phi_dash = rotationangle[\\\"cs\\\"].to_rotation_angle(c3)\",\n \"def goal_test(c):\\n return c == GOAL_CUBE\",\n \"def crosstrackdistance(lon1,lat1,\\n lon2,lat2,\\n lon3,lat3,\\n rearth=6.370949e3,\\n altitude=0,\\n deg=True,\\n DEBUG=False):\\n\\n rearth += altitude\\n\\n if deg:\\n lat1, lat2, lat3, lon1, lon2, lon3 = map(np.deg2rad, (lat1, lat2, lat3,\\n lon1, lon2, lon3))\\n \\n # Angular distance between point 1 and point 3 \\n d13 = geo_dist(lon1,lat1,lon3,lat3,\\n deg=False,\\n rearth=rearth,\\n altitude=0)/rearth\\n\\n #initial bearing, 1 to 2 (in DEGREES)\\n b12 = bearing(lat1,lat2,lon1,lon2,deg=False)\\n\\n #initial bearing, 1 to 3 (in DEGREES)\\n b13 = bearing(lat1,lat3,lon1,lon3,deg=False)\\n\\n b12,b13 = map(np.deg2rad, (b12,b13))\\n\\n dist = np.arcsin(np.sin(d13)*np.sin(b13-b12))*rearth\\n\\n if DEBUG:\\n print(\\\"lon1, lat1 : {:5.2f}°, {:5.2f}°\\\".format(np.rad2deg(lon1),np.rad2deg(lat1)))\\n print(\\\"lon2, lat2 : {:5.2f}°, {:5.2f}°\\\".format(np.rad2deg(lon2),np.rad2deg(lat2)))\\n print(\\\"lon3, lat3 : {:5.2f}°, {:5.2f}°\\\".format(np.rad2deg(lon3),np.rad2deg(lat3)))\\n print(\\\"Sphere radius: {:7.2g}\\\".format(rearth))\\n\\n print(\\\"Distance between P3 and great circle formed by P1 and P2: \\\")\\n print(\\\"{:7.2g}\\\".format(dist))\\n\\n print(\\\"Angular distance (deg) between P3 and great circle formed by P1 and P2: \\\")\\n print(\\\"{:7.2g}\\\".format(np.rad2deg(dist/rearth)))\\n\\n return dist\",\n \"def check_obstacle_ahead(distances, angles, save_index = None, length_to_check = 250, half_robot_width = 180, threshold_low = 12, threshold_high = 100):\\n distances = np.array(distances)\\n angles = np.array(angles)\\n # compute angle to differentiate regions\\n delta = np.arctan(half_robot_width / length_to_check) * 57.3\\n\\n # compute the indices for the 2 regions of interest\\n idcs1 = np.logical_or(np.logical_and(angles <= 90, angles >= delta), np.logical_and(angles >= 270, angles <= (360 - delta)))\\n idcs2 = np.logical_or(np.logical_and(angles >= 0, angles <= delta), np.logical_and(angles <= 360, angles >= (360 - delta)))\\n\\n # compute the critical ditance for those regions (set of angles)\\n critical_distance_1 = half_robot_width / np.abs(np.sin(angles[idcs1] / 57.3))\\n critical_distance_2 = length_to_check / np.abs(np.cos(angles[idcs2] / 57.3))\\n\\n # compare actual distances with critical distances\\n obstacles1 = distances[idcs1] < critical_distance_1\\n obstacles2 = distances[idcs2] < critical_distance_2\\n \\n # save for debug\\n if save_index is not None:\\n np.save(\\\"/home/arthur/dev/ros/data/lidar/angles_{}.npy\\\".format(save_index), angles)\\n np.save(\\\"/home/arthur/dev/ros/data/lidar/distances_{}.npy\\\".format(save_index), distances)\\n \\n # return true depending on the obstacle detection\\n count = (np.count_nonzero(obstacles1) + np.count_nonzero(obstacles2))\\n return count >= threshold_low and count <= threshold_high\",\n \"def test_calcAngles_joint_centers(self):\\n _,joint_centers = pycgmCalc.calcAngles(self.motion_data, vsk=self.cal_SM, frame=0,\\\\\\n formatData=False, splitAnglesAxis=False, returnjoints=True)\\n #Verify that several the expected joint_centers are returned.\\n expected_Front_Head = np.array([ 255.19071198, 406.12081909, 1721.92053223])\\n expected_LHip = np.array([182.57097863, 339.43231855, 935.52900126])\\n expected_RHand = np.array([ 859.80614366, 517.28239823, 1051.97278944])\\n expected_Thorax = np.array([256.149810236564, 364.3090603933987, 1459.6553639290375])\\n expected_LKnee = np.array([143.55478579, 279.90370346, 524.78408753])\\n expected_result = [expected_Front_Head, expected_LHip, expected_RHand, expected_Thorax, expected_LKnee]\\n result = [\\n joint_centers[0]['Front_Head'],\\n joint_centers[0]['LHip'],\\n joint_centers[0]['RHand'],\\n joint_centers[0]['Thorax'],\\n joint_centers[0]['LKnee']\\n ]\\n np.testing.assert_almost_equal(result, expected_result, self.rounding_precision)\",\n \"def test_astrounits_validate_list(self):\\n au = inches_to.astronomical_units([1.0, 2.0, 3.0, 4.0])\\n comparison = np.array([1.69789e-13, 2*1.69789e-13, 3*1.69789e-13, 4*1.69789e-13])\\n\\n try:\\n for i in range(len(comparison)):\\n self.assertTrue(math.isclose(au[i], comparison[i], rel_tol=self.accepted_error))\\n print('{:.40s}{}'.format(sys._getframe().f_code.co_name + self.padding, self.passed))\\n except AssertionError:\\n print('{:.40s}{}'.format(sys._getframe().f_code.co_name + self.padding, self.failed))\",\n \"def test_c(self):\\n self.failIf(cgs.speed_of_light/mks.speed_of_light!=100)\",\n \"def test_cross_support_region(self):\\n # Computes cross support for the reference image, with cbca_intensity=5 and cbca_distance=3\\n csr_ = cbca.cross_support(self.ref['im'].data, 3, 5.)\\n\\n # Cross support region top arm ground truth for the reference image self.ref\\n csr_ground_truth_top_arm = np.array([[0, 0, 0, 0, 0],\\n [1, 1, 1, 1, 1],\\n [1, 1, 1, 2, 1]])\\n # Check if the calculated Cross support region top arm is equal to the ground truth\\n # (same shape and all elements equals)\\n\\n np.testing.assert_array_equal(csr_[:, :, 2], csr_ground_truth_top_arm)\\n\\n # Cross support region bottom arm ground truth for the reference image self.ref\\n csr_ground_truth_bottom_arm = np.array([[1, 1, 1, 2, 1],\\n [1, 1, 1, 1, 1],\\n [0, 0, 0, 0, 0]])\\n # Check if the calculated Cross support region bottom arm is equal to the ground truth\\n # (same shape and all elements equals)\\n np.testing.assert_array_equal(csr_[:, :, 3], csr_ground_truth_bottom_arm)\\n\\n # Cross support region left arm ground truth for the reference image self.ref\\n csr_ground_truth_left_arm = np.array([[0, 1, 1, 1, 1],\\n [0, 1, 2, 2, 1],\\n [0, 1, 1, 1, 1]])\\n # Check if the calculated Cross support region left arm is equal to the ground truth\\n # (same shape and all elements equals)\\n np.testing.assert_array_equal(csr_[:, :, 0], csr_ground_truth_left_arm)\\n\\n # Cross support region right arm ground truth for the reference image self.ref\\n csr_ground_truth_right_arm = np.array([[1, 1, 1, 1, 0],\\n [2, 2, 1, 1, 0],\\n [1, 1, 1, 1, 0]])\\n # Check if the calculated Cross support region right arm is equal to the ground truth\\n # (same shape and all elements equals)\\n np.testing.assert_array_equal(csr_[:, :, 1], csr_ground_truth_right_arm)\",\n \"def areColinear(self, other):\\n perpVect = np.array([-self.vector[c.Y], self.vector[c.X]])\\n vect1 = other.end[:2]-self.start[:2]\\n vect2 = other.start[:2]-self.start[:2]\\n cosTheda1 = (np.dot(perpVect, vect1)/\\n (np.linalg.norm(perpVect)*np.linalg.norm(vect1)))\\n if abs(cosTheda1) > 0.0001:\\n return False\\n cosTheda2 = (np.dot(perpVect, vect2)/\\n (np.linalg.norm(perpVect)*np.linalg.norm(vect2)))\\n return not(abs(cosTheda2) > 0.0001)\",\n \"def test01(self):\\n a = np.arange(3, self.N)\\n ac = bcolz.arange(3, self.N, rootdir=self.rootdir)\\n self.assertTrue(np.all(a == ac))\",\n \"def goodPlace(contour):\\n perimeter = cv2.arcLength(contour, True)\\n x, y, w, h = cv2.boundingRect(contour)\\n if y<=0 or x<=0:\\n return False\\n elif y+h >=2016 or x+w>=3840:\\n return False\\n return True\",\n \"def test_concentration_profile(self):\\n\\n # TODO: uncomment when have average concentrations\\n # small number so that can use array less\\n # epsilon = 0.001\\n\\n # if self.operating_condition == \\\"discharge\\\":\\n # np.testing.assert_array_less(\\n # -self.c_e_n_av.entries, self.c_e_av.entries + epsilon\\n # )\\n # np.testing.assert_array_less(\\n # self.c_e_p_av.entries, self.c_e_av.entries + epsilon\\n # )\\n # elif self.operating_condition == \\\"charge\\\":\\n # np.testing.assert_array_less(\\n # -self.c_e_n_av.entries, self.c_e_av.entries + epsilon\\n # )\\n # np.testing.assert_array_less(\\n # self.c_e_p_av.entries, self.c_e_av.entries + epsilon\\n # )\\n # elif self.operating_condition == \\\"off\\\":\\n # np.testing.assert_array_equal(self.c_e_n_av.entries, self.c_e_av.entries)\\n # np.testing.assert_array_equal(self.c_e_s_av.entries, self.c_e_av.entries)\\n # np.testing.assert_array_equal(self.c_e_p_av.entries, self.c_e_av.entries)\",\n \"def test_polar_angle_normal_case(self):\\n point1 = np.array([1, 1])\\n point2 = np.array([2, 2])\\n pol_angle = convex_hull.polar_angle(point2, point1)\\n\\n self.assertEqual(round(math.tan(pol_angle)), 1)\",\n \"def is_codon_correct(input_codon):\\n if type(input_codon) == float:\\n return False\\n\\t\\t\\n allowed_bases = ['A', 'T', 'C', 'G', 'N', '?', '-']\\n\\n for base in input_codon:\\n if base in allowed_bases:\\n continue\\n else:\\n print(\\\"Your codon is incorrect\\\")\\n return False\\n\\n return True\",\n \"def inrange(cc, point):\\n return point.row in range(cc.top, cc.bottom+1) and point.col in range(cc.left, cc.right+1)\",\n \"def _isArcTangentToArc(self, px, py, cx1, cy1, cx2, cy2):\\n p = QPointF(px, py)\\n v1 = QVector2D(p - QPointF(cx1, cy1)).normalized()\\n v2 = QVector2D(p - QPointF(cx1, cy1)).normalized()\\n if abs(v1.dotProduct(v1, v2)) - 1.0 <= 1e-6:\\n # TODO: handle case where arc turns back into the other arc\\n return True\\n else:\\n return False\",\n \"def check_correctness(S, bc_start='not-a-knot', bc_end='not-a-knot',\\n tol=1e-14):\\n x = S.x\\n c = S.c\\n dx = np.diff(x)\\n dx = dx.reshape([dx.shape[0]] + [1] * (c.ndim - 2))\\n dxi = dx[:-1]\\n\\n # Check C2 continuity.\\n assert_allclose(c[3, 1:], c[0, :-1] * dxi**3 + c[1, :-1] * dxi**2 +\\n c[2, :-1] * dxi + c[3, :-1], rtol=tol, atol=tol)\\n assert_allclose(c[2, 1:], 3 * c[0, :-1] * dxi**2 +\\n 2 * c[1, :-1] * dxi + c[2, :-1], rtol=tol, atol=tol)\\n assert_allclose(c[1, 1:], 3 * c[0, :-1] * dxi + c[1, :-1],\\n rtol=tol, atol=tol)\\n\\n # Check that we found a parabola, the third derivative is 0.\\n if x.size == 3 and bc_start == 'not-a-knot' and bc_end == 'not-a-knot':\\n assert_allclose(c[0], 0, rtol=tol, atol=tol)\\n return\\n\\n # Check periodic boundary conditions.\\n if bc_start == 'periodic':\\n assert_allclose(S(x[0], 0), S(x[-1], 0), rtol=tol, atol=tol)\\n assert_allclose(S(x[0], 1), S(x[-1], 1), rtol=tol, atol=tol)\\n assert_allclose(S(x[0], 2), S(x[-1], 2), rtol=tol, atol=tol)\\n return\\n\\n # Check other boundary conditions.\\n if bc_start == 'not-a-knot':\\n if x.size == 2:\\n slope = (S(x[1]) - S(x[0])) / dx[0]\\n assert_allclose(S(x[0], 1), slope, rtol=tol, atol=tol)\\n else:\\n assert_allclose(c[0, 0], c[0, 1], rtol=tol, atol=tol)\\n elif bc_start == 'clamped':\\n assert_allclose(S(x[0], 1), 0, rtol=tol, atol=tol)\\n elif bc_start == 'natural':\\n assert_allclose(S(x[0], 2), 0, rtol=tol, atol=tol)\\n else:\\n order, value = bc_start\\n assert_allclose(S(x[0], order), value, rtol=tol, atol=tol)\\n\\n if bc_end == 'not-a-knot':\\n if x.size == 2:\\n slope = (S(x[1]) - S(x[0])) / dx[0]\\n assert_allclose(S(x[1], 1), slope, rtol=tol, atol=tol)\\n else:\\n assert_allclose(c[0, -1], c[0, -2], rtol=tol, atol=tol)\\n elif bc_end == 'clamped':\\n assert_allclose(S(x[-1], 1), 0, rtol=tol, atol=tol)\\n elif bc_end == 'natural':\\n assert_allclose(S(x[-1], 2), 0, rtol=2*tol, atol=2*tol)\\n else:\\n order, value = bc_end\\n assert_allclose(S(x[-1], order), value, rtol=tol, atol=tol)\",\n \"def are_angles_allowed(self, angles, return_reason=False):\\n #The base goniometer can reach all angles.\\n if return_reason:\\n return (True, \\\"\\\")\\n else:\\n return True\",\n \"def all_covered(matches, molecule) -> bool:\\n # check atoms\\n for i in range(molecule.n_atoms):\\n assert (i, ) in matches\\n # check bonds\\n for bond in molecule.bonds:\\n bond = (bond.atom1_index, bond.atom2_index)\\n assert bond in matches or tuple(reversed(bond)) in matches\\n # check angles\\n for angle in molecule.angles:\\n angle = tuple([atom.molecule_atom_index for atom in angle])\\n assert angle in matches or tuple(reversed(angle)) in matches\\n # check torsions\\n for torsion in molecule.propers:\\n dihedral = tuple([atom.molecule_atom_index for atom in torsion])\\n assert dihedral in matches or tuple(reversed(dihedral)) in matches\\n\\n return True\",\n \"def azimuth(vv, v0, v1):\\n with np.errstate(divide='ignore', invalid='ignore'):\\n n0 = np.cross(v0, v1)\\n n0 /= np.dual.norm(n0, axis=-1)[..., np.newaxis]\\n nn = np.cross(v0, vv)\\n nn /= np.dual.norm(nn, axis=-1)[..., np.newaxis]\\n\\n azi = np.arccos(np.sum(nn * n0, -1))\\n if len(np.shape(azi)) > 0:\\n azi[np.dot(vv, n0) < 0] *= -1\\n # arbitrary angle where vv is (anti)parallel to v0\\n azi[np.isnan(azi)] = 0\\n elif np.isnan(azi):\\n return 0\\n elif np.dot(vv, v0) < 1 and azi > 0:\\n azi *= -1\\n\\n return azi\",\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 check_tele_coords(coords, is_alt_az):\\n\\t\\n\\t#Stuff check coords are OK values?\\n\\tif len(coords)!= 2:\\n\\t\\tlogger.error('Incorrect length for coords parameter, should be 2')\\n\\telse:\\n\\t\\tfor i in range(len(coords)):\\n\\t\\t\\n\\t\\t\\t#print('Checking', coords[i], 'index:',i)\\n\\t\\t\\tvalid_Coords = True\\n\\t\\t\\ttry:\\n\\t\\t\\t\\tj = str(coords[i])\\n\\t\\t\\t\\t\\n\\t\\t\\texcept:\\n\\t\\t\\t\\tvalid_Coords = False\\n\\t\\t\\telse:\\n\\t\\t\\t\\tspace_split = j.split(' ')\\n\\t\\t\\t\\tcolon_split = j.split(':')\\n\\t\\t\\t\\tif len(space_split) == 3 or len(colon_split) == 3: \\n\\t\\t\\t\\t\\tif len(space_split) == 3:\\n\\t\\t\\t\\t\\t\\tvalid_one = space_split\\n\\t\\t\\t\\t\\tif len(colon_split)==3:\\n\\t\\t\\t\\t\\t\\tvalid_one = colon_split\\n\\t\\t\\t\\telse:\\n\\t\\t\\t\\t\\tvalid_Coords = False\\n\\t\\t\\t\\n\\t\\t\\ttry:\\n\\t\\t\\t\\tvalid_one = [float(valid_one[k]) for k in range(len(valid_one))]\\n\\t\\t\\texcept:\\n\\t\\t\\t\\tvalid_Coords = False\\n\\t\\t\\t#Check the values entered are in valid ranges\\n\\t\\t\\tif valid_Coords == True:\\n\\t\\t\\t\\t#Check mintues for all RA, DEC, Alt, Az,\\n\\t\\t\\t\\tif valid_one[1] < 0 or valid_one[1] >= 60:\\n\\t\\t\\t\\t\\tvalid_Coords =False\\n\\t\\t\\t\\t# Check seconds for all RA, DEC, ALt, Az\\n\\t\\t\\t\\tif valid_one[2] < 0 or valid_one[2]>= 60:\\n\\t\\t\\t\\t\\tvalid_Coords =False\\n\\t\\t\\t\\t\\n\\t\\t\\t\\t# First value will have different ranges for RA, DEC, Alt, Az\\n\\t\\t\\t\\t# i == 0 will be either RA or Alt..\\n\\t\\t\\t\\t# is_alt_az==False for RA\\n\\t\\t\\t\\tif i == 0 and is_alt_az == False:\\n\\t\\t\\t\\t\\tif valid_one[0] < 0 or valid_one[0] >=24:\\n\\t\\t\\t\\t\\t\\tvalid_Coords = False\\n\\t\\t\\t\\telif i == 0 and is_alt_az == True:\\n\\t\\t\\t\\t\\tif valid_one[0] <0 or valid_one[0] >90:\\n\\t\\t\\t\\t\\t\\tvalid_Coords =False\\n\\t\\t\\t\\t# i == 1 will be DEC or Az\\n\\t\\t\\t\\t# is_alt_az==False for DEC\\n\\t\\t\\t\\telif i== 1 and is_alt_az ==False:\\n\\t\\t\\t\\t\\tif valid_one[0] <-90 or valid_one[0] > 90:\\n\\t\\t\\t\\t\\t\\tvalid_Coords = False\\n\\t\\t\\t\\telif i == 1 and is_alt_az == True:\\n\\t\\t\\t\\t\\tif valid_one[0] <0 or valid_one[0] >=360:\\n\\t\\t\\t\\t\\t\\tvalid_Coords =False\\n\\t\\t\\t\\telse:\\n\\t\\t\\t\\t\\tprint(\\\"Issue with 'i' or 'is_alt_az'\\\")\\n\\t\\t\\t\\t\\t\\n\\t\\t\\tif valid_Coords ==False:\\n\\t\\t\\t\\traise ValueError('Invalid Coordinates provided')\",\n \"def test02(self):\\n a = np.arange(3, self.N, 4)\\n ac = bcolz.arange(3, self.N, 4, rootdir=self.rootdir)\\n self.assertTrue(np.all(a == ac))\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.64040065","0.55662644","0.5453842","0.54343426","0.542246","0.5321511","0.52047867","0.5199475","0.51695144","0.5155091","0.5144264","0.5114534","0.50843585","0.505066","0.50357336","0.50191617","0.5004695","0.49946713","0.4977154","0.49758136","0.49680394","0.49456647","0.4924928","0.4903312","0.48812243","0.48757187","0.48713356","0.48579684","0.48265517","0.48262703","0.482465","0.48217255","0.48123446","0.48089316","0.47909713","0.47768775","0.47709695","0.4756315","0.4752136","0.4747356","0.47426108","0.47183257","0.47100863","0.47094968","0.47091353","0.4698383","0.46885097","0.46873105","0.46830145","0.46790558","0.46703777","0.46670538","0.46620455","0.46587583","0.46507174","0.4648622","0.4637031","0.46360236","0.46214148","0.46185172","0.4615474","0.46138075","0.46088144","0.45930538","0.4592662","0.45926017","0.45909655","0.45880732","0.45877197","0.45831722","0.45831198","0.45792764","0.45726815","0.4563291","0.45497492","0.4547484","0.4546647","0.45424968","0.45413318","0.45410627","0.4541011","0.4537911","0.45375362","0.45362064","0.45345438","0.45338723","0.45327228","0.45288816","0.45253903","0.45245394","0.4523789","0.45218742","0.45170298","0.4516377","0.45150724","0.45115942","0.45100653","0.45095664","0.45063877","0.45058703"],"string":"[\n \"0.64040065\",\n \"0.55662644\",\n \"0.5453842\",\n \"0.54343426\",\n \"0.542246\",\n \"0.5321511\",\n \"0.52047867\",\n \"0.5199475\",\n \"0.51695144\",\n \"0.5155091\",\n \"0.5144264\",\n \"0.5114534\",\n \"0.50843585\",\n \"0.505066\",\n \"0.50357336\",\n \"0.50191617\",\n \"0.5004695\",\n \"0.49946713\",\n \"0.4977154\",\n \"0.49758136\",\n \"0.49680394\",\n \"0.49456647\",\n \"0.4924928\",\n \"0.4903312\",\n \"0.48812243\",\n \"0.48757187\",\n \"0.48713356\",\n \"0.48579684\",\n \"0.48265517\",\n \"0.48262703\",\n \"0.482465\",\n \"0.48217255\",\n \"0.48123446\",\n \"0.48089316\",\n \"0.47909713\",\n \"0.47768775\",\n \"0.47709695\",\n \"0.4756315\",\n \"0.4752136\",\n \"0.4747356\",\n \"0.47426108\",\n \"0.47183257\",\n \"0.47100863\",\n \"0.47094968\",\n \"0.47091353\",\n \"0.4698383\",\n \"0.46885097\",\n \"0.46873105\",\n \"0.46830145\",\n \"0.46790558\",\n \"0.46703777\",\n \"0.46670538\",\n \"0.46620455\",\n \"0.46587583\",\n \"0.46507174\",\n \"0.4648622\",\n \"0.4637031\",\n \"0.46360236\",\n \"0.46214148\",\n \"0.46185172\",\n \"0.4615474\",\n \"0.46138075\",\n \"0.46088144\",\n \"0.45930538\",\n \"0.4592662\",\n \"0.45926017\",\n \"0.45909655\",\n \"0.45880732\",\n \"0.45877197\",\n \"0.45831722\",\n \"0.45831198\",\n \"0.45792764\",\n \"0.45726815\",\n \"0.4563291\",\n \"0.45497492\",\n \"0.4547484\",\n \"0.4546647\",\n \"0.45424968\",\n \"0.45413318\",\n \"0.45410627\",\n \"0.4541011\",\n \"0.4537911\",\n \"0.45375362\",\n \"0.45362064\",\n \"0.45345438\",\n \"0.45338723\",\n \"0.45327228\",\n \"0.45288816\",\n \"0.45253903\",\n \"0.45245394\",\n \"0.4523789\",\n \"0.45218742\",\n \"0.45170298\",\n \"0.4516377\",\n \"0.45150724\",\n \"0.45115942\",\n \"0.45100653\",\n \"0.45095664\",\n \"0.45063877\",\n \"0.45058703\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.610046"},"document_rank":{"kind":"string","value":"1"}}},{"rowIdx":89888,"cells":{"query":{"kind":"string","value":"Test import dataset wine."},"document":{"kind":"string","value":"def test_import_wine():\n X, y = wine_data()\n\n assert(X.shape[1] == 12)\n assert(len(y.unique().tolist()) == 3)\n assert(X.shape[0] == y.shape[0])"},"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_import_data():\n\n file_path = os.path.join(CONST_ADVANTICSYS_DIR, CONST_ADVANTICSYS_TEST_1)\n\n # Bring df\n success, log, test_ingress_df = advanticsys_import(file_path)\n assert success, log\n assert isinstance(test_ingress_df, pd.DataFrame)\n\n # Test import function\n success, log = import_data(\n test_ingress_df,\n CONST_ADVANTICSYS,\n SQL_USER,\n SQL_PASSWORD,\n SQL_HOST,\n SQL_PORT,\n SQL_TEST_DBNAME\n )\n\n assert success is True, log \n assert log == \"New: 0 (uploaded); Duplicates: 75 (ignored)\"","def fixture_example_data():\n import_example_data()","def test_dataset_from_file(train_dataset):\n dummy = \"justo. Praesent luctus. Curabitur egestas nunc sed libero. Proin sed\"\n assert train_dataset[0][0] == dummy\n assert train_dataset[0][1] == '6'","def test_load_dataset():\n\n # Given\n dataset_file_name = core.config.app_config.TESTING_DATA_FILE\n\n # When\n subject = utils.load_dataset(filename=dataset_file_name)\n\n # Then\n assert isinstance(subject, pd.DataFrame)\n assert subject.shape == (5940, 41)","def test_loadData():\n \n sys = LVsystem.Ecosystem()\n \n sys.loadSetup('2Prey1Predator')\n \n \n data = sys.create_data()\n \n assert data[0] == 3\n assert data[1] == ['rabbit', 'hen', 'fox']\n assert data[2] == [30,10,20]\n assert data[3] == [0.09,0.07,-0.06] \n assert data[4] == [10000,10000,1]\n assert data[5] == [400,500,250]\n assert data[6][1][2] == -data[6][2][1]\n assert data[6][2][2] == 0\n\n sys.removeSpecies('rabbit')\n sys.removeSpecies('fox')\n sys.removeSpecies('hen')","def test_import(self):\n\n database.delete_database()\n\n #Fully successful import\n actual_tuples1 = database.import_data('csvs', 'product_data.csv', 'customer_data.csv',\n 'rentals_data.csv')\n expected_tuples1 = ((1, 1, 1), (0, 0, 0))\n self.assertEqual(actual_tuples1, expected_tuples1)\n database.delete_database()\n\n #Partially successful import with failed product_data\n actual_tuples2 = database.import_data('csvs', 'produc_data.csv', 'customer_data.csv',\n 'rentals_data.csv')\n expected_tuples2 = ((0, 1, 1), (1, 0, 0))\n self.assertEqual(actual_tuples2, expected_tuples2)\n database.delete_database()\n\n #Partially successful import with failed customer_data\n actual_tuples3 = database.import_data('csvs', 'product_data.csv', 'custome_data.csv',\n 'rentals_data.csv')\n expected_tuples3 = ((1, 0, 1), (0, 1, 0))\n self.assertEqual(actual_tuples3, expected_tuples3)\n database.delete_database()\n\n #Partially successful import with failed rentals_data\n actual_tuples4 = database.import_data('csvs', 'product_data.csv', 'customer_data.csv',\n 'rental_data.csv')\n expected_tuples4 = ((1, 1, 0), (0, 0, 1))\n self.assertEqual(actual_tuples4, expected_tuples4)\n database.delete_database()","def importData():\n #importChallengeDataToDB()\n importTrendingDataToDB()","def test_import(self):\n\n DropDataUnitTesting.drop_data()\n tup1 = ()\n tup2 = ()\n results = []\n try:\n current_dir = os.getcwd()\n directory_name = current_dir + '\\\\lesson5\\\\data\\\\'\n file_name_dict = {'products': 'products.csv', 'customers': 'customers.csv',\n 'rentals': 'rentals.csv'}\n for key, value in file_name_dict.items():\n tmp_file = directory_name + value\n mongo_insert = mdb.ImportData(key, tmp_file)\n results = mongo_insert.import_data()\n tup1 = results[0]\n tup2 = results[1]\n except FileNotFoundError as e:\n logger.error('exception %s', e, exc_info=True)\n result = 'exception {}'.format(e)\n print(result)\n print(results)\n print(tup1, tup2)\n # assert the correct number of items were added\n self.assertEqual(tup1[0], 'customers: 10, ')\n self.assertEqual(tup1[1], 'products: 10, ')\n self.assertEqual(tup1[2], 'rentals: 10, ')\n # check no errors occurred during addition\n self.assertEqual(tup2[0], 0)\n DropDataUnitTesting.drop_data()","def test_import(import_data):\n try:\n df_tab = import_data()\n logging.info(\"Testing import_data: Successfully Found File\")\n except FileNotFoundError as err:\n logging.error(\"Testing import_data: The file wasn't found\")\n raise err\n\n try:\n assert df_tab.shape[0] > 0\n assert df_tab.shape[1] > 0\n logging.info(\"Testing import_data: Successfully Available Data\")\n except AssertionError as err:\n logging.error(\n \"Testing import_data: The file doesn't appear to have rows and columns\"\n )\n raise err\n\n return df_tab","def test_full_dataset_from_file(full_dataset):\n train_dummy = \"justo. Praesent luctus. Curabitur egestas nunc sed libero. Proin sed\"\n val_dummy = \"malesuada. Integer id magna et ipsum cursus vestibulum. Mauris magna.\"\n\n assert full_dataset.train[0][0] == train_dummy\n assert full_dataset.train[0][1] == '6'\n\n assert full_dataset.val[0][0] == val_dummy\n assert full_dataset.val[0][1] == '8'\n\n assert full_dataset[0][0] == train_dummy\n assert full_dataset[100][0] == val_dummy","def test_data_set_load(data_set):\n data = data_set()\n train_data, train_labels, test_data, test_labels = data.load_data()\n\n assert len(train_data) > 0\n assert len(test_data) > 0\n assert len(train_data) == len(train_labels)\n assert len(test_data) == len(test_labels)","def test_make_dataset_happy_path(self):\n # User story: user runs src.make_dataset() on the current directory\n # and gets a fully functional dataset\n pass","def test_load_data(self):\n assert len(self._mnist.get()) == 10\n assert self._mnist.get()[0].label == 7\n pass","def test_multiple_import(self):\n # Currently, there are no PowerPlant or Project objects in the database\n self.assertEqual(PowerPlant.objects.count(), 0)\n self.assertEqual(Project.objects.count(), 0)\n # There are no InfrastructureType objects in the database\n self.assertEqual(InfrastructureType.objects.count(), 0)\n # There are no Fuel or FuelCategory objects in the database\n self.assertEqual(Fuel.objects.count(), 0)\n self.assertEqual(FuelCategory.objects.count(), 0)\n # There are no Countries or Regions in the database\n self.assertEqual(Country.objects.count(), 0)\n self.assertEqual(Region.objects.count(), 0)\n # There are no OwnerStakes in the database\n self.assertEqual(PlantOwnerStake.objects.count(), 0)\n # There are no Initiatives in the database\n self.assertEqual(Initiative.objects.count(), 0)\n # There are no ProjectFunding objects in the database\n self.assertEqual(ProjectFunding.objects.count(), 0)\n\n # Run the import\n self.call_command(filename='power_plant_import/tests/data/six_rows.csv')\n\n # The file has 3 'Plant' rows and 3 'Project' rows, but the project_liaoning\n # also gets a parent PowerPlant created for it\n self.assertEqual(PowerPlant.objects.count(), 4)\n self.assertEqual(Project.objects.count(), 3)\n # There is now 1 InfrastructureType object in the database\n self.assertEqual(InfrastructureType.objects.count(), 1)\n # There are now 4 Fuel and 3 FuelCategory objects in the database\n self.assertEqual(Fuel.objects.count(), 4)\n self.assertEqual(FuelCategory.objects.count(), 3)\n # There are now 4 Countries and 3 Regions in the database\n self.assertEqual(Country.objects.count(), 4)\n self.assertEqual(Region.objects.count(), 3)\n # There are now 4 OwnerStakes in the database\n self.assertEqual(PlantOwnerStake.objects.count(), 4)\n # There is now Initiative in the database\n self.assertEqual(Initiative.objects.count(), 1)\n # There are now 3 ProjectFunding objects in the database\n self.assertEqual(ProjectFunding.objects.count(), 3)\n\n # Run the import again\n self.call_command(filename='power_plant_import/tests/data/six_rows.csv')\n\n # There are still 4 PowerPlant and 3 Project objects in the database\n self.assertEqual(PowerPlant.objects.count(), 4)\n self.assertEqual(Project.objects.count(), 3)\n # There is still 1 InfrastructureType object in the database\n self.assertEqual(InfrastructureType.objects.count(), 1)\n # There are still 4 Fuel and 3 FuelCategory objects in the database\n self.assertEqual(Fuel.objects.count(), 4)\n self.assertEqual(FuelCategory.objects.count(), 3)\n # There are still 4 Countries and 3 Regions in the database\n self.assertEqual(Country.objects.count(), 4)\n self.assertEqual(Region.objects.count(), 3)\n # There are still 4 OwnerStakes in the database\n self.assertEqual(PlantOwnerStake.objects.count(), 4)\n # There is still Initiative in the database\n self.assertEqual(Initiative.objects.count(), 1)\n # There are still 3 ProjectFunding objects in the database\n self.assertEqual(ProjectFunding.objects.count(), 3)","def _load_test_data(self):\n self._save_test_data()","def setUp(self):\n self.dataset = get_test_dataset()","def test_large_import(self):\n self.create_sample_data_set_dir(\"node59p1.dat\", TELEM_DIR)\n self.assert_initialize()\n result = self.data_subscribers.get_samples(DataParticleType.METADATA_TELEMETERED,1,60)\n result = self.data_subscribers.get_samples(DataParticleType.SAMPLE_TELEMETERED,750,400)","def test_load_UCR_UEA_dataset():\n X, y = load_UCR_UEA_dataset(name=\"UnitTest\")\n assert isinstance(X, pd.DataFrame) and isinstance(y, np.ndarray)\n assert X.shape == (42, 1) and y.shape == (42,)","def test_import(self):\n self.assertTrue(NagiosPerfdataCollector)","def import_test():\n if os.path.exists(\"test.csv\"):\n #print (\"--testing data imported to data frame\\n\")\n test_df = pd.read_csv(\"test.csv\", index_col=0)\n else:\n print(\"training CSV not found\")\n exit()\n \n return test_df","def test_002_load_data(self):\n __test = chess_storage.ChessStorage()\n __test_filename = consts.TEST_FILENAME\n __test_data = list(range(consts.TEST_LIST_LENGHT))\n __load_test = __test.load_data(consts.TEST_NOTEXISTFILE)\n self.assertEqual(__load_test, consts.ERROR_CODES[\"NO_FILE_EXIST\"])\n __load_test = __test.load_data(__test_filename)\n self.assertEqual(__load_test, __test_data)","def load_data(self):\n with open('data/fordTrain.csv') as f:\n data = csv.reader(f, delimiter=',')\n train = [x for i, x in enumerate(data) if i > 0] \n # Extract features and target variable separately\n trainx = [x[3:] for x in train]\n trainy = [x[2] for x in train]\n\n with open('data/fordTest.csv') as f:\n data = csv.reader(f, delimiter=',')\n testx = [x[3:] for i, x in enumerate(data) if i > 0] \n\n with open('data/Solution.csv') as f:\n data = csv.reader(f, delimiter=',')\n testy = [x[2] for i, x in enumerate(data) if i > 0] \n\n # Extract features and target variable, convert to numpy array\n trainx = np.asarray(trainx, dtype=np.float32)\n trainy = np.asarray(trainy, dtype=np.int8)\n testx = np.asarray(testx, dtype=np.float32)\n testy = np.asarray(testy, dtype=np.int8)\n\n # Return training and test sets\n trainSet = Dataset(trainx, trainy)\n testSet = Dataset(testx, testy)\n return trainSet, testSet","def test_import_data_handler(self):\n\n # create new unittest data\n # unittest_result = ImportUnitTestData.import_data_handler()\n # test_result = main.import_data_handler()\n # print(test_result)\n # print(unittest_result)\n # self.assertEqual(test_result, unittest_result )","def test_missing_data_sources(self):","def load_examples_data(dataset_name):\n dataset_name = dataset_name.strip().lower()\n if dataset_name.lower() not in ['pokemon', 'hanzi', 'animals', 'nsfw', 'simpsons', 'horse2zebra', 'people',\n 'autodrive', 'superresolution', 'anpr', 'beauty','antisproofing','facelandmarks','dogs-vs-cats','chinese']:\n raise ValueError('Not a valid dataset_name.')\n dataset_name = 'examples_' + dataset_name\n dirname = os.path.join(_trident_dir, dataset_name)\n if not os.path.exists(dirname):\n try:\n os.makedirs(dirname)\n except OSError:\n # Except permission denied and potential race conditions\n # in multi-threaded environments.\n pass\n is_internet_ok = is_connected()\n if dataset_name == 'examples_pokemon':\n is_download=download_file_from_google_drive('1U-xc54fX9j9BcidvRa0ow6qjssMlSF2A', dirname, 'pokemon.tar')\n tar_file_path = os.path.join(dirname, 'pokemon.tar')\n extract_archive(tar_file_path, dirname, archive_format='tar')\n extract_path = os.path.join(dirname, 'pokemon')\n dataset = load_folder_images(dataset_name, extract_path, folder_as_label=False)\n print('get pokemon images :{0}'.format(len(dataset)))\n return dataset\n\n\n elif dataset_name == 'examples_hanzi':\n download_file_from_google_drive('13UEzSG0az113gpRPKPyKrIE2HDaA2P4H', dirname, 'hanzi.tar')\n tar_file_path = os.path.join(dirname, 'hanzi.tar')\n extract_path = os.path.join(dirname, 'hanzi')\n extract_archive(tar_file_path, dirname, archive_format='tar')\n dataset = load_folder_images(dataset_name, os.path.join(dirname, 'train'), folder_as_label=True,\n object_type=ObjectType.gray)\n\n dataset_test = load_folder_images(dataset_name, os.path.join(dirname, 'test'), folder_as_label=True,\n object_type=ObjectType.gray)\n\n dataset.testdata = dataset_test.traindata\n dataset.class_names['zh-cn'] = dataset.class_names['en-us']\n return dataset\n\n elif dataset_name == 'examples_animals':\n download_file_from_google_drive('19Cjq8OO6qd9k9TMZxlPjDpejDOdiHJoW', dirname, 'animals.tar')\n tar_file_path = os.path.join(dirname, 'animals.tar')\n extract_archive(tar_file_path, dirname, archive_format='tar')\n dataset = load_folder_images(dataset_name, dirname, folder_as_label=True)\n return dataset\n elif dataset_name == 'examples_nsfw':\n tar_file_path = os.path.join(dirname, 'nsfw.tar')\n if os.path.exists(tar_file_path) and get_file_create_time(tar_file_path)<datetime.datetime(2021, 2, 20, 0, 0, 0).timestamp():\n os.remove(tar_file_path)\n if os.path.exists(os.path.join(dirname,'porn_detection_data.pkl')):\n os.remove(os.path.join(dirname,'porn_detection_data.pkl'))\n _delete_h(dirname)\n download_file_from_google_drive('1EXpV2QUrSFJ7zJn8NqtqFl1k6HvXsUzp', dirname, 'nsfw.tar')\n\n extract_path = os.path.join(dirname, 'nsfw')\n extract_archive(tar_file_path, dirname, archive_format='tar')\n folders = ['drawings', 'hentai', 'neutral', 'porn', 'sexy']\n data=unpickle(os.path.join(dirname,'porn_detection_data.pkl'))\n\n trainData = []\n testData = []\n trainLabel = []\n testLabel = []\n for n in range(5):\n folder=folders[n]\n trainData.extend(data[folder]['train'])\n trainLabel.extend([n]*len(data[folder]['train']))\n testData.extend(data[folder]['test'])\n testLabel.extend([n] * len(data[folder]['test']))\n\n trainarray = ImageDataset(trainData,object_type=ObjectType.rgb)\n trainlabel = LabelDataset(trainLabel,object_type=ObjectType.classification_label)\n train_iter = Iterator(data=trainarray, label=trainlabel)\n\n testarray = ImageDataset(testData,object_type=ObjectType.rgb)\n testlabel = LabelDataset(testLabel,object_type=ObjectType.classification_label)\n test_iter = Iterator(data=testarray, label=testlabel)\n print('training images: {0} test images:{1}'.format(len(trainarray), len(testarray)))\n\n dataset = DataProvider(dataset_name, traindata=train_iter, testdata=test_iter)\n dataset.binding_class_names(['drawing', 'hentai', 'neutral', 'porn', 'sexy'], 'en-us')\n dataset.binding_class_names(['绘画', '色情漫画', '中性', '色情', '性感'], 'zh-cn')\n dataset.binding_class_names(['繪畫', '色情漫畫', '中性', '色情', '性感'], 'zh-tw')\n dataset.scenario = 'train'\n return dataset\n elif dataset_name == 'examples_simpsons':\n download_file_from_google_drive('1hGNFbfBv3EZ4nx4Qod6PtSYzO8H4QIxC', dirname, 'simpsons.tar')\n tar_file_path = os.path.join(dirname, 'simpsons.tar')\n extract_path = os.path.join(dirname, 'simpsons')\n extract_archive(tar_file_path, extract_path, archive_format='tar')\n data_provider = load_folder_images(dataset_name, extract_path, folder_as_label=False)\n data_provider.traindata.unpair = RandomNoiseDataset(shape=(100), random_mode='normal')\n print('get simpsons images :{0}'.format(len(data_provider.traindata.data.items)))\n return data_provider\n elif dataset_name == 'examples_horse2zebra':\n download_file_from_google_drive('1pqj-T90Vh4wVNBV09kYZWgVPsZUA2f7U', dirname, 'horse2zebra.tar')\n tar_file_path = os.path.join(dirname, 'horse2zebra.tar')\n extract_path = os.path.join(dirname, 'horse2zebra')\n extract_archive(tar_file_path, dirname, archive_format='tar')\n trainA = ImageDataset(list_images(os.path.join(dirname, 'trainA')), object_type=ObjectType.rgb,\n get_image_mode=GetImageMode.processed)\n trainB = ImageDataset(list_images(os.path.join(dirname, 'trainB')), object_type=ObjectType.rgb,\n get_image_mode=GetImageMode.processed)\n testA = ImageDataset(list_images(os.path.join(dirname, 'testA')), object_type=ObjectType.rgb,\n get_image_mode=GetImageMode.processed)\n testB = ImageDataset(list_images(os.path.join(dirname, 'testB')), object_type=ObjectType.rgb,\n get_image_mode=GetImageMode.processed)\n train_iter = Iterator(data=trainA, unpair=trainB)\n test_iter = Iterator(data=testA, unpair=testB)\n dataset = DataProvider(dataset_name, traindata=train_iter, testdata=test_iter)\n print('get horse2zebra images :{0}'.format(len(dataset)))\n return dataset\n elif dataset_name == 'examples_people':\n download_file_from_google_drive('1H7mJJfWpmXpRxurMZQqY4N_UXWLbQ2pT', dirname, 'people.tar')\n tar_file_path = os.path.join(dirname, 'people.tar')\n extract_archive(tar_file_path, dirname, archive_format='tar')\n imgs = glob.glob(os.path.join(dirname, 'imgs', '*.*g'))\n masks = glob.glob(os.path.join(dirname, 'masks', '*.png'))\n imgs=list(sorted(imgs))\n masks = list(sorted(masks))\n # make_dir_if_need(os.path.join(dirname, 'trimap'))\n # for i in range(len(masks)):\n # mask=mask2array(masks[i])\n # trimap=mask2trimap(mask)\n # save_mask(trimap,masks[i].replace('masks','trimap'))\n # print('trimap',len(masks))\n\n imgdata = ImageDataset(images=imgs, object_type=ObjectType.rgb)\n mskdata = MaskDataset(masks=masks, object_type=ObjectType.binary_mask)\n dataset = DataProvider(dataset_name=dataset_name, traindata=Iterator(data=imgdata, label=mskdata))\n print('get people images :{0}'.format(len(dataset)))\n return dataset\n elif dataset_name == 'examples_autodrive':\n download_file_from_google_drive('1JqPPeHqhWLqnI6bD8nuHcVx-Y56oIZMK', dirname, 'autodrive.tar')\n tar_file_path = os.path.join(dirname, 'autodrive.tar')\n extract_path = os.path.join(dirname, 'autodrive')\n extract_archive(tar_file_path, dirname, archive_format='tar')\n imgs = glob.glob(os.path.join(dirname, 'images', '*.*g'))\n masks = glob.glob(os.path.join(dirname, 'masks', '*.png'))\n imgs = list(sorted(imgs))\n masks = list(sorted(masks))\n imgdata = ImageDataset(images=imgs, object_type=ObjectType.rgb,symbol='image')\n mskdata = MaskDataset(masks=masks, object_type=ObjectType.color_mask,symbol='mask')\n\n def parse_code(l):\n if len(l.strip().split(\"\\t\")) == 2:\n a, b = l.replace('\\t\\t', '\\t').strip().split(\"\\t\")\n return tuple(int(i) for i in b.split(' ')), a\n\n label_codes, label_names = zip(\n *[parse_code(l) for l in open(os.path.join(dirname, \"label_colors.txt\")).readlines()])\n for i in range(len(label_codes)):\n mskdata.palette[label_names[i]] = label_codes[i]\n\n dataset = DataProvider(dataset_name=dataset_name, traindata=Iterator(data=imgdata, label=mskdata))\n print('get autodrive images :{0}'.format(len(dataset)))\n return dataset\n elif dataset_name == 'examples_superresolution':\n download_file_from_google_drive('1v1uoymrWI_MLSiGvSGW7tWJYSnzzXpEQ', dirname, 'superresolution.tar')\n tar_file_path = os.path.join(dirname, 'superresolution.tar')\n extract_archive(tar_file_path, dirname, archive_format='tar')\n imgs = glob.glob(os.path.join(dirname, '*.*g'))\n imgs.extend(glob.glob(os.path.join(dirname, '*.bmp')))\n imgs = list(sorted(imgs))\n\n print('get super resolution images :{0}'.format(len(imgs)))\n\n imgdata = ImageDataset(images=imgs * 2, object_type=ObjectType.rgb, symbol='lr')\n labeldata = ImageDataset(images=imgs * 2, object_type=ObjectType.rgb, symbol='hr')\n dataset = DataProvider(dataset_name=dataset_name, traindata=Iterator(data=imgdata, label=labeldata))\n return dataset\n elif dataset_name == 'examples_beauty':\n download_file_from_google_drive('1aJhxN9IqsxuayhRTm-gmxk6PiLe5wm9X', dirname, 'beauty.tar')\n tar_file_path = os.path.join(dirname, 'beauty.tar')\n\n extract_archive(tar_file_path, dirname, archive_format='tar')\n # 讀取圖片數據\n images_dict = {}\n with open(os.path.join(dirname, 'images_dict.pkl'), 'rb') as fp:\n images_dict = pickle.load(fp)\n\n f = open(os.path.join(dirname, 'All_Ratings.txt'), encoding='utf-8-sig').readlines()\n imgs = []\n landmarks = []\n ratings = []\n for row in f:\n data = row.strip().split('\\t')\n if 'images\\\\' + data[0] in images_dict:\n img = images_dict['images\\\\' + data[0]][0]\n img = img.transpose([2, 0, 1])[::-1].transpose([1, 2, 0])\n imgs.append(img)\n landmark = images_dict['images\\\\' + data[0]][1].astype(np.float32)\n landmarks.append(landmark)\n rating = (float(data[1])) / 5.00\n ratings.append(rating)\n print('{0} faces loaded...'.format(len(imgs)))\n imgdata = ImageDataset(images=imgs, object_type=ObjectType.rgb, symbol='faces')\n landmarkdata = LandmarkDataset(landmarks=landmarks, object_type=ObjectType.landmarks, symbol='target_landmarks')\n labeldata = LabelDataset(data=ratings,object_type=ObjectType.classification_label, symbol='target_beauty')\n data_provider = DataProvider(dataset_name=dataset_name, traindata=Iterator(data=imgdata, label=Dataset.zip(landmarkdata,labeldata)))\n return data_provider\n\n elif dataset_name == 'examples_facelandmarks':\n download_file_from_google_drive('1GtswQBAHPa_bXaB4tW2uOOQ8Lxfz2L5B', dirname, 'ibug_300W.tar')\n tar_file_path = os.path.join(dirname, 'ibug_300W.tar')\n extract_archive(tar_file_path, dirname, archive_format='tar')\n root_dir=os.path.join(dirname, 'ibug_300W_large_face_landmark_dataset')\n image_paths = {}\n landmarks = {}\n crops = {}\n\n for mode in ['train','test']:\n make_dir_if_need(os.path.join(dirname, 'crops',mode))\n tree = ElementTree.parse(os.path.join(root_dir, 'labels_ibug_300W_{0}.xml'.format(mode)))\n root = tree.getroot()\n image_paths[mode]=[]\n landmarks[mode] = []\n crops[mode] = []\n\n offset=5\n for j in tqdm(range(len(root[2]))):\n try:\n filename=root[2][j]\n landmark = []\n for num in range(68):\n x_coordinate = int(filename[0][num].attrib['x'])\n y_coordinate = int(filename[0][num].attrib['y'])\n landmark.append([x_coordinate, y_coordinate])\n landmark=np.asarray(landmark)\n\n crop = filename[0].attrib\n for k in crop.keys():\n crop[k] = int(crop[k]) if isinstance(crop[k], str) else crop[k]\n for k in crop.keys():\n if k=='top' and int(landmark[:,1].min())<int(crop[k]):\n crop[k] = int( landmark[:,1].min())\n crop[ 'height']+=crop[k]-int(landmark[:,1].min())\n elif k=='left' and int(landmark[:,0].min())<int(crop[k]):\n crop[k] = int( landmark[:,0].min())\n crop['width']+= crop[k] - int(landmark[:, 0].min())\n elif k == 'width' and int(landmark[:, 0].max()-landmark[:, 0].min()) > int(crop[k]):\n crop[k] = int(landmark[:, 0].max()-landmark[:, 0].min())\n elif k == 'height' and int(landmark[:, 1].max()-landmark[:, 1].min()) > int(crop[k]):\n crop[k] = int(landmark[:, 1].max()-landmark[:, 1].min())\n\n crop['left']-=offset\n crop['top'] -= offset\n crop['width'] += 2*offset\n crop['height'] += 2*offset\n\n\n landmark[:,0]-=crop['left']\n landmark[:, 1] -= crop['top']\n\n\n if not os.path.exists(os.path.join(dirname, 'crops', mode, '{0}.png'.format(j))):\n im=image2array(os.path.join(root_dir, filename.attrib['file']))\n if im.ndim==2:\n im=cv2.cvtColor(im,cv2.COLOR_GRAY2RGB)\n im=im[crop['top']:min(crop['top']+crop['height'],im.shape[0]),crop['left']:min(crop['left']+crop['width'],im.shape[1]),:]\n\n if max(im.shape[:2])/max(min(im.shape[:2]),0)<=5:\n\n array2image(im).save(os.path.join(dirname, 'crops',mode,'{0}.png'.format(j)))\n image_paths[mode].append(os.path.join(dirname, 'crops', mode, '{0}.png'.format(j)))\n crops[mode].append(crop)\n landmarks[mode].append(landmark)\n del im\n else:\n #im = image2array(os.path.join(dirname, 'crops',mode,'{0}.png'.format(j)))\n image_paths[mode].append(os.path.join(dirname, 'crops',mode,'{0}.png'.format(j)))\n crops[mode].append(crop)\n landmarks[mode].append(landmark)\n\n if j%100==0:\n gc.collect()\n except Exception as e:\n pass\n\n print('ibug 300w train dataset: images: {0} landmarks:{1} \\n'.format(len(image_paths['train']),len(landmarks['train'])))\n print('ibug 300w test dataset: images: {0} landmarks:{1} \\n'.format(len(image_paths['test']), len(landmarks['test'])))\n imdata=ImageDataset(images=image_paths['train'],symbol='faces',object_type=ObjectType.rgb)\n landmarkdata = LandmarkDataset(landmarks=landmarks['train'], symbol='landmarks',object_type=ObjectType.landmarks)\n imtestdata = ImageDataset(images=image_paths['test'], symbol='faces',object_type=ObjectType.rgb)\n landmarktestdata = LandmarkDataset(landmarks=landmarks['test'], symbol='landmarks',object_type=ObjectType.landmarks)\n data_provider=DataProvider(traindata=Iterator(data=imdata,label=landmarkdata),testdata=Iterator(data=imtestdata,label=landmarktestdata))\n return data_provider\n\n elif dataset_name == 'examples_antisproofing':\n download_file_from_google_drive('1e7Zjn2MHNCvA5gXdJUECzY8NjK4KVpa7', dirname, 'antisproofing.tar')\n tar_file_path = os.path.join(dirname, 'antisproofing.tar')\n make_dir_if_need(os.path.join(dirname, 'antisproofing'))\n extract_archive(tar_file_path, dirname, archive_format='tar')\n data_provider = load_folder_images(dataset_name,os.path.join(dirname, 'antisproofing'))\n return data_provider\n elif dataset_name == 'examples_anpr':\n download_file_from_google_drive('1uGBd8tXlP0TZAXNgrR6H0jl5MXj7VPbN', dirname, 'anpr.tar')\n tar_file_path = os.path.join(dirname, 'anpr.tar')\n extract_archive(tar_file_path, dirname, archive_format='tar')\n imgs = glob.glob(os.path.join(dirname, '*.*g'))\n imgs = list(sorted(imgs))\n\n # CCPD (Chinese City Parking Dataset, ECCV) and PDRC (license Plate Detection and Recognition Challenge)\n # https://github.com/detectRecog/CCPD\n provinces = [\"皖\", \"沪\", \"津\", \"渝\", \"冀\", \"晋\", \"蒙\", \"辽\", \"吉\", \"黑\", \"苏\", \"浙\", \"京\", \"闽\", \"赣\", \"鲁\", \"豫\", \"鄂\", \"湘\", \"粤\",\n \"桂\", \"琼\", \"川\", \"贵\", \"云\", \"藏\", \"陕\", \"甘\", \"青\", \"宁\", \"新\", \"警\", \"学\", \"O\"]\n alphabets = ['A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'J', 'K', 'L', 'M', 'N', 'P', 'Q', 'R', 'S', 'T', 'U', 'V',\n 'W', 'X', 'Y', 'Z', 'O']\n ads = ['A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'J', 'K', 'L', 'M', 'N', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W',\n 'X', 'Y', 'Z', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'O']\n\n def lp2char(lp):\n cols = lp.split('_')\n charstring = ''\n for i in range(len(cols)):\n if i == 0:\n charstring += provinces[int(cols[i])]\n elif i == 1:\n charstring += alphabets[int(cols[i])]\n else:\n charstring += ads[int(cols[i])]\n return charstring\n\n width = 720\n height = 1160\n for im_path in imgs:\n lbl = im_path.split('/')[-1].rsplit('.', 1)[0].split('-')[-3]\n charstring = lp2char(lbl)\n iname = im_path.rsplit('/', 1)[-1].rsplit('.', 1)[0].split('-')\n [leftUp, rightDown] = [[int(eel) for eel in el.split('&')] for el in iname[2].split('_')]\n box = [leftUp[0], leftUp[1], rightDown[0], rightDown[1]]\n ori_w, ori_h = [float(int(el)) for el in [width, height]]\n new_labels = [(leftUp[0] + rightDown[0]) / (2 * ori_w), (leftUp[1] + rightDown[1]) / (2 * ori_h),\n (rightDown[0] - leftUp[0]) / ori_w, (rightDown[1] - leftUp[1]) / ori_h]\n download_file_from_google_drive('1e7Zjn2MHNCvA5gXdJUECzY8NjK4KVpa7', dirname, 'antisproofing.tar')\n tar_file_path = os.path.join(dirname, 'antisproofing.tar')\n make_dir_if_need(os.path.join(dirname, 'antisproofing'))\n extract_archive(tar_file_path, dirname, archive_format='tar')\n data_provider = load_folder_images(dataset_name, os.path.join(dirname, 'antisproofing'))\n return data_provider\n\n\n\n elif dataset_name == 'examples_dogs-vs-cats':\n download_file_from_google_drive('10czW0On7eIXkPP-MuQ-IRxMWdTizWjNC', dirname, 'dogs-vs-cats.tar')\n tar_file_path = os.path.join(dirname, 'dogs-vs-cats.tar')\n extract_archive(tar_file_path, dirname, archive_format='tar')\n data_provider = load_folder_images(dataset_name, dirname)\n return data_provider\n elif dataset_name == 'examples_chinese':\n to_half=ToHalfWidth()\n to_sc=ChineseConvert(convert_to='simplified')\n download_file_from_google_drive('1yzRzXpLuhSUxnixqCgpbdTk16ajnTEWF', dirname, 'chinese.tar')\n tar_file_path = os.path.join(dirname, 'chinese.tar')\n extract_archive(tar_file_path, dirname, archive_format='tar')\n\n as_train = remove_nonprintable(to_half(codecs.open(os.path.join(dirname, 'as_training.utf8'), encoding='utf-8-sig').read().strip().replace('\\u3000' ,'|'))).splitlines()\n cityu_train =remove_nonprintable(to_half(codecs.open(os.path.join(dirname, 'cityu_training.utf8'), encoding='utf-8-sig').read().strip().replace(' ','|'))).splitlines()\n\n as_test = remove_nonprintable(to_half(codecs.open(os.path.join(dirname, 'as_testing_gold.utf8'), encoding='utf-8-sig').read().strip().replace('\\u3000', '|'))).splitlines()\n cityu_test = remove_nonprintable(to_half(codecs.open(os.path.join(dirname, 'cityu_test_gold.utf8'), encoding='utf-8-sig').read().strip().replace(' ', '|'))).splitlines()\n\n\n data = as_train + cityu_train # 把兩個語料合併\n test_data=as_test + cityu_test # 把兩個語料合併\n\n\n raw_data_train = [row.strip('\\n').strip('\\r') for row in data] # 移除分行字元\n raw_data_test = [row.strip('\\n').strip('\\r') for row in test_data] # 移除分行字元\n\n process_data_train=[]\n process_seg_label_train = []\n process_simplifided_label_train = []\n process_traditional_label_train = []\n\n tmp_data_train = []\n tmp_seg_label_train = []\n tmp_simplifided_label_train = []\n tmp_pronunce_label_train = []\n for k in tqdm(range(len(raw_data_train))):\n row=raw_data_train[k]\n if row.startswith('∥'):\n row=row[1:]\n words=row.replace('||','|').split('|')\n for k in range(len(words)):\n\n word = words[k]\n\n for i in range(len(word)):\n tmp_data_train.append(word[i])\n #tmp_simplifided_label_train.append(to_half(to_sc(word[i])))\n #轉換為BMES\n\n if i==0 and len(word)>1: #B 是一個詞的開始\n tmp_seg_label_train.append('B')\n elif i==len(word)-1 and len(word)>=2 and tmp_seg_label_train[-1] in ['B','M']: #E 是一個詞的結束\n tmp_seg_label_train.append('E')\n elif len(word)==1 and i==0: #S 自己就是一個單詞\n tmp_seg_label_train.append('S')\n elif len(word)>=3 and tmp_seg_label_train[-1] in ['B','M']: #M 是一個詞的中間\n tmp_seg_label_train.append('M')\n\n if len(tmp_seg_label_train)>0 and tmp_seg_label_train[-1] in ['E','S']:\n if len(word) > 1 and (is_alphabet(word) or is_punctuation(word)) and k+1<len(words):\n if word in [ '。','﹖']:\n pass\n\n elif random.random() < 0.6 or is_alphabet(word):\n tmp_data_train.append(' ')\n tmp_seg_label_train.append('S')\n\n if (k+1<len(raw_data_train) and not raw_data_train[k+1].startswith( '」')) and words[-1] in [ '。','﹖']:\n #process_traditional_label_train.append(tmp_data_train)\n\n tmp_data_train=to_half(''.join(tmp_data_train))\n tmp_seg_label_train = ''.join(tmp_seg_label_train)\n # if len(tmp_data_train)!=len(tmp_seg_label_train):\n # print('')\n tmp_simplifided_label_train =to_sc(tmp_data_train)\n\n process_data_train.append(tmp_data_train)\n process_seg_label_train.append(tmp_seg_label_train)\n process_simplifided_label_train.append(tmp_simplifided_label_train)\n tmp_data_train = []\n tmp_seg_label_train = []\n tmp_simplifided_label_train = []\n tmp_pronunce_label_train = []\n # else:\n # tmp_data_train.append('\\n')\n # tmp_simplifided_label_train.append('\\n')\n # tmp_seg_label_train.append('\\n')\n corpus=process_data_train\n seg_corpus=process_seg_label_train\n simplifided_corpus =process_simplifided_label_train\n\n process_data_test = []\n process_seg_label_test = []\n process_simplifided_label_test = []\n process_traditional_label_test = []\n print('generate test labels')\n tmp_data_test = []\n tmp_seg_label_test = []\n tmp_simplifided_label_test = []\n tmp_pronunce_label_test = []\n for k in tqdm(range(len(raw_data_test))):\n row=raw_data_test[k]\n if row.startswith('∥'):\n row=row[1:]\n words = row.replace('||', '|').split('|')\n for k in range(len(words)):\n\n word = words[k]\n\n for i in range(len(word)):\n tmp_data_test.append(word[i])\n # tmp_simplifided_label_test.append(to_half(to_sc(word[i])))\n # 轉換為BMES\n\n if i == 0 and len(word) > 1: # B 是一個詞的開始\n tmp_seg_label_test.append('B')\n elif i == len(word) - 1 and len(word) >= 2 and tmp_seg_label_test[-1] in ['B', 'M']: # E 是一個詞的結束\n tmp_seg_label_test.append('E')\n elif len(word) == 1 and i == 0: # S 自己就是一個單詞\n tmp_seg_label_test.append('S')\n elif len(word) >= 3 and tmp_seg_label_test[-1] in ['B', 'M']: # M 是一個詞的中間\n tmp_seg_label_test.append('M')\n\n if len(tmp_seg_label_test) > 0 and tmp_seg_label_test[-1] in ['E', 'S'] and k+1<len(words):\n if len(word) > 1 and (is_alphabet(word) or is_punctuation(word)):\n if word in ['。', '﹖']:\n pass\n elif random.random() < 0.6 or is_alphabet(word):\n tmp_data_test.append(' ')\n tmp_seg_label_test.append('S')\n\n if (k + 1 < len(raw_data_test) and not raw_data_test[k + 1].startswith('」')) and words[-1] in ['。', '﹖']:\n # process_traditional_label_test.append(tmp_data_test)\n\n tmp_data_test = to_half(''.join(tmp_data_test))\n tmp_seg_label_test = ''.join(tmp_seg_label_test)\n # if len(tmp_data_test)!=len(tmp_seg_label_test):\n # print('')\n tmp_simplifided_label_test = to_sc(tmp_data_test)\n\n process_data_test.append(tmp_data_test)\n process_seg_label_test.append(tmp_seg_label_test)\n process_simplifided_label_test.append(tmp_simplifided_label_test)\n tmp_data_test = []\n tmp_seg_label_test = []\n tmp_simplifided_label_test = []\n tmp_pronunce_label_test = []\n # else:\n # tmp_data_test.append('\\n')\n # tmp_simplifided_label_test.append('\\n')\n # tmp_seg_label_test.append('\\n')\n test_corpus = process_data_test\n test_seg_corpus = process_seg_label_test\n test_simplifided_corpus = process_simplifided_label_test\n\n\n data=TextSequenceDataset(corpus=corpus,sequence_length=64,sequence_start_at='section_start',object_type=ObjectType.corpus,symbol='input')\n seg_label = TextSequenceDataset(corpus=seg_corpus,sequence_length=64, sequence_start_at='section_start', object_type=ObjectType.sequence_label,symbol='seg_label')\n simplifided_label = TextSequenceDataset(corpus=simplifided_corpus,sequence_length=64, sequence_start_at='section_start', object_type=ObjectType.sequence_label,symbol='simplified_label')\n traditional_label = TextSequenceDataset(corpus= copy.deepcopy(corpus), sequence_length=64, sequence_start_at='section_start', object_type=ObjectType.sequence_label,symbol='traditional_label')\n\n data_test=TextSequenceDataset(corpus=test_corpus,sequence_length=64,sequence_start_at='section_start',object_type=ObjectType.corpus,symbol='input')\n seg_test_label = TextSequenceDataset(corpus=test_seg_corpus,sequence_length=64, sequence_start_at='section_start', object_type=ObjectType.sequence_label,symbol='seg_label')\n simplifided_test_label = TextSequenceDataset(corpus=test_simplifided_corpus,sequence_length=64, sequence_start_at='section_start', object_type=ObjectType.sequence_label,symbol='simplified_label')\n traditional_test_label = TextSequenceDataset(corpus= copy.deepcopy(test_corpus), sequence_length=64, sequence_start_at='section_start', object_type=ObjectType.sequence_label,symbol='traditional_label')\n\n\n chars = list(sorted(set(list( ''.join(corpus) +bpmf_phonetic+'\\n\\r\\t∥'+ ''.join(simplifided_corpus)+''.join(test_data)))))\n chars.insert(0, '[CLS]')\n chars.insert(1, '[SEP]')\n chars.insert(2, '[UNK]')\n chars.insert(3, '[PAD]')\n chars.insert(4, '[MASK]')\n\n data.vocabs =data_test.vocabs=simplifided_label.vocabs=simplifided_test_label.vocabs = chars\n data.text2index=data_test.text2index =simplifided_label.text2index=simplifided_test_label.text2index = dict((c, i) for i, c in enumerate(chars))\n data.index2text =data_test.index2text =simplifided_label.index2text=simplifided_test_label.index2text= dict((i, c) for i, c in enumerate(chars))\n traditional_label = copy.deepcopy(data)\n traditional_test_label = copy.deepcopy(data_test)\n traditional_label.object_type =traditional_test_label.object_type = ObjectType.sequence_label\n traditional_label.symbol =traditional_test_label.symbol = 'traditional_label'\n\n mask_label = copy.deepcopy(data)\n mask_test_label = copy.deepcopy(data_test)\n #mask_label.object_type =mask_test_label.object_type= ObjectType.corpus\n mask_label.symbol = mask_test_label.symbol = 'mask_label'\n\n\n\n nextword=copy.deepcopy(data)\n nextword_test = copy.deepcopy(data_test)\n nextword.object_type=nextword_test.object_type=ObjectType.sequence_label\n nextword.symbol=nextword_test.symbol='nextword_label'\n nextword.sequence_offset=nextword_test.sequence_offset=1\n\n label=ZipDataset(seg_label,nextword,simplifided_label,traditional_label,mask_label)\n label_test = ZipDataset(seg_test_label, nextword_test, simplifided_test_label, traditional_test_label, mask_test_label)\n provider=TextSequenceDataProvider(\n traindata=Iterator(data=data,label=label),\n testdata=Iterator(data=data_test,label=label_test))\n return provider\n #,sample_filter=lambda x:x[0][-1]==3\n else:\n return None","def test_dataaug():\n # test len\n augdataset = AugmentedDataset(4, foldername=\"test_data\")\n assert len(augdataset) == 40\n\n augbaldatset = AugmentedBalancedDataset(2, foldername=\"test_data\")\n assert len(augbaldatset) == 2*(3*4)\n\n # test getitem\n assert augdataset[35][0].size() == (1, 299, 299)\n assert augbaldatset[40040][0].size() == (1, 299, 299)","def Test_data():\n print (\"loading test data ...\")\n time_start = time.time()\n data_root = '/media/keziwen/86AA9651AA963E1D'\n\n with h5py.File(join(data_root, './data/test_real2.h5')) as f:\n test_real = f['test_real'][:]\n with h5py.File(join(data_root, './data/test_imag2.h5')) as f:\n test_imag = f['test_imag'][:]\n test_real = np.transpose(test_real, (0, 1, 3, 2))\n test_imag = np.transpose(test_imag, (0, 1, 3, 2))\n test_data = test_real+1j*test_imag\n time_end = time.time()\n print ('dataset has been created using {}s'.format(time_end - time_start))\n return test_data","def _load_testing_data(base_dir):\n test_data = pd.read_csv(os.path.join(base_dir, \"test_vale.csv\")).adjclose.values\n return _data_transformation(test_data)","def load_data(self):","def test_compute_glycemic_load(self):\n pass","def test_dataset_from_dir(dir_dataset):\n dummy = \"malesuada. Integer id magna et ipsum cursus vestibulum. Mauris magna.\"\n assert dir_dataset[0][0] == dummy\n assert dir_dataset[0][1] == '8'\n\n dummy = \"Sed molestie. Sed id risus quis diam luctus lobortis. Class\"\n assert dir_dataset[100][0] == dummy\n assert dir_dataset[100][1] == '6'","def test_wool():\n test_path = tempfile.mkdtemp()\n x_train, metadata = wool(test_path)\n try:\n assert x_train.shape == (309, 2)\n except:\n shutil.rmtree(test_path)\n raise()","def test_import():\n assert hasattr(waves, 'wave_number')","def load_dataset_test():\n df_test = load_csv_file(\"31_test.csv\")\n return df_test.values","def test_Conll2003Loader(self):\n dataset_path = \"test/data_for_tests/conll_2003_example.txt\"\n loader = Conll2003Loader()\n dataset_2003 = loader.load(dataset_path)","def setUp(self):\n self.test_data = self.read_data('test_data/clients.txt')","def testCreateWmsDataset(self):\n\n # create the source\n\n path = '/minerva_source_wms'\n name = 'testWMS'\n typeName = 'geonode:global_temp'\n username = ''\n password = ''\n baseURL = 'http://demo.boundlessgeo.com/geoserver/ows'\n params = {\n 'name': name,\n 'username': username,\n 'password': password,\n 'baseURL': baseURL\n }\n response = self.request(path=path, method='POST', params=params, user=self._user)\n self.assertStatusOk(response)\n wmsSource = response.json\n\n # create the dataset\n\n path = '/minerva_dataset_wms'\n name = 'testWMSdataset'\n wmsParams = {}\n params = {\n 'name': name,\n 'wmsSourceId': wmsSource['_id'],\n 'typeName': typeName,\n 'wmsParams': wmsParams\n }\n response = self.request(path=path, method='POST', params=params, user=self._user)\n self.assertStatusOk(response)\n wmsDataset = response.json\n minerva_metadata = wmsDataset['meta']['minerva']\n self.assertEquals(wmsDataset['name'], name, 'incorrect wms dataset name')\n self.assertEquals(minerva_metadata['source_id'], wmsSource['_id'], 'incorrect wms source_id')\n self.assertEquals(minerva_metadata['dataset_type'], 'wms', 'incorrect wms dataset type')\n self.assertEquals(minerva_metadata['base_url'], wmsSource['meta']['minerva']['wms_params']['base_url'],'incorrect wms dataset baseURL')\n self.assertEquals(minerva_metadata['type_name'], typeName, 'incorrect wms dataset typeName')\n legend = 'PD94bWwgdmVyc2lvbj0iMS4wIiBlbmNvZGluZz0iVVRGLTgiPz48U2VydmljZUV4Y2VwdGlvblJlcG9ydCB2ZXJzaW9uPSIxLjMuMCIgeG1sbnM9Imh0dHA6Ly93d3cub3Blbmdpcy5uZXQvb2djIiB4bWxuczp4c2k9Imh0dHA6Ly93d3cudzMub3JnLzIwMDEvWE1MU2NoZW1hLWluc3RhbmNlIiB4c2k6c2NoZW1hTG9jYXRpb249Imh0dHA6Ly93d3cub3Blbmdpcy5uZXQvb2djIGh0dHA6Ly9kZW1vLmJvdW5kbGVzc2dlby5jb206ODAvZ2Vvc2VydmVyL3NjaGVtYXMvd21zLzEuMy4wL2V4Y2VwdGlvbnNfMV8zXzAueHNkIj4gICA8U2VydmljZUV4Y2VwdGlvbj4KICAgICAgQ2FuJmFwb3M7dCBvYnRhaW4gdGhlIHNjaGVtYSBmb3IgdGhlIHJlcXVpcmVkIGxheWVyLgpnZW9ub2RlOmdsb2JhbF90ZW1wIGxheWVyIGRvZXMgbm90IGV4aXN0Lgo8L1NlcnZpY2VFeGNlcHRpb24+PC9TZXJ2aWNlRXhjZXB0aW9uUmVwb3J0Pg==\\n'\n # TODO determine if legend is stable, if not, needs to be mocked\n self.assertEquals(minerva_metadata['legend'], legend, 'incorrect wms dataset legend')","def test_ingest_zipfile():\n\n try:\n\n adult_data_df = ingest_csv_from_zipfile(Directories.ZIP_FILE_DIR.value, FileNames.DATA_FILE.value)\n\n except Exception as exception:\n\n pytest.fail('Ingest zip file error: {}'.format(exception))\n\n pass","def load_dataset():\n\n\n train_dd_loader = DailyDialogLoader(PATH_TO_TRAIN_DATA, load=False)\n train_dataloader = DataLoader(train_dd_loader, batch_size=16, shuffle=True, num_workers=0,\n collate_fn=PadCollate())\n\n test_dd_loader = DailyDialogLoader(PATH_TO_TEST_DATA, load=True)\n test_dataloader = DataLoader(test_dd_loader, batch_size=1, shuffle=False, num_workers=0,\n collate_fn=PadCollate())\n\n assert train_dd_loader.vocabulary.n_words == test_dd_loader.vocabulary.n_words\n\n return train_dd_loader, train_dataloader, test_dataloader","def test_dataset_autogen_dir_with_test(autogen_dataset_dir_with_test):\n train_dummy = \"Donec non justo. Proin non massa non ante bibendum ullamcorper.\"\n val_dummy = \"nibh. Aliquam ornare, libero at auctor ullamcorper, nisl arcu iaculis\"\n test_dummy = \"a sollicitudin orci sem eget massa. Suspendisse eleifend. Cras sed\"\n\n assert autogen_dataset_dir_with_test.train[0][0] == train_dummy\n assert autogen_dataset_dir_with_test.train[0][1] == '4'\n assert len(autogen_dataset_dir_with_test.train) == 201\n\n assert autogen_dataset_dir_with_test.val[0][0] == val_dummy\n assert autogen_dataset_dir_with_test.val[0][1] == '10'\n assert len(autogen_dataset_dir_with_test.val) == 51\n\n assert autogen_dataset_dir_with_test.test[0][0] == test_dummy\n assert autogen_dataset_dir_with_test.test[0][1] == '3'\n assert len(autogen_dataset_dir_with_test.test) == 50","def setup(self):\n self.rows = test_helpers.fetch_sample_teradata_rows()\n self.csv_path = 'not/a/real/path'","def test_invlaid_data(self):\n # Currently, there are no PowerPlant or Project objects in the database\n self.assertEqual(PowerPlant.objects.count(), 0)\n self.assertEqual(Project.objects.count(), 0)\n\n # Call the command with invalid data.\n # The first row is for a power plant, but it has an invalid latitude.\n # The second row is for a project, but it has an invalid project capacity.\n # The third row is for a project, but it has an invalid project capacity unit.\n # The fourth row is for a power plant, but has an invalid status.\n self.call_command(filename='power_plant_import/tests/data/invalid_data.csv')\n\n # Each of the objects were created, though the invalid data was not saved.\n self.assertEqual(PowerPlant.objects.count(), 3)\n self.assertEqual(Project.objects.count(), 2)","def test_import(self):\r\n descriptor = self.get_dummy_course(START)","def load_data(self) -> None:","def test_dataset():\n # File paths\n intervals_file = \"example_files/intervals.bed\"\n target_file = \"example_files/targets.tsv\"\n gtf_file = \"example_files/gencode.v24.annotation_chr22.gtf\"\n fasta_file = \"example_files/hg38_chr22.fa\"\n ds = SeqDistDataset(intervals_file, fasta_file, gtf_file, target_file)\n\n ds[0]\n ds[10]\n it = ds.batch_iter(32)\n next(it)","def load_data(opt=\"mnist\"):\n if opt == \"mnist\":\n train, test = tf.keras.datasets.mnist.load_data()\n \n x_train, y_train = train\n x_test, y_test = test\n \n x_train = x_train.reshape(x_train.shape[0], 28 * 28)\n x_test = x_test.reshape(x_test.shape[0], 28 * 28)\n \n y_train = y_train.astype(np.int)\n y_test = y_test.astype(np.int)\n for i in range(len(y_train)):\n y_train[i] = 1 if y_train[i] % 2 == 0 else -1\n for i in range(len(y_test)):\n y_test[i] = 1 if y_test[i] % 2 == 0 else -1\n\n elif opt == \"covertype\":\n df = pd.read_csv(\"covtype.data\", header=None)\n x = df.iloc[:, 0:54].values\n y = df[54].values\n for i in range(len(y)):\n y[i] = 1 if y[i] % 2 == 0 else -1\n x_train, x_test, y_train, y_test = train_test_split(x, y, test_size=0.3)\n \n else:\n logging.error(\"Unknown dataset!!\")\n\n logging.info(\"train data shape: {}\".format(x_train.shape))\n logging.info(\"test data shape: {}\".format(x_test.shape))\n return (x_train, y_train), (x_test, y_test)","def import_data_handler():\n\n result = ''\n try:\n current_dir = os.getcwd()\n directory_name = current_dir + '\\\\lesson5\\\\data\\\\'\n file_name_dict = {'products': 'products.csv', 'customers': 'customers.csv',\n 'rentals': 'rentals.csv'}\n for key, value in file_name_dict.items():\n tmp_file = directory_name + value\n mongo_insert = ImportUnitTestData()\n result = mongo_insert.import_data(key, tmp_file)\n print(result)\n except FileNotFoundError as e:\n logger.error('exception %s', e, exc_info=True)\n result = 'exception {}'.format(e)\n print(result)\n return result","def load_data():\n directories=[\"./track1/\",\n \"./track1_recovery/\",\n \"./track2/\",\n \"./track1_reverse/\",\n \"./track2_reverse/\",#Additional data for model built on top of lenet.h5\n \"./track2_recovery/\",#Additions data for model built on top of lenet.h5\n ]\n lines=[]\n for directory in directories:\n with open(directory+\"driving_log.csv\") as csvfile:\n reader=csv.reader(csvfile)\n for line in reader:\n lines.append(line)\n train_samples, validation_samples = train_test_split(lines, test_size=0.2)\n return train_samples, validation_samples","def test_ExtendSpine1(self):\n\n self.delayDisplay(\"Starting the test\")\n #\n # first, get some data\n #\n import urllib\n downloads = (\n ('http://slicer.kitware.com/midas3/download?items=5767', 'FA.nrrd', slicer.util.loadVolume),\n )\n\n for url,name,loader in downloads:\n filePath = slicer.app.temporaryPath + '/' + name\n if not os.path.exists(filePath) or os.stat(filePath).st_size == 0:\n logging.info('Requesting download %s from %s...\\n' % (name, url))\n urllib.urlretrieve(url, filePath)\n if loader:\n logging.info('Loading %s...' % (name,))\n loader(filePath)\n self.delayDisplay('Finished with download and loading')\n\n volumeNode = slicer.util.getNode(pattern=\"FA\")\n logic = ExtendSpineLogic()\n self.assertIsNotNone( logic.hasImageData(volumeNode) )\n self.delayDisplay('Test passed!')","def import_datasets(snli_path):\n print('extract data from snli directory..')\n train = dict(); dev = dict(); test = dict()\n gold_labels = {'entailment': 0, 'neutral': 1, 'contradiction': 2}\n\n for file_type in ['train', 'dev', 'test']:\n path = os.path.join(snli_path, 'snli_1.0_{}.jsonl'.format(file_type))\n with open(path) as file:\n data = [json.loads(line) for line in file]\n eval(file_type)['premise'] = [entry['sentence1'] for entry in data if entry['gold_label'] != '-']\n eval(file_type)['hypothesis'] = [entry['sentence2'] for entry in data if entry['gold_label'] != '-']\n g_labels = np.array([gold_labels[entry['gold_label']] for entry in data if entry['gold_label'] != '-'])\n eval(file_type)['label'] = g_labels\n print('extraction process was finished successfully!')\n return train, dev, test","def setUpTestData(cls):\n call_command('loaddata', 'db.json', verbosity=0)","def test_data_path(self):\n path = self._api.GetDatapath()\n self._api.End()\n self.assertRaises(\n RuntimeError, self._api.Init, path=(self._test_dir + os.path.sep)\n ) # no tessdata\n if _TESSERACT_VERSION >= 0x3999800:\n new_path = path\n else:\n new_path = os.path.abspath(os.path.join(path, os.path.pardir)) + os.path.sep\n self._api.End()\n self._api.Init(new_path)\n self.assertEqual(self._api.GetDatapath(), path)","def runTest(self):\n # workaround for Python 2.6\n if self.skip:\n return\n\n f = Dataset(self.file, 'a')\n w = f.variables[\"vl2\"]\n v = f.variables[\"vl\"]\n w[0:3] = np.arange(3, dtype=np.float64)\n v[0] # sometimes crashes\n v[0].tolist() # sometimes crashes\n v[0].size # BOOM!\n f.close()","def load_data(train_path, test_path):\n\n train_data = pd.read_csv(train_path)\n test_data = pd.read_csv(test_path)\n\n print(\"number of training examples = \" + str(train_data.shape[0]))\n print(\"number of test examples = \" + str(test_data.shape[0]))\n print(\"train shape: \" + str(train_data.shape))\n print(\"test shape: \" + str(test_data.shape))\n\n return train_data, test_data","def load_data(train_path, test_path):\n\n train_data = pd.read_csv(train_path)\n test_data = pd.read_csv(test_path)\n\n print(\"number of training examples = \" + str(train_data.shape[0]))\n print(\"number of test examples = \" + str(test_data.shape[0]))\n print(\"train shape: \" + str(train_data.shape))\n print(\"test shape: \" + str(test_data.shape))\n\n return train_data, test_data","def load_dataset(display = False, flag=\"train\"):\n\n if flag ==\"train\":\n print(\"Loading training set image X ...\")\n train_X_data = DataUtils(filename=trainfile_X).getImage()\n print(\"Loading training set label y ...\")\n train_y_data = DataUtils(filename=trainfile_y).getLabel()\n print(\"size of training set X = \", train_X_data.shape)\n print(\"size of training set y = \", train_y_data.shape) \n\n if display:\n path_trainset = \"MNIST_dataset/imgs_train\"\n if not os.path.exists(path_trainset):\n os.mkdir(path_trainset)\n outImg(train_X_data, train_y_data, 30, out_path)\n DataUtils(outpath=path_trainset).outImg(train_X_data, train_y_data, 30)\n\n return train_X_data, train_y_data\n \n elif flag == \"test\":\n print(\"Loading test set image X ...\")\n test_X_data = DataUtils(testfile_X).getImage()\n print(\"Loading test set label y ...\")\n test_y_data = DataUtils(testfile_y).getLabel()\n print(\"size of test set X = \", test_X_data.shape)\n print(\"size of test set y = \", test_y_data.shape)\n\n if display:\n path_testset = \"MNIST_dataset/imgs_test\"\n if not os.path.exists(path_testset):\n os.mkdir(path_testset)\n DataUtils(outpath=path_testset).outImg(test_X_data, test_y_data, 30)\n\n return test_X_data, test_y_data","def train_dataset():\n return TabularDataset.from_path('tests/data/dummy_tabular/train.csv', sep=',')","def test_includes_two_new_datasets(self):\n new_datasets = factories.SourceDatasetFactory.create_batch(2, source_study_version=self.study_version_3)\n response = self.client.get(self.get_url(self.study.pk))\n context = response.context\n table = context['source_dataset_table']\n for new_dataset in new_datasets:\n self.assertIn(new_dataset, table.data)","def setUpClass(cls):\n super(Module05Tests, cls).setUpClass()\n cls.datasets = {\n 0: DATASETS_ROOT + 'diffusion_synthetic_normal_L8_r2_slices_41_50_gr15_b1200',\n 1: DATASETS_ROOT + 'filtered',\n 2: DATASETS_ROOT + 'noise'\n }\n cls.data = smns.load_object(file_path=cls.datasets[2])","def data_import(path):\n train_path = os.path.join(path, \"train.csv\")\n test_path = os.path.join(path, \"test.csv\")\n df_train = pd.read_csv(train_path)\n df_test = pd.read_csv(test_path)\n return df_train, df_test","def test_import_python(self):\n provider = ProcessingProvider()\n registry = QgsApplication.processingRegistry()\n if not registry.providerById(provider.id()):\n registry.addProvider(provider)\n feedback = LoggerProcessingFeedBack(True)\n project = QgsProject()\n context = QgsProcessingContext()\n context.setProject(project)\n couche = QgsVectorLayer(plugin_test_data_path('portions.gpkg'), 'layer', 'ogr')\n\n params = {\n \"INPUT\": couche,\n \"TABLE\": \"portion\",\n \"SCHEMA\": \"veloroutes\",\n \"DATABASE\": \"test\",\n 'MATRIX': [\n \"TYPE_PORTION_COVADIS\", \"type_portion\",\n \"MONTANT_SUBVENTION\", \"mont_subv\",\n \"ANNE_SUBVENTION\", \"annee_subv\", \"fid\", \"id_import\",\n \"LIEN_ITIN\", \"lien_itin\", \"LIEN_CYCLO\", \"lien_segm\"]\n }\n\n alg = \"{}:import_covadis\".format(provider.id())\n processing.run(\n alg, params, feedback=feedback, context=context\n )\n\n p = \"\"\"\n SELECT id_portion FROM imports.import_portion LIMIT 1;\n \"\"\"\n self.cursor.execute(p)\n p1 = self.cursor.fetchone()\n self.assertIsNotNone(p1[0])","def test_training(self):\n\t\tpass","def train(self, trainfile):","def test_drop_data_handler(self):\n # insert some test data\n try:\n current_dir = os.getcwd()\n directory_name = current_dir + '\\\\lesson5\\\\data\\\\'\n file_name_dict = {'products': 'products.csv', 'customers': 'customers.csv',\n 'rentals': 'rentals.csv'}\n for key, value in file_name_dict.items():\n tmp_file = directory_name + value\n mongo_insert = mdb.ImportData(key, tmp_file)\n print(mongo_insert)\n except FileNotFoundError as e:\n logger.error('exception %s', e, exc_info=True)\n result = main.drop_data_handler()\n self.assertEqual(result, 'all data dropped- good luck on your next job')","def load_test(data_file, labels=True, skip_rows=0):\n dat = iter_loadtxt(data_file, delimiter='\\t', skiprows=skip_rows)\n if labels:\n Dat = DataSet(images=dat[:, 0:-1], labels=dat[:, -1].astype(int), reshape=False)\n else:\n nrow = dat.shape[0]\n Dat = DataSet(images=dat, labels=np.full(nrow, np.nan), reshape=False)\n return Dat","def __loadDataset(self, parameters):\n # self.localConfigured = Settings.instance().readValue( key = 'Common/local-repo' )\n for pr in parameters:\n if pr['type'] == 'dataset':\n if pr['value'].startswith('undefined:/'):\n fileName = pr['value'].split('undefined:/')[1]\n if not os.path.exists( fileName ):\n raise Exception(\"the following test data file is missing: %s \" % fileName)\n\n doc = FileModelTestData.DataModel()\n res = doc.load( absPath = fileName )\n pr['value'] = \"undefined:/%s\" % doc.getRaw()\n elif pr['value'].startswith('local-tests:/'):\n fileName = pr['value'].split('local-tests:/')[1]\n\n if not os.path.exists( fileName ):\n raise Exception(\"the following test data file is missing: %s \" % fileName)\n \n doc = FileModelTestData.DataModel()\n res = doc.load( absPath = fileName )\n pr['value'] = \"local-tests:/%s\" % doc.getRaw()\n else:\n pass","def load_raw_dataset(name):\n assert name in VALID_NAMES, 'Invalid data set requested. Please make sure name is one of ' + ', '.join(VALID_NAMES) + '.'\n\n os.makedirs('downloads', exist_ok=True)\n path = os.path.join('downloads', name)\n path_raw = os.path.join(path, 'raw')\n\n if name == 'iris':\n prep_path(path)\n safe_dl('https://archive.ics.uci.edu/ml/machine-learning-databases/iris/iris.data', path_raw)\n safe_dl('https://archive.ics.uci.edu/ml/machine-learning-databases/iris/iris.names', path_raw)\n return pd.read_csv(os.path.join(path_raw, 'iris.data'), names=['sepal_len', 'sepal_wid', 'petal_len', 'petal_wid', 'species'])\n\n elif name == 'wine':\n prep_path(path)\n safe_dl('https://archive.ics.uci.edu/ml/machine-learning-databases/wine/wine.data', path_raw)\n safe_dl('https://archive.ics.uci.edu/ml/machine-learning-databases/wine/wine.names', path_raw)\n return pd.read_csv(os.path.join(path_raw, 'wine.data'), names=['class',\n 'alcohol',\n 'malic_acid',\n 'ash',\n 'alkalinity',\n 'magnesium',\n 'phenols',\n 'flavanoids',\n 'nonflavanoid_phenols',\n 'proanthocyanins',\n 'color_intensity',\n 'hue',\n 'dilution',\n 'proline'])\n\n elif name == 'titanic':\n import kaggle; kaggle.api.authenticate()\n prep_path(path)\n if len(os.listdir(path_raw)) == 0:\n kaggle.api.competition_download_files('titanic', path_raw)\n titanic = pd.read_csv(os.path.join(path_raw, 'train.csv'))\n titanic_test = pd.read_csv(os.path.join(path_raw, 'test.csv'))\n return titanic, titanic_test\n\n elif name == 'lanl':\n import kaggle; kaggle.api.authenticate()\n prep_path(path)\n if len(os.listdir(path)) == 0:\n kaggle.api.competition_download_files('LANL-Earthquake-Prediction', path_raw)\n if not os.path.exists(os.path.join(path_raw, 'test')):\n zip_ref = zipfile.ZipFile(os.path.join(path_raw, 'test.zip'), 'r')\n zip_ref.extractall(os.path.join(path_raw, 'test'))\n zip_ref.close()\n return pd.read_csv(os.path.join(path_raw, 'train.csv.zip'))\n\n elif name == 'MNIST':\n mnist = torchvision.datasets.MNIST('downloads', train=True, download=True)\n mnist_test = torchvision.datasets.MNIST('downloads', train=False, download=True)\n return mnist, mnist_test\n\n elif name == 'FashionMNIST':\n fmnist = torchvision.datasets.FashionMNIST('downloads', train=True, download=True)\n fmnist_test = torchvision.datasets.FashionMNIST('downloads', train=False, download=True)\n return fmnist, fmnist_test","def load_data(conso_train_file='../input/conso_train.csv',\n meteo_train_file='../input/meteo_train.csv',\n meteo_test_file='../input/meteo_prev.csv'):\n # Loading the weather data\n train_meteo = pd.read_csv(meteo_train_file, sep=';')\n test_meteo = pd.read_csv(meteo_test_file, sep=';')\n\n # Marking the type and merge the train/test dataframes\n train_meteo['type'] = 'train'\n test_meteo['type'] = 'test'\n data_meteo = pd.concat([train_meteo, test_meteo])\n # Correct the weather data\n data_meteo = correct_weather_data(data_meteo)\n\n # Load the train consumption\n train_conso = pd.read_csv(conso_train_file, sep=';')\n # Correct the consumption data\n train_conso = correct_conso_data(train_conso)\n\n # Mark the type and merge the consumption/weather dataframes\n train_conso['type'] = 'train'\n data = pd.merge(train_conso, data_meteo,\n on=['date', 'type'], how='outer', sort=True)\n\n # Complete the test dates\n data = add_test_dates(data)\n # Correct the test data from the merging\n data = correct_test_data(data)\n\n return data","def test_record_is_dataset_file(self) -> None:\n path = \"/home/user/dataset.record\"\n result = is_dataset_file(path)\n self.assertTrue(result)","def load():\n filepath = dirname(abspath(__file__))\n##### EDIT THE FOLLOWING TO POINT TO DatasetName.csv #####\n data = recfromtxt(open(filepath + '/spector.csv',\"rb\"), delimiter=\" \",\n names=True, dtype=float, usecols=(1,2,3,4))\n names = list(data.dtype.names)\n endog = array(data[names[3]], dtype=float)\n endog_name = names[3]\n exog = column_stack(data[i] for i in names[:3]).astype(float)\n exog_name = names[:3]\n dataset = Dataset(data=data, names=names, endog=endog, exog=exog,\n endog_name = endog_name, exog_name=exog_name)\n return dataset","def setUp(self):\n super(FrameImportCSVTest, self).setUp()\n self.dataset = self.get_file(\"int_str_int.csv\")\n self.schema = [(\"num1\", int), (\"letter\", str), (\"num2\", int)]\n self.frame = self.context.frame.import_csv(self.dataset,\n schema=self.schema)","def test_import_software_asset(self):\n pass","def load_data(y_name='Species'):\n train_path = tf.keras.utils.get_file(args.TRAIN_URL.split('/')[-1], args.TRAIN_URL)\n test_path = tf.keras.utils.get_file(args.TEST_URL.split('/')[-1], args.TEST_URL)\n\n train = pd.read_csv(train_path, names=args.CSV_COLUMN_NAMES, header=0)\n train_x, train_y = train, train.pop(y_name)\n\n test = pd.read_csv(test_path, names=args.CSV_COLUMN_NAMES, header=0)\n test_x, test_y = test, test.pop(y_name)\n\n return (train_x, train_y), (test_x, test_y)","def setUp(self):\n self.dataset = self.dataset_cls()","def test(self, dataset) -> None:\n raise NotImplementedError()","def test_load_data_single_column():\n f = ImageFeaturizer()\n f.load_data(**LOAD_DATA_ARGS)\n compare_featurizer_class(f, (227, 227), np.zeros((1)), **COMPARE_ARGS)\n\n # Remove path to the generated csv at end of test\n remove_generated_paths()","def load_data_raw(source='local'):\n import os\n\n if source == 'kaggle':\n # Download the Ames Housing Dataset\n # Set the enviroment variables\n import zipfile\n os.environ['KAGGLE_USERNAME'] = \"lubomrstraka\"\n os.environ['KAGGLE_KEY'] = \"c7347462ef834e6645ce238c2f2fa561\"\n \n # Import dependencies\n os.system(\"pip install kaggle --upgrade --quiet\")\n\n # Download datasets\n os.system(\"kaggle competitions download -c house-prices-advanced-regression-techniques --quiet\")\n \n # Extract data\n with zipfile.ZipFile('house-prices-advanced-regression-techniques.zip', 'r') as archive:\n archive.extractall()\n\n # Read Train & Test Baseline Data\n train_bl = pd.read_csv('train.csv', index_col='Id')\n test_bl = pd.read_csv('test.csv', index_col='Id')\n \n # Using local data used while registering dataset\n # prevents \"Too many requests\" response from Kaggle\n elif source == 'local': \n train_bl = pd.read_csv('train.csv', index_col='Id')\n test_bl = pd.read_csv('test.csv', index_col='Id')\n \n else:\n print('Missing data!')\n train_bl = pd.DataFrame()\n test_bl = pd.DataFrame()\n\n\n return train_bl, test_bl","def test_dataset_autogen(autogen_dataset):\n train_dummy = \"eget, venenatis a, magna. Lorem ipsum dolor sit amet, consectetuer\"\n val_dummy = \"leo. Vivamus nibh dolor, nonummy ac, feugiat non, lobortis quis,\"\n test_dummy = \"turpis egestas. Aliquam fringilla cursus purus. Nullam scelerisque neque sed\"\n\n assert autogen_dataset.train[0][0] == train_dummy\n assert autogen_dataset.train[0][1] == '8'\n assert len(autogen_dataset.train) == 64\n\n assert autogen_dataset.val[0][0] == val_dummy\n assert autogen_dataset.val[0][1] == '1'\n assert len(autogen_dataset.val) == 16\n\n assert autogen_dataset.test[0][0] == test_dummy\n assert autogen_dataset.test[0][1] == '6'\n assert len(autogen_dataset.test) == 20","def test_dataloader(self) -> torch.utils.data.DataLoader: \n return torch.utils.data.DataLoader(self.dataset_test, **self.dl_kwargs)","def test_load_model_data(self):\n add_components_and_load_data(\n prereq_modules=IMPORTED_PREREQ_MODULES,\n module_to_test=MODULE_BEING_TESTED,\n test_data_dir=TEST_DATA_DIRECTORY,\n subproblem=\"\",\n stage=\"\",\n )","def test_load_model_data(self):\n add_components_and_load_data(\n prereq_modules=IMPORTED_PREREQ_MODULES,\n module_to_test=MODULE_BEING_TESTED,\n test_data_dir=TEST_DATA_DIRECTORY,\n subproblem=\"\",\n stage=\"\",\n )","def test_get_denoiser_data_dir(self):\r\n\r\n obs = get_denoiser_data_dir()\r\n\r\n self.assertTrue(exists(obs))\r\n self.assertTrue(exists(obs + 'FLX_error_profile.dat'))","def Train_data():\n print (\"loading train data ...\")\n time_start = time.time()\n data_root = '/media/keziwen/86AA9651AA963E1D'\n with h5py.File(join(data_root, './data/train_real2.h5')) as f:\n data_real = f['train_real'][:]\n num, nt, ny, nx = data_real.shape\n data_real = np.transpose(data_real, (0, 1, 3, 2))\n with h5py.File(join(data_root, './data/train_imag2.h5')) as f:\n data_imag = f['train_imag'][:]\n num, nt, ny, nx = data_imag.shape\n data_imag = np.transpose(data_imag, (0, 1, 3, 2))\n data = data_real+1j*data_imag\n num_train = 15000\n num_validate = 2000\n train_data = data[0:num_train]\n validate_data = data[num_train:num_train+num_validate]\n\n train_data = np.random.permutation(train_data)\n\n time_end = time.time()\n print ('dataset has been created using {}s'.format(time_end-time_start))\n return train_data, validate_data","def setUp(self):\n\n self.test_data_path = 'testing/test_data/'","def test_alien_data(self):","def get_test_data():\n\n # test set\n test = pd.read_csv(\"test.csv\")\n\n return test","def test_import_values_densetxt():\n x = np.random.rand(7, 11)\n export_data('/tmp/test.densetxt', x)\n assert np.array_equal(x, import_data('/tmp/test.densetxt'))","def test_import_process(self):\r\n good_file = self._get_del_file()\r\n imp = Importer(good_file, username=u\"admin\")\r\n imp.process()\r\n\r\n # now let's do some db sanity checks\r\n self._delicious_data_test()","def test_data():\n current_dir = os.path.dirname(os.path.abspath(__file__))\n test_data_dir = os.path.join(current_dir, \"test_data\")\n\n return pd.read_csv(os.path.join(test_data_dir, \"test_data_6m.csv\"))","def load_data_simple_train_test(train_pos_data_path, train_neg_data_path, stopwords):\n\n\ttrain_files_pos = [join(train_pos_data_path, f) for f in listdir(train_pos_data_path) if isfile(join(train_pos_data_path, f))]\n\ttrain_files_neg = [join(train_neg_data_path, f) for f in listdir(train_neg_data_path) if isfile(join(train_neg_data_path, f))]\n\n\ttrain_files_pos.sort(key = lambda x: x.split(\"_\")[0].replace(\"cv\", \"\"))\n\ttrain_files_neg.sort(key = lambda x: x.split(\"_\")[0].replace(\"cv\", \"\"))\n\n\tprint(\"The count of all positive files is: \", len(train_files_pos))\n\tprint(\"The count of all negative files is: \", len(train_files_neg))\n\n\tall_pos_docs = collect_train_data(train_files_pos, stopwords)\n\tall_neg_docs = collect_train_data(train_files_neg, stopwords)\n\n\tpos_train = all_pos_docs[:900]\n\tneg_train = all_neg_docs[:900]\n\tpos_test = all_pos_docs[900:]\n\tneg_test = all_neg_docs[900:]\n\n\tprint(\"The size of the positive training set is: \", len(pos_train))\n\tprint(\"The size of the negative training set is: \", len(neg_train))\n\tprint(\"The size of the positive test set is: \", len(pos_test))\n\tprint(\"The size of the negative test set is: \", len(neg_test))\n\n\treturn pos_train, pos_test, neg_train, neg_test","def _create_data():\n tf.logging.info(\"Create records..\")\n train, val, test = util.load_data(data_dir, FLAGS[\"is_aug\"])\n tf.logging.info(\"Dataset size: Train-{} Test-{} Val-{}\".format(len(train), len(test), len(val)))\n return train, val, test","def __test_and_train(self):\n f = open(\"all_data_info.csv\")\n reader = csv.DictReader(f, delimiter=\",\")\n data = []\n for line in reader:\n if line['artist_group'] == \"train_and_test\" and line[\"in_train\"] == \"False\":\n # the img's artist is in training set\n # but the img is in test set only\n data.append((line['artist'], line['new_filename']))\n\n return data","def load_wmt_en_fr_dataset(data_dir=\"wmt\"):\n # URLs for WMT data.\n _WMT_ENFR_TRAIN_URL = \"http://www.statmt.org/wmt10/training-giga-fren.tar\"\n _WMT_ENFR_DEV_URL = \"http://www.statmt.org/wmt15/dev-v2.tgz\"\n\n def maybe_download(directory, filename, url):\n \"\"\"Download filename from url unless it's already in directory.\"\"\"\n if not os.path.exists(directory):\n print(\"Creating directory %s\" % directory)\n os.mkdir(directory)\n filepath = os.path.join(directory, filename)\n if not os.path.exists(filepath):\n print(\"Downloading %s to %s\" % (url, filepath))\n filepath, _ = urllib.request.urlretrieve(url, filepath)\n statinfo = os.stat(filepath)\n print(\"Succesfully downloaded\", filename, statinfo.st_size, \"bytes\")\n return filepath\n\n def gunzip_file(gz_path, new_path):\n \"\"\"Unzips from gz_path into new_path.\"\"\"\n print(\"Unpacking %s to %s\" % (gz_path, new_path))\n with gzip.open(gz_path, \"rb\") as gz_file:\n with open(new_path, \"wb\") as new_file:\n for line in gz_file:\n new_file.write(line)\n\n def get_wmt_enfr_train_set(directory):\n \"\"\"Download the WMT en-fr training corpus to directory unless it's there.\"\"\"\n train_path = os.path.join(directory, \"giga-fren.release2\")\n if not (gfile.Exists(train_path +\".fr\") and gfile.Exists(train_path +\".en\")):\n corpus_file = maybe_download(directory, \"training-giga-fren.tar\",\n _WMT_ENFR_TRAIN_URL)\n print(\"Extracting tar file %s\" % corpus_file)\n with tarfile.open(corpus_file, \"r\") as corpus_tar:\n corpus_tar.extractall(directory)\n gunzip_file(train_path + \".fr.gz\", train_path + \".fr\")\n gunzip_file(train_path + \".en.gz\", train_path + \".en\")\n return train_path\n\n def get_wmt_enfr_dev_set(directory):\n \"\"\"Download the WMT en-fr training corpus to directory unless it's there.\"\"\"\n dev_name = \"newstest2013\"\n dev_path = os.path.join(directory, dev_name)\n if not (gfile.Exists(dev_path + \".fr\") and gfile.Exists(dev_path + \".en\")):\n dev_file = maybe_download(directory, \"dev-v2.tgz\", _WMT_ENFR_DEV_URL)\n print(\"Extracting tgz file %s\" % dev_file)\n with tarfile.open(dev_file, \"r:gz\") as dev_tar:\n fr_dev_file = dev_tar.getmember(\"dev/\" + dev_name + \".fr\")\n en_dev_file = dev_tar.getmember(\"dev/\" + dev_name + \".en\")\n fr_dev_file.name = dev_name + \".fr\" # Extract without \"dev/\" prefix.\n en_dev_file.name = dev_name + \".en\"\n dev_tar.extract(fr_dev_file, directory)\n dev_tar.extract(en_dev_file, directory)\n return dev_path\n ## ==================\n if data_dir == \"\":\n print(\"Load or Download WMT English-to-French translation > %s\"\n % os.getcwd())\n else:\n print(\"Load or Download WMT English-to-French translation > %s\"\n % data_dir)\n ## ======== Download if not exist\n train_path = get_wmt_enfr_train_set(data_dir)\n dev_path = get_wmt_enfr_dev_set(data_dir)\n\n return train_path, dev_path","def test_readSongData():\n\n # make sure the number of columns pull out from the database is correct\n assert svd.song_df.shape[1] == 8","def _load_training_data(self):\n self._save_training_data()","def test_import_controls_with_evidence(self):\n response = self.import_file(\"controls_no_warnings.csv\")\n self._check_csv_response(response, {})\n\n evidence = models.Document.query.filter_by(title=\"Some title 3\").all()\n self.assertEqual(len(evidence), 1)\n control = models.Control.query.filter_by(slug=\"control-3\").first()\n self.assertEqual(control.document_evidence[0].title, \"Some title 3\")","def test_i_large_datasets(self):\n\n # If foma is not installed, exit.\n if not h.foma_installed(force_check=True):\n return\n\n # Configuration\n\n # The ``old_dump_file`` variable holds the name of a MySQL dump file in /tests/data/datasets\n # that will be used to populate the database.\n old_dump_file = 'blaold.sql'\n backup_dump_file = 'old_test_dump.sql'\n\n # The ``precompiled_morphophonology`` variable holds the name of a compiled foma FST that\n # maps surface representations to sequences of morphemes. A file with this name should be\n # present in /tests/data/morphophonologies or else the variable should be set to None.\n pregenerated_morphophonology = None # 'blaold_morphophonology.script'\n precompiled_morphophonology = None # 'blaold_morphophonology.foma'\n\n # Here we load a whole database from the mysqpl dump file specified in ``tests/data/datasets/<old_dump_file>``.\n old_dump_file_path = os.path.join(self.test_datasets_path, old_dump_file)\n backup_dump_file_path = os.path.join(self.test_datasets_path, backup_dump_file)\n tmp_script_path = os.path.join(self.test_datasets_path, 'tmp.sh')\n if not os.path.isfile(old_dump_file_path):\n return\n config = h.get_config(config_filename='test.ini')\n SQLAlchemyURL = config['sqlalchemy.url']\n if not SQLAlchemyURL.split(':')[0] == 'mysql':\n return\n rdbms, username, password, db_name = SQLAlchemyURL.split(':')\n username = username[2:]\n password = password.split('@')[0]\n db_name = db_name.split('/')[-1]\n # First dump the existing database so we can load it later.\n # Note: the --single-transaction option seems to be required (on Mac MySQL 5.6 using InnoDB tables ...)\n # see http://forums.mysql.com/read.php?10,108835,112951#msg-112951\n with open(tmp_script_path, 'w') as tmpscript:\n tmpscript.write('#!/bin/sh\\nmysqldump -u %s -p%s --single-transaction --no-create-info --result-file=%s %s' % (\n username, password, backup_dump_file_path, db_name))\n os.chmod(tmp_script_path, 0744)\n with open(os.devnull, \"w\") as fnull:\n call([tmp_script_path], stdout=fnull, stderr=fnull)\n # Now load the dump file of the large database (from old_dump_file)\n with open(tmp_script_path, 'w') as tmpscript:\n tmpscript.write('#!/bin/sh\\nmysql -u %s -p%s %s < %s' % (username, password, db_name, old_dump_file_path))\n with open(os.devnull, \"w\") as fnull:\n call([tmp_script_path], stdout=fnull, stderr=fnull)\n\n # Recreate the default users that the loaded dump file deleted\n administrator = h.generate_default_administrator()\n contributor = h.generate_default_contributor()\n viewer = h.generate_default_viewer()\n Session.add_all([administrator, contributor, viewer])\n Session.commit()\n\n\n ################################################################################\n # PHONOLOGY\n ################################################################################\n\n # Create a Blackfoot phonology with the test phonology script\n params = self.phonology_create_params.copy()\n params.update({\n 'name': u'Blackfoot Phonology',\n 'description': u'The phonological rules of Frantz (1997) as FSTs',\n 'script': self.blackfoot_phonology_script\n })\n params = json.dumps(params)\n response = self.app.post(url('phonologies'), params, self.json_headers,\n self.extra_environ_admin)\n resp = json.loads(response.body)\n phonology_id = resp['id']\n\n \"\"\"\n\n\n ################################################################################\n # MORPHOLOGY\n ################################################################################\n\n # Create a lexicon form search and corpus\n # The code below constructs a query that finds a (large) subset of the Blackfoot morphemes.\n # Notes for future morphology creators:\n # 1. the \"oth\" category is a mess: detangle the nominalizer, inchoative, transitive suffixes, etc. from\n # one another and from the numerals and temporal modifiers -- ugh!\n # 2. the \"pro\" category\" is also a mess: clearly pronoun-forming iisto does not have the same distribution \n # as the verbal suffixes aiksi and aistsi! And oht, the LING/means thing, is different again...\n # 3. hkayi, that thing at the end of demonstratives, is not agra, what is it? ...\n # 4. the dim category contains only 'sst' 'DIM' and is not used in any forms ...\n lexical_category_names = ['nan', 'nin', 'nar', 'nir', 'vai', 'vii', 'vta', 'vti', 'vrt', 'adt',\n 'drt', 'prev', 'med', 'fin', 'oth', 'o', 'und', 'pro', 'asp', 'ten', 'mod', 'agra', 'agrb', 'thm', 'whq',\n 'num', 'stp', 'PN']\n durative_morpheme = 15717\n hkayi_morpheme = 23429\n query = {'filter': ['and', [['Form', 'syntactic_category', 'name', 'in', lexical_category_names],\n ['not', ['Form', 'morpheme_break', 'regex', '[ -]']],\n ['not', ['Form', 'id', 'in', [durative_morpheme, hkayi_morpheme]]],\n ['not', ['Form', 'grammaticality', '=', '*']]\n ]]}\n smaller_query_for_rapid_testing = {'filter': ['and', [['Form', 'id', '<', 1000],\n ['Form', 'syntactic_category', 'name', 'in', lexical_category_names]]]}\n params = self.form_search_create_params.copy()\n params.update({\n 'name': u'Blackfoot morphemes',\n 'search': query\n })\n params = json.dumps(params)\n response = self.app.post(url('formsearches'), params, self.json_headers, self.extra_environ_admin)\n lexicon_form_search_id = json.loads(response.body)['id']\n params = self.corpus_create_params.copy()\n params.update({\n 'name': u'Corpus of Blackfoot morphemes',\n 'form_search': lexicon_form_search_id\n })\n params = json.dumps(params)\n response = self.app.post(url('corpora'), params, self.json_headers, self.extra_environ_admin)\n lexicon_corpus_id = json.loads(response.body)['id']\n\n # Create a rules corpus\n\n # Create a corpus of forms containing words -- to be used to estimate ngram probabilities\n # The goal here is to exclude things that look like words but are not really words, i.e., \n # morphemes; as a heuristic we search for grammatical forms categorized as 'sent' or whose\n # transcription value contains a space or a dash.\n query = {'filter': ['and', [['or', [['Form', 'syntactic_category', 'name', '=', u'sent'],\n ['Form', 'morpheme_break', 'like', '% %'],\n ['Form', 'morpheme_break', 'like', '%-%']]],\n ['Form', 'syntactic_category_string', '!=', None],\n ['Form', 'grammaticality', '=', '']]]}\n params = self.form_search_create_params.copy()\n params.update({\n 'name': u'Find Blackfoot sentences',\n 'description': u'Returns all forms containing words',\n 'search': query\n })\n params = json.dumps(params)\n response = self.app.post(url('formsearches'), params, self.json_headers, self.extra_environ_admin)\n rules_form_search_id = json.loads(response.body)['id']\n params = self.corpus_create_params.copy()\n params.update({\n 'name': u'Corpus of Blackfoot sentences',\n 'form_search': rules_form_search_id\n })\n params = json.dumps(params)\n response = self.app.post(url('corpora'), params, self.json_headers, self.extra_environ_admin)\n rules_corpus_id = json.loads(response.body)['id']\n\n # Now we reduce the number of category-based word-formation rules by removing all such\n # rules implicit in the rules corpus that have fewer than two exemplar tokens.\n\n # Get the category sequence types of all of the words in the rules corpus ordered by their counts, minus\n # those with fewer than ``minimum_token_count`` counts.\n minimum_token_count = 2\n params = {'minimum_token_count': minimum_token_count}\n response = self.app.get(url(controller='corpora', action='get_word_category_sequences', id=rules_corpus_id),\n params, self.json_headers, self.extra_environ_admin)\n resp = json.loads(response.body)\n\n word_category_sequences = u' '.join([word_category_sequence for word_category_sequence, ids in resp])\n #word_category_sequences = u'agra-vai vai-agrb'\n\n # Now create a morphology using the lexicon and rules defined by word_category_sequences\n rich_upper = False\n name = u'Morphology of Blackfoot'\n params = self.morphology_create_params.copy()\n params.update({\n 'name': name,\n 'lexicon_corpus': lexicon_corpus_id,\n 'rules': word_category_sequences,\n 'script_type': u'lexc',\n 'extract_morphemes_from_rules_corpus': False,\n 'rich_upper': rich_upper\n })\n params = json.dumps(params)\n response = self.app.post(url('morphologies'), params, self.json_headers, self.extra_environ_admin_appset)\n resp = json.loads(response.body)\n morphology_id = resp['id']\n assert resp['name'] == name\n assert resp['script_type'] == u'lexc'\n\n # Generate the morphology's script without compiling it.\n response = self.app.put(url(controller='morphologies', action='generate',\n id=morphology_id), headers=self.json_headers,\n extra_environ=self.extra_environ_contrib)\n resp = json.loads(response.body)\n generate_attempt = resp['generate_attempt']\n\n # Poll ``GET /morphologies/morphology_id`` until ``generate_attempt`` has changed.\n seconds_elapsed = 0\n wait = 2\n while True:\n response = self.app.get(url('morphology', id=morphology_id),\n headers=self.json_headers, extra_environ=self.extra_environ_contrib)\n resp = json.loads(response.body)\n if generate_attempt != resp['generate_attempt']:\n log.debug('Generate attempt for morphology %d has terminated.' % morphology_id)\n break\n else:\n log.debug('Waiting for morphology %d\\'s script to generate: %s' % (\n morphology_id, self.human_readable_seconds(seconds_elapsed)))\n sleep(wait)\n seconds_elapsed = seconds_elapsed + wait\n\n ################################################################################\n # MORPHEME LANGUAGE MODEL\n ################################################################################\n\n # Create a morpheme language model\n name = u'Blackfoot morpheme language model'\n params = self.morpheme_language_model_create_params.copy()\n params.update({\n 'name': name,\n 'corpus': rules_corpus_id,\n 'toolkit': 'mitlm'\n })\n params = json.dumps(params)\n response = self.app.post(url('morphemelanguagemodels'), params, self.json_headers, self.extra_environ_admin)\n resp = json.loads(response.body)\n morpheme_language_model_id = resp['id']\n assert resp['name'] == name\n assert resp['toolkit'] == u'mitlm'\n assert resp['order'] == 3\n assert resp['smoothing'] == u'' # The ModKN smoothing algorithm is the implicit default with MITLM\n\n # Generate the files of the language model\n response = self.app.put(url(controller='morphemelanguagemodels', action='generate', id=morpheme_language_model_id),\n {}, self.json_headers, self.extra_environ_admin)\n resp = json.loads(response.body)\n lm_generate_attempt = resp['generate_attempt']\n\n # Poll GET /morphemelanguagemodels/id until generate_attempt changes.\n requester = lambda: self.app.get(url('morphemelanguagemodel', id=morpheme_language_model_id),\n headers=self.json_headers, extra_environ=self.extra_environ_admin)\n resp = self.poll(requester, 'generate_attempt', lm_generate_attempt, log, wait=1, vocal=False)\n assert resp['generate_message'] == u'Language model successfully generated.'\n\n ################################################################################\n # MORPHOLOGICAL PARSER\n ################################################################################\n\n # Create a morphological parser for Blackfoot\n params = self.morphological_parser_create_params.copy()\n params.update({\n 'name': u'Morphological parser for Blackfoot',\n 'phonology': phonology_id,\n 'morphology': morphology_id,\n 'language_model': morpheme_language_model_id\n })\n params = json.dumps(params)\n response = self.app.post(url('morphologicalparsers'), params, self.json_headers, self.extra_environ_admin)\n resp = json.loads(response.body)\n morphological_parser_id = resp['id']\n\n # Compile the morphological parser's morphophonology script if necessary, cf. precompiled_morphophonology and pregenerated_morphophonology.\n morphological_parser_directory = os.path.join(self.morphological_parsers_path, 'morphological_parser_%d' % morphological_parser_id)\n morphophonology_binary_filename = 'morphophonology.foma'\n morphophonology_script_filename = 'morphological_parser.script'\n morphophonology_binary_path = os.path.join(morphological_parser_directory, morphophonology_binary_filename )\n morphophonology_script_path = os.path.join(morphological_parser_directory, morphophonology_script_filename )\n try:\n precompiled_morphophonology_path = os.path.join(self.test_morphophonologies_path, precompiled_morphophonology)\n pregenerated_morphophonology_path = os.path.join(self.test_morphophonologies_path, pregenerated_morphophonology)\n except Exception:\n precompiled_morphophonology_path = None\n pregenerated_morphophonology_path = None\n if (precompiled_morphophonology_path and pregenerated_morphophonology_path and \n os.path.exists(precompiled_morphophonology_path) and os.path.exists(pregenerated_morphophonology_path)):\n # Use the precompiled morphophonology script if it's available,\n copyfileobj(open(precompiled_morphophonology_path, 'rb'), open(morphophonology_binary_path, 'wb'))\n copyfileobj(open(pregenerated_morphophonology_path, 'rb'), open(morphophonology_script_path, 'wb'))\n else:\n # Generate the parser's morphophonology FST, compile it and generate the morphemic language model\n response = self.app.put(url(controller='morphologicalparsers', action='generate_and_compile',\n id=morphological_parser_id), headers=self.json_headers, extra_environ=self.extra_environ_admin)\n resp = json.loads(response.body)\n morphological_parser_compile_attempt = resp['compile_attempt']\n\n # Generate the parser's morphophonology FST, compile it and generate the morphemic language model\n response = self.app.put(url(controller='morphologicalparsers', action='generate_and_compile',\n id=morphological_parser_id), headers=self.json_headers, extra_environ=self.extra_environ_admin)\n\n # Poll ``GET /morphologicalparsers/mophological_parser_id`` until ``compile_attempt`` has changed.\n requester = lambda: self.app.get(url('morphologicalparser', id=morphological_parser_id),\n headers=self.json_headers, extra_environ=self.extra_environ_admin)\n resp = self.poll(requester, 'compile_attempt', morphological_parser_compile_attempt, log,\n wait=10, vocal=True, task_descr='compile morphological parser %s' % morphological_parser_id)\n assert resp['compile_message'] == \\\n u'Compilation process terminated successfully and new binary file was written.'\n\n # Poll ``GET /morphologicalparsers/mophological_parser_id`` until ``compile_attempt`` has changed.\n requester = lambda: self.app.get(url('morphologicalparser', id=morphological_parser_id),\n headers=self.json_headers, extra_environ=self.extra_environ_admin)\n resp = self.poll(requester, 'compile_attempt', morphological_parser_compile_attempt, log,\n wait=10, vocal=True, task_descr='compile morphological parser %s' % morphological_parser_id)\n assert resp['compile_message'] == \\\n u'Compilation process terminated successfully and new binary file was written.'\n\n # Some reusable transcriptions and their parses\n transcription1 = u'nitsspiyi'\n transcription1_correct_parse = u'%s-%s' % (\n h.rare_delimiter.join([u'nit', u'1', u'agra']),\n h.rare_delimiter.join([u'ihpiyi', u'dance', u'vai']))\n transcription1_impoverished_parse = u'nit-ihpiyi'\n transcription2 = u'aaniit'\n transcription2_correct_parse = u'%s-%s' % (\n h.rare_delimiter.join([u'waanii', u'say', u'vai']),\n h.rare_delimiter.join([u't', u'IMP', u'agrb']))\n transcription2_impoverished_parse = u'waanii-t'\n\n # Test applyup on the mophological parser's morphophonology FST\n params = json.dumps({'transcriptions': [transcription1, transcription2]})\n response = self.app.put(url(controller='morphologicalparsers', action='applyup',\n id=morphological_parser_id), params, self.json_headers, self.extra_environ_admin)\n resp = json.loads(response.body)\n if rich_upper:\n assert transcription1_correct_parse in resp[transcription1]\n assert transcription2_correct_parse in resp[transcription2]\n else:\n assert transcription1_impoverished_parse in resp[transcription1]\n assert transcription2_impoverished_parse in resp[transcription2]\n\n # Test how well the morphological parser parses some test words.\n params = json.dumps({'transcriptions': [transcription1, transcription2]})\n response = self.app.put(url(controller='morphologicalparsers', action='parse',\n id=morphological_parser_id), params, self.json_headers, self.extra_environ_admin)\n resp = json.loads(response.body)\n assert resp[transcription1] == transcription1_correct_parse\n # aaniit will have waaniit 'scatter' as its most likely parse and the correct parse waanii-t 'say-IMP'\n # as its second most likely...\n assert resp[transcription2] != transcription2_correct_parse\n\n\n\n \"\"\"\n\n\n ################################################################################\n # LOUIE MORPHOLOGY\n ################################################################################\n\n # Create a form search that returns forms containing analyzed words elicited by Louie.\n\n conjuncts = [['or', [['Form', 'syntactic_category', 'name', '=', u'sent'],\n ['Form', 'morpheme_break', 'like', '% %'],\n ['Form', 'morpheme_break', 'like', '%-%']]],\n ['Form', 'syntactic_category_string', '!=', None],\n ['Form', 'grammaticality', '=', ''],\n ['Form', 'elicitor', 'last_name', '=', 'Louie']]\n query = {'filter': ['and', conjuncts]}\n\n params = self.form_search_create_params.copy()\n params.update({\n 'name': u'Forms containing analyzed words elicited by Louie',\n 'search': query\n })\n params = json.dumps(params)\n response = self.app.post(url('formsearches'), params, self.json_headers, self.extra_environ_admin)\n louie_form_search_id = json.loads(response.body)['id']\n\n params = self.corpus_create_params.copy()\n params.update({\n 'name': u'Corpus of forms containing analyzed words elicited by Louie',\n 'form_search': louie_form_search_id\n })\n params = json.dumps(params)\n response = self.app.post(url('corpora'), params, self.json_headers, self.extra_environ_admin)\n louie_corpus_id = json.loads(response.body)['id']\n\n # Now create a morphology using the Louie corpus as both the lexicon and rules corpora.\n rich_upper = False\n name = u'Morphology of Blackfoot based on words elicited by Louie'\n params = self.morphology_create_params.copy()\n params.update({\n 'name': name,\n 'lexicon_corpus': louie_corpus_id,\n 'rules_corpus': louie_corpus_id,\n 'script_type': u'regex',\n 'extract_morphemes_from_rules_corpus': True,\n 'rich_upper': rich_upper\n })\n params = json.dumps(params)\n response = self.app.post(url('morphologies'), params, self.json_headers, self.extra_environ_admin_appset)\n resp = json.loads(response.body)\n louie_morphology_id = resp['id']\n assert resp['name'] == name\n assert resp['script_type'] == u'regex'\n\n # Generate the morphology's script without compiling it.\n response = self.app.put(url(controller='morphologies', action='generate',\n id=louie_morphology_id), headers=self.json_headers,\n extra_environ=self.extra_environ_contrib)\n resp = json.loads(response.body)\n generate_attempt = resp['generate_attempt']\n\n # Poll ``GET /morphologies/morphology_id`` until ``generate_attempt`` has changed.\n seconds_elapsed = 0\n wait = 2\n while True:\n response = self.app.get(url('morphology', id=louie_morphology_id),\n headers=self.json_headers, extra_environ=self.extra_environ_contrib)\n resp = json.loads(response.body)\n if generate_attempt != resp['generate_attempt']:\n log.debug('Generate attempt for morphology %d has terminated.' % louie_morphology_id)\n break\n else:\n log.debug('Waiting for morphology %d\\'s script to generate: %s' % (\n louie_morphology_id, self.human_readable_seconds(seconds_elapsed)))\n sleep(wait)\n seconds_elapsed = seconds_elapsed + wait\n\n\n ################################################################################\n # MORPHEME LANGUAGE MODEL -- LOUIE\n ################################################################################\n\n # Create a morpheme language model based on the data elicited by Louie\n name = u'Blackfoot morpheme language model based on data elicited by Louie'\n params = self.morpheme_language_model_create_params.copy()\n params.update({\n 'name': name,\n 'corpus': louie_corpus_id,\n 'toolkit': 'mitlm'\n })\n params = json.dumps(params)\n response = self.app.post(url('morphemelanguagemodels'), params, self.json_headers, self.extra_environ_admin)\n resp = json.loads(response.body)\n louie_language_model_id = resp['id']\n assert resp['name'] == name\n assert resp['toolkit'] == u'mitlm'\n assert resp['order'] == 3\n assert resp['smoothing'] == u'' # The ModKN smoothing algorithm is the implicit default with MITLM\n\n # Generate the files of the language model\n response = self.app.put(url(controller='morphemelanguagemodels', action='generate',\n id=louie_language_model_id),\n {}, self.json_headers, self.extra_environ_admin)\n resp = json.loads(response.body)\n lm_generate_attempt = resp['generate_attempt']\n\n # Poll GET /morphemelanguagemodels/id until generate_attempt changes.\n requester = lambda: self.app.get(url('morphemelanguagemodel', id=louie_language_model_id),\n headers=self.json_headers, extra_environ=self.extra_environ_admin)\n resp = self.poll(requester, 'generate_attempt', lm_generate_attempt, log, wait=1, vocal=False)\n assert resp['generate_message'] == u'Language model successfully generated.'\n\n ################################################################################\n # MORPHOLOGICAL PARSER -- LOUIE\n ################################################################################\n\n # Create a morphological parser for Blackfoot based on data elicited by Louie\n params = self.morphological_parser_create_params.copy()\n params.update({\n 'name': u'Morphological parser for Blackfoot based on data elicited by Louie',\n 'phonology': phonology_id,\n 'morphology': louie_morphology_id,\n 'language_model': louie_language_model_id\n })\n params = json.dumps(params)\n response = self.app.post(url('morphologicalparsers'), params, self.json_headers,\n self.extra_environ_admin)\n resp = json.loads(response.body)\n louie_parser_id = resp['id']\n\n # Compile the morphological parser's morphophonology script if necessary, cf.\n # precompiled_morphophonology and pregenerated_morphophonology.\n morphological_parser_directory = os.path.join(self.morphological_parsers_path,\n 'morphological_parser_%d' % louie_parser_id)\n morphophonology_binary_filename = 'morphophonology.foma'\n morphophonology_script_filename = 'morphological_parser.script'\n morphophonology_binary_path = os.path.join(morphological_parser_directory,\n morphophonology_binary_filename )\n morphophonology_script_path = os.path.join(morphological_parser_directory,\n morphophonology_script_filename )\n try:\n precompiled_morphophonology_path = os.path.join(self.test_morphophonologies_path,\n precompiled_morphophonology)\n pregenerated_morphophonology_path = os.path.join(self.test_morphophonologies_path,\n pregenerated_morphophonology)\n except Exception:\n precompiled_morphophonology_path = None\n pregenerated_morphophonology_path = None\n if (precompiled_morphophonology_path and pregenerated_morphophonology_path and \n os.path.exists(precompiled_morphophonology_path) and os.path.exists(pregenerated_morphophonology_path)):\n # Use the precompiled morphophonology script if it's available,\n copyfileobj(open(precompiled_morphophonology_path, 'rb'), open(morphophonology_binary_path, 'wb'))\n copyfileobj(open(pregenerated_morphophonology_path, 'rb'), open(morphophonology_script_path, 'wb'))\n else:\n # Generate the parser's morphophonology FST, compile it and generate the morphemic language model\n response = self.app.put(url(controller='morphologicalparsers', action='generate_and_compile',\n id=louie_parser_id), headers=self.json_headers, extra_environ=self.extra_environ_admin)\n resp = json.loads(response.body)\n morphological_parser_compile_attempt = resp['compile_attempt']\n\n # Generate the parser's morphophonology FST, compile it and generate the morphemic language model\n response = self.app.put(url(controller='morphologicalparsers', action='generate_and_compile',\n id=louie_parser_id), headers=self.json_headers, extra_environ=self.extra_environ_admin)\n\n # Poll ``GET /morphologicalparsers/mophological_parser_id`` until ``compile_attempt`` has changed.\n requester = lambda: self.app.get(url('morphologicalparser', id=louie_parser_id),\n headers=self.json_headers, extra_environ=self.extra_environ_admin)\n resp = self.poll(requester, 'compile_attempt', morphological_parser_compile_attempt, log,\n wait=10, vocal=True, task_descr='compile morphological parser %s' % louie_parser_id)\n assert resp['compile_message'] == \\\n u'Compilation process terminated successfully and new binary file was written.'\n\n # Poll ``GET /morphologicalparsers/mophological_parser_id`` until ``compile_attempt`` has changed.\n requester = lambda: self.app.get(url('morphologicalparser', id=louie_parser_id),\n headers=self.json_headers, extra_environ=self.extra_environ_admin)\n resp = self.poll(requester, 'compile_attempt', morphological_parser_compile_attempt, log,\n wait=10, vocal=True, task_descr='compile morphological parser %s' % louie_parser_id)\n assert resp['compile_message'] == \\\n u'Compilation process terminated successfully and new binary file was written.'\n\n # Some reusable transcriptions and their parses\n transcription1 = u'nitsspiyi'\n transcription1_correct_parse = u'%s-%s' % (\n h.rare_delimiter.join([u'nit', u'1', u'agra']),\n h.rare_delimiter.join([u'ihpiyi', u'dance', u'vai']))\n transcription1_impoverished_parse = u'nit-ihpiyi'\n transcription2 = u'aaniit'\n transcription2_correct_parse = u'%s-%s' % (\n h.rare_delimiter.join([u'waanii', u'say', u'vai']),\n h.rare_delimiter.join([u't', u'IMP', u'agrb']))\n transcription2_impoverished_parse = u'waanii-t'\n\n # Test applyup on the mophological parser's morphophonology FST\n params = json.dumps({'transcriptions': [transcription1, transcription2]})\n response = self.app.put(url(controller='morphologicalparsers', action='applyup',\n id=louie_parser_id), params, self.json_headers, self.extra_environ_admin)\n resp = json.loads(response.body)\n if rich_upper:\n assert transcription1_correct_parse in resp[transcription1]\n assert transcription2_correct_parse not in resp[transcription2]\n else:\n assert transcription1_impoverished_parse in resp[transcription1]\n assert transcription2_impoverished_parse not in resp[transcription2]\n\n # Test how well the morphological parser parses some test words.\n params = json.dumps({'transcriptions': [transcription1, transcription2]})\n response = self.app.put(url(controller='morphologicalparsers', action='parse',\n id=louie_parser_id), params, self.json_headers, self.extra_environ_admin)\n resp = json.loads(response.body)\n assert resp[transcription1] == transcription1_correct_parse\n # aaniit will have waaniit 'scatter' as its most likely parse and the correct parse waanii-t 'say-IMP'\n # as its second most likely...\n assert resp[transcription2] != transcription2_correct_parse\n\n\n # Finally, load the original database back in so that subsequent tests can work.\n with open(tmp_script_path, 'w') as tmpscript:\n tmpscript.write('#!/bin/sh\\nmysql -u %s -p%s %s < %s' % (username, password, db_name, backup_dump_file_path))\n with open(os.devnull, \"w\") as fnull:\n call([tmp_script_path], stdout=fnull, stderr=fnull)\n os.remove(tmp_script_path)\n os.remove(backup_dump_file_path)\n\n # Implement category-based class LMs and test them against morpheme-based ones.\n # Build multiple Bf morphological parsers and test them out, find the best one, write a paper on it!","def _load_test_data(self):\n\n self.test_loader = data.Test_loader(self.N_max, self.n_per_conn,\n self.data_path, self.device)\n\n self.test_loader.load_data()\n\n # load mean and std from train\n scc_mean_std = np.loadtxt(\n os.path.join(self.data_path, 'scc_mean_std.csv'), delimiter=',')\n self.mean = torch.Tensor(scc_mean_std[0])\n self.std = torch.Tensor(scc_mean_std[1])","def test_income():\n test_path = tempfile.mkdtemp()\n x_train, metadata = income(test_path)\n try:\n assert x_train.shape == (44, 4)\n except:\n shutil.rmtree(test_path)\n raise()","def test_get_mnist_data(self):\n # TODO: Remove once get_mnist_data(...) is fixed.\n pass\n # mnist = get_mnist_data()\n # self.assertEqual(len(mnist.data), 60000)\n # self.assertEqual(len(mnist.labels), 60000)"],"string":"[\n \"def test_import_data():\\n\\n file_path = os.path.join(CONST_ADVANTICSYS_DIR, CONST_ADVANTICSYS_TEST_1)\\n\\n # Bring df\\n success, log, test_ingress_df = advanticsys_import(file_path)\\n assert success, log\\n assert isinstance(test_ingress_df, pd.DataFrame)\\n\\n # Test import function\\n success, log = import_data(\\n test_ingress_df,\\n CONST_ADVANTICSYS,\\n SQL_USER,\\n SQL_PASSWORD,\\n SQL_HOST,\\n SQL_PORT,\\n SQL_TEST_DBNAME\\n )\\n\\n assert success is True, log \\n assert log == \\\"New: 0 (uploaded); Duplicates: 75 (ignored)\\\"\",\n \"def fixture_example_data():\\n import_example_data()\",\n \"def test_dataset_from_file(train_dataset):\\n dummy = \\\"justo. Praesent luctus. Curabitur egestas nunc sed libero. Proin sed\\\"\\n assert train_dataset[0][0] == dummy\\n assert train_dataset[0][1] == '6'\",\n \"def test_load_dataset():\\n\\n # Given\\n dataset_file_name = core.config.app_config.TESTING_DATA_FILE\\n\\n # When\\n subject = utils.load_dataset(filename=dataset_file_name)\\n\\n # Then\\n assert isinstance(subject, pd.DataFrame)\\n assert subject.shape == (5940, 41)\",\n \"def test_loadData():\\n \\n sys = LVsystem.Ecosystem()\\n \\n sys.loadSetup('2Prey1Predator')\\n \\n \\n data = sys.create_data()\\n \\n assert data[0] == 3\\n assert data[1] == ['rabbit', 'hen', 'fox']\\n assert data[2] == [30,10,20]\\n assert data[3] == [0.09,0.07,-0.06] \\n assert data[4] == [10000,10000,1]\\n assert data[5] == [400,500,250]\\n assert data[6][1][2] == -data[6][2][1]\\n assert data[6][2][2] == 0\\n\\n sys.removeSpecies('rabbit')\\n sys.removeSpecies('fox')\\n sys.removeSpecies('hen')\",\n \"def test_import(self):\\n\\n database.delete_database()\\n\\n #Fully successful import\\n actual_tuples1 = database.import_data('csvs', 'product_data.csv', 'customer_data.csv',\\n 'rentals_data.csv')\\n expected_tuples1 = ((1, 1, 1), (0, 0, 0))\\n self.assertEqual(actual_tuples1, expected_tuples1)\\n database.delete_database()\\n\\n #Partially successful import with failed product_data\\n actual_tuples2 = database.import_data('csvs', 'produc_data.csv', 'customer_data.csv',\\n 'rentals_data.csv')\\n expected_tuples2 = ((0, 1, 1), (1, 0, 0))\\n self.assertEqual(actual_tuples2, expected_tuples2)\\n database.delete_database()\\n\\n #Partially successful import with failed customer_data\\n actual_tuples3 = database.import_data('csvs', 'product_data.csv', 'custome_data.csv',\\n 'rentals_data.csv')\\n expected_tuples3 = ((1, 0, 1), (0, 1, 0))\\n self.assertEqual(actual_tuples3, expected_tuples3)\\n database.delete_database()\\n\\n #Partially successful import with failed rentals_data\\n actual_tuples4 = database.import_data('csvs', 'product_data.csv', 'customer_data.csv',\\n 'rental_data.csv')\\n expected_tuples4 = ((1, 1, 0), (0, 0, 1))\\n self.assertEqual(actual_tuples4, expected_tuples4)\\n database.delete_database()\",\n \"def importData():\\n #importChallengeDataToDB()\\n importTrendingDataToDB()\",\n \"def test_import(self):\\n\\n DropDataUnitTesting.drop_data()\\n tup1 = ()\\n tup2 = ()\\n results = []\\n try:\\n current_dir = os.getcwd()\\n directory_name = current_dir + '\\\\\\\\lesson5\\\\\\\\data\\\\\\\\'\\n file_name_dict = {'products': 'products.csv', 'customers': 'customers.csv',\\n 'rentals': 'rentals.csv'}\\n for key, value in file_name_dict.items():\\n tmp_file = directory_name + value\\n mongo_insert = mdb.ImportData(key, tmp_file)\\n results = mongo_insert.import_data()\\n tup1 = results[0]\\n tup2 = results[1]\\n except FileNotFoundError as e:\\n logger.error('exception %s', e, exc_info=True)\\n result = 'exception {}'.format(e)\\n print(result)\\n print(results)\\n print(tup1, tup2)\\n # assert the correct number of items were added\\n self.assertEqual(tup1[0], 'customers: 10, ')\\n self.assertEqual(tup1[1], 'products: 10, ')\\n self.assertEqual(tup1[2], 'rentals: 10, ')\\n # check no errors occurred during addition\\n self.assertEqual(tup2[0], 0)\\n DropDataUnitTesting.drop_data()\",\n \"def test_import(import_data):\\n try:\\n df_tab = import_data()\\n logging.info(\\\"Testing import_data: Successfully Found File\\\")\\n except FileNotFoundError as err:\\n logging.error(\\\"Testing import_data: The file wasn't found\\\")\\n raise err\\n\\n try:\\n assert df_tab.shape[0] > 0\\n assert df_tab.shape[1] > 0\\n logging.info(\\\"Testing import_data: Successfully Available Data\\\")\\n except AssertionError as err:\\n logging.error(\\n \\\"Testing import_data: The file doesn't appear to have rows and columns\\\"\\n )\\n raise err\\n\\n return df_tab\",\n \"def test_full_dataset_from_file(full_dataset):\\n train_dummy = \\\"justo. Praesent luctus. Curabitur egestas nunc sed libero. Proin sed\\\"\\n val_dummy = \\\"malesuada. Integer id magna et ipsum cursus vestibulum. Mauris magna.\\\"\\n\\n assert full_dataset.train[0][0] == train_dummy\\n assert full_dataset.train[0][1] == '6'\\n\\n assert full_dataset.val[0][0] == val_dummy\\n assert full_dataset.val[0][1] == '8'\\n\\n assert full_dataset[0][0] == train_dummy\\n assert full_dataset[100][0] == val_dummy\",\n \"def test_data_set_load(data_set):\\n data = data_set()\\n train_data, train_labels, test_data, test_labels = data.load_data()\\n\\n assert len(train_data) > 0\\n assert len(test_data) > 0\\n assert len(train_data) == len(train_labels)\\n assert len(test_data) == len(test_labels)\",\n \"def test_make_dataset_happy_path(self):\\n # User story: user runs src.make_dataset() on the current directory\\n # and gets a fully functional dataset\\n pass\",\n \"def test_load_data(self):\\n assert len(self._mnist.get()) == 10\\n assert self._mnist.get()[0].label == 7\\n pass\",\n \"def test_multiple_import(self):\\n # Currently, there are no PowerPlant or Project objects in the database\\n self.assertEqual(PowerPlant.objects.count(), 0)\\n self.assertEqual(Project.objects.count(), 0)\\n # There are no InfrastructureType objects in the database\\n self.assertEqual(InfrastructureType.objects.count(), 0)\\n # There are no Fuel or FuelCategory objects in the database\\n self.assertEqual(Fuel.objects.count(), 0)\\n self.assertEqual(FuelCategory.objects.count(), 0)\\n # There are no Countries or Regions in the database\\n self.assertEqual(Country.objects.count(), 0)\\n self.assertEqual(Region.objects.count(), 0)\\n # There are no OwnerStakes in the database\\n self.assertEqual(PlantOwnerStake.objects.count(), 0)\\n # There are no Initiatives in the database\\n self.assertEqual(Initiative.objects.count(), 0)\\n # There are no ProjectFunding objects in the database\\n self.assertEqual(ProjectFunding.objects.count(), 0)\\n\\n # Run the import\\n self.call_command(filename='power_plant_import/tests/data/six_rows.csv')\\n\\n # The file has 3 'Plant' rows and 3 'Project' rows, but the project_liaoning\\n # also gets a parent PowerPlant created for it\\n self.assertEqual(PowerPlant.objects.count(), 4)\\n self.assertEqual(Project.objects.count(), 3)\\n # There is now 1 InfrastructureType object in the database\\n self.assertEqual(InfrastructureType.objects.count(), 1)\\n # There are now 4 Fuel and 3 FuelCategory objects in the database\\n self.assertEqual(Fuel.objects.count(), 4)\\n self.assertEqual(FuelCategory.objects.count(), 3)\\n # There are now 4 Countries and 3 Regions in the database\\n self.assertEqual(Country.objects.count(), 4)\\n self.assertEqual(Region.objects.count(), 3)\\n # There are now 4 OwnerStakes in the database\\n self.assertEqual(PlantOwnerStake.objects.count(), 4)\\n # There is now Initiative in the database\\n self.assertEqual(Initiative.objects.count(), 1)\\n # There are now 3 ProjectFunding objects in the database\\n self.assertEqual(ProjectFunding.objects.count(), 3)\\n\\n # Run the import again\\n self.call_command(filename='power_plant_import/tests/data/six_rows.csv')\\n\\n # There are still 4 PowerPlant and 3 Project objects in the database\\n self.assertEqual(PowerPlant.objects.count(), 4)\\n self.assertEqual(Project.objects.count(), 3)\\n # There is still 1 InfrastructureType object in the database\\n self.assertEqual(InfrastructureType.objects.count(), 1)\\n # There are still 4 Fuel and 3 FuelCategory objects in the database\\n self.assertEqual(Fuel.objects.count(), 4)\\n self.assertEqual(FuelCategory.objects.count(), 3)\\n # There are still 4 Countries and 3 Regions in the database\\n self.assertEqual(Country.objects.count(), 4)\\n self.assertEqual(Region.objects.count(), 3)\\n # There are still 4 OwnerStakes in the database\\n self.assertEqual(PlantOwnerStake.objects.count(), 4)\\n # There is still Initiative in the database\\n self.assertEqual(Initiative.objects.count(), 1)\\n # There are still 3 ProjectFunding objects in the database\\n self.assertEqual(ProjectFunding.objects.count(), 3)\",\n \"def _load_test_data(self):\\n self._save_test_data()\",\n \"def setUp(self):\\n self.dataset = get_test_dataset()\",\n \"def test_large_import(self):\\n self.create_sample_data_set_dir(\\\"node59p1.dat\\\", TELEM_DIR)\\n self.assert_initialize()\\n result = self.data_subscribers.get_samples(DataParticleType.METADATA_TELEMETERED,1,60)\\n result = self.data_subscribers.get_samples(DataParticleType.SAMPLE_TELEMETERED,750,400)\",\n \"def test_load_UCR_UEA_dataset():\\n X, y = load_UCR_UEA_dataset(name=\\\"UnitTest\\\")\\n assert isinstance(X, pd.DataFrame) and isinstance(y, np.ndarray)\\n assert X.shape == (42, 1) and y.shape == (42,)\",\n \"def test_import(self):\\n self.assertTrue(NagiosPerfdataCollector)\",\n \"def import_test():\\n if os.path.exists(\\\"test.csv\\\"):\\n #print (\\\"--testing data imported to data frame\\\\n\\\")\\n test_df = pd.read_csv(\\\"test.csv\\\", index_col=0)\\n else:\\n print(\\\"training CSV not found\\\")\\n exit()\\n \\n return test_df\",\n \"def test_002_load_data(self):\\n __test = chess_storage.ChessStorage()\\n __test_filename = consts.TEST_FILENAME\\n __test_data = list(range(consts.TEST_LIST_LENGHT))\\n __load_test = __test.load_data(consts.TEST_NOTEXISTFILE)\\n self.assertEqual(__load_test, consts.ERROR_CODES[\\\"NO_FILE_EXIST\\\"])\\n __load_test = __test.load_data(__test_filename)\\n self.assertEqual(__load_test, __test_data)\",\n \"def load_data(self):\\n with open('data/fordTrain.csv') as f:\\n data = csv.reader(f, delimiter=',')\\n train = [x for i, x in enumerate(data) if i > 0] \\n # Extract features and target variable separately\\n trainx = [x[3:] for x in train]\\n trainy = [x[2] for x in train]\\n\\n with open('data/fordTest.csv') as f:\\n data = csv.reader(f, delimiter=',')\\n testx = [x[3:] for i, x in enumerate(data) if i > 0] \\n\\n with open('data/Solution.csv') as f:\\n data = csv.reader(f, delimiter=',')\\n testy = [x[2] for i, x in enumerate(data) if i > 0] \\n\\n # Extract features and target variable, convert to numpy array\\n trainx = np.asarray(trainx, dtype=np.float32)\\n trainy = np.asarray(trainy, dtype=np.int8)\\n testx = np.asarray(testx, dtype=np.float32)\\n testy = np.asarray(testy, dtype=np.int8)\\n\\n # Return training and test sets\\n trainSet = Dataset(trainx, trainy)\\n testSet = Dataset(testx, testy)\\n return trainSet, testSet\",\n \"def test_import_data_handler(self):\\n\\n # create new unittest data\\n # unittest_result = ImportUnitTestData.import_data_handler()\\n # test_result = main.import_data_handler()\\n # print(test_result)\\n # print(unittest_result)\\n # self.assertEqual(test_result, unittest_result )\",\n \"def test_missing_data_sources(self):\",\n \"def load_examples_data(dataset_name):\\n dataset_name = dataset_name.strip().lower()\\n if dataset_name.lower() not in ['pokemon', 'hanzi', 'animals', 'nsfw', 'simpsons', 'horse2zebra', 'people',\\n 'autodrive', 'superresolution', 'anpr', 'beauty','antisproofing','facelandmarks','dogs-vs-cats','chinese']:\\n raise ValueError('Not a valid dataset_name.')\\n dataset_name = 'examples_' + dataset_name\\n dirname = os.path.join(_trident_dir, dataset_name)\\n if not os.path.exists(dirname):\\n try:\\n os.makedirs(dirname)\\n except OSError:\\n # Except permission denied and potential race conditions\\n # in multi-threaded environments.\\n pass\\n is_internet_ok = is_connected()\\n if dataset_name == 'examples_pokemon':\\n is_download=download_file_from_google_drive('1U-xc54fX9j9BcidvRa0ow6qjssMlSF2A', dirname, 'pokemon.tar')\\n tar_file_path = os.path.join(dirname, 'pokemon.tar')\\n extract_archive(tar_file_path, dirname, archive_format='tar')\\n extract_path = os.path.join(dirname, 'pokemon')\\n dataset = load_folder_images(dataset_name, extract_path, folder_as_label=False)\\n print('get pokemon images :{0}'.format(len(dataset)))\\n return dataset\\n\\n\\n elif dataset_name == 'examples_hanzi':\\n download_file_from_google_drive('13UEzSG0az113gpRPKPyKrIE2HDaA2P4H', dirname, 'hanzi.tar')\\n tar_file_path = os.path.join(dirname, 'hanzi.tar')\\n extract_path = os.path.join(dirname, 'hanzi')\\n extract_archive(tar_file_path, dirname, archive_format='tar')\\n dataset = load_folder_images(dataset_name, os.path.join(dirname, 'train'), folder_as_label=True,\\n object_type=ObjectType.gray)\\n\\n dataset_test = load_folder_images(dataset_name, os.path.join(dirname, 'test'), folder_as_label=True,\\n object_type=ObjectType.gray)\\n\\n dataset.testdata = dataset_test.traindata\\n dataset.class_names['zh-cn'] = dataset.class_names['en-us']\\n return dataset\\n\\n elif dataset_name == 'examples_animals':\\n download_file_from_google_drive('19Cjq8OO6qd9k9TMZxlPjDpejDOdiHJoW', dirname, 'animals.tar')\\n tar_file_path = os.path.join(dirname, 'animals.tar')\\n extract_archive(tar_file_path, dirname, archive_format='tar')\\n dataset = load_folder_images(dataset_name, dirname, folder_as_label=True)\\n return dataset\\n elif dataset_name == 'examples_nsfw':\\n tar_file_path = os.path.join(dirname, 'nsfw.tar')\\n if os.path.exists(tar_file_path) and get_file_create_time(tar_file_path)<datetime.datetime(2021, 2, 20, 0, 0, 0).timestamp():\\n os.remove(tar_file_path)\\n if os.path.exists(os.path.join(dirname,'porn_detection_data.pkl')):\\n os.remove(os.path.join(dirname,'porn_detection_data.pkl'))\\n _delete_h(dirname)\\n download_file_from_google_drive('1EXpV2QUrSFJ7zJn8NqtqFl1k6HvXsUzp', dirname, 'nsfw.tar')\\n\\n extract_path = os.path.join(dirname, 'nsfw')\\n extract_archive(tar_file_path, dirname, archive_format='tar')\\n folders = ['drawings', 'hentai', 'neutral', 'porn', 'sexy']\\n data=unpickle(os.path.join(dirname,'porn_detection_data.pkl'))\\n\\n trainData = []\\n testData = []\\n trainLabel = []\\n testLabel = []\\n for n in range(5):\\n folder=folders[n]\\n trainData.extend(data[folder]['train'])\\n trainLabel.extend([n]*len(data[folder]['train']))\\n testData.extend(data[folder]['test'])\\n testLabel.extend([n] * len(data[folder]['test']))\\n\\n trainarray = ImageDataset(trainData,object_type=ObjectType.rgb)\\n trainlabel = LabelDataset(trainLabel,object_type=ObjectType.classification_label)\\n train_iter = Iterator(data=trainarray, label=trainlabel)\\n\\n testarray = ImageDataset(testData,object_type=ObjectType.rgb)\\n testlabel = LabelDataset(testLabel,object_type=ObjectType.classification_label)\\n test_iter = Iterator(data=testarray, label=testlabel)\\n print('training images: {0} test images:{1}'.format(len(trainarray), len(testarray)))\\n\\n dataset = DataProvider(dataset_name, traindata=train_iter, testdata=test_iter)\\n dataset.binding_class_names(['drawing', 'hentai', 'neutral', 'porn', 'sexy'], 'en-us')\\n dataset.binding_class_names(['绘画', '色情漫画', '中性', '色情', '性感'], 'zh-cn')\\n dataset.binding_class_names(['繪畫', '色情漫畫', '中性', '色情', '性感'], 'zh-tw')\\n dataset.scenario = 'train'\\n return dataset\\n elif dataset_name == 'examples_simpsons':\\n download_file_from_google_drive('1hGNFbfBv3EZ4nx4Qod6PtSYzO8H4QIxC', dirname, 'simpsons.tar')\\n tar_file_path = os.path.join(dirname, 'simpsons.tar')\\n extract_path = os.path.join(dirname, 'simpsons')\\n extract_archive(tar_file_path, extract_path, archive_format='tar')\\n data_provider = load_folder_images(dataset_name, extract_path, folder_as_label=False)\\n data_provider.traindata.unpair = RandomNoiseDataset(shape=(100), random_mode='normal')\\n print('get simpsons images :{0}'.format(len(data_provider.traindata.data.items)))\\n return data_provider\\n elif dataset_name == 'examples_horse2zebra':\\n download_file_from_google_drive('1pqj-T90Vh4wVNBV09kYZWgVPsZUA2f7U', dirname, 'horse2zebra.tar')\\n tar_file_path = os.path.join(dirname, 'horse2zebra.tar')\\n extract_path = os.path.join(dirname, 'horse2zebra')\\n extract_archive(tar_file_path, dirname, archive_format='tar')\\n trainA = ImageDataset(list_images(os.path.join(dirname, 'trainA')), object_type=ObjectType.rgb,\\n get_image_mode=GetImageMode.processed)\\n trainB = ImageDataset(list_images(os.path.join(dirname, 'trainB')), object_type=ObjectType.rgb,\\n get_image_mode=GetImageMode.processed)\\n testA = ImageDataset(list_images(os.path.join(dirname, 'testA')), object_type=ObjectType.rgb,\\n get_image_mode=GetImageMode.processed)\\n testB = ImageDataset(list_images(os.path.join(dirname, 'testB')), object_type=ObjectType.rgb,\\n get_image_mode=GetImageMode.processed)\\n train_iter = Iterator(data=trainA, unpair=trainB)\\n test_iter = Iterator(data=testA, unpair=testB)\\n dataset = DataProvider(dataset_name, traindata=train_iter, testdata=test_iter)\\n print('get horse2zebra images :{0}'.format(len(dataset)))\\n return dataset\\n elif dataset_name == 'examples_people':\\n download_file_from_google_drive('1H7mJJfWpmXpRxurMZQqY4N_UXWLbQ2pT', dirname, 'people.tar')\\n tar_file_path = os.path.join(dirname, 'people.tar')\\n extract_archive(tar_file_path, dirname, archive_format='tar')\\n imgs = glob.glob(os.path.join(dirname, 'imgs', '*.*g'))\\n masks = glob.glob(os.path.join(dirname, 'masks', '*.png'))\\n imgs=list(sorted(imgs))\\n masks = list(sorted(masks))\\n # make_dir_if_need(os.path.join(dirname, 'trimap'))\\n # for i in range(len(masks)):\\n # mask=mask2array(masks[i])\\n # trimap=mask2trimap(mask)\\n # save_mask(trimap,masks[i].replace('masks','trimap'))\\n # print('trimap',len(masks))\\n\\n imgdata = ImageDataset(images=imgs, object_type=ObjectType.rgb)\\n mskdata = MaskDataset(masks=masks, object_type=ObjectType.binary_mask)\\n dataset = DataProvider(dataset_name=dataset_name, traindata=Iterator(data=imgdata, label=mskdata))\\n print('get people images :{0}'.format(len(dataset)))\\n return dataset\\n elif dataset_name == 'examples_autodrive':\\n download_file_from_google_drive('1JqPPeHqhWLqnI6bD8nuHcVx-Y56oIZMK', dirname, 'autodrive.tar')\\n tar_file_path = os.path.join(dirname, 'autodrive.tar')\\n extract_path = os.path.join(dirname, 'autodrive')\\n extract_archive(tar_file_path, dirname, archive_format='tar')\\n imgs = glob.glob(os.path.join(dirname, 'images', '*.*g'))\\n masks = glob.glob(os.path.join(dirname, 'masks', '*.png'))\\n imgs = list(sorted(imgs))\\n masks = list(sorted(masks))\\n imgdata = ImageDataset(images=imgs, object_type=ObjectType.rgb,symbol='image')\\n mskdata = MaskDataset(masks=masks, object_type=ObjectType.color_mask,symbol='mask')\\n\\n def parse_code(l):\\n if len(l.strip().split(\\\"\\\\t\\\")) == 2:\\n a, b = l.replace('\\\\t\\\\t', '\\\\t').strip().split(\\\"\\\\t\\\")\\n return tuple(int(i) for i in b.split(' ')), a\\n\\n label_codes, label_names = zip(\\n *[parse_code(l) for l in open(os.path.join(dirname, \\\"label_colors.txt\\\")).readlines()])\\n for i in range(len(label_codes)):\\n mskdata.palette[label_names[i]] = label_codes[i]\\n\\n dataset = DataProvider(dataset_name=dataset_name, traindata=Iterator(data=imgdata, label=mskdata))\\n print('get autodrive images :{0}'.format(len(dataset)))\\n return dataset\\n elif dataset_name == 'examples_superresolution':\\n download_file_from_google_drive('1v1uoymrWI_MLSiGvSGW7tWJYSnzzXpEQ', dirname, 'superresolution.tar')\\n tar_file_path = os.path.join(dirname, 'superresolution.tar')\\n extract_archive(tar_file_path, dirname, archive_format='tar')\\n imgs = glob.glob(os.path.join(dirname, '*.*g'))\\n imgs.extend(glob.glob(os.path.join(dirname, '*.bmp')))\\n imgs = list(sorted(imgs))\\n\\n print('get super resolution images :{0}'.format(len(imgs)))\\n\\n imgdata = ImageDataset(images=imgs * 2, object_type=ObjectType.rgb, symbol='lr')\\n labeldata = ImageDataset(images=imgs * 2, object_type=ObjectType.rgb, symbol='hr')\\n dataset = DataProvider(dataset_name=dataset_name, traindata=Iterator(data=imgdata, label=labeldata))\\n return dataset\\n elif dataset_name == 'examples_beauty':\\n download_file_from_google_drive('1aJhxN9IqsxuayhRTm-gmxk6PiLe5wm9X', dirname, 'beauty.tar')\\n tar_file_path = os.path.join(dirname, 'beauty.tar')\\n\\n extract_archive(tar_file_path, dirname, archive_format='tar')\\n # 讀取圖片數據\\n images_dict = {}\\n with open(os.path.join(dirname, 'images_dict.pkl'), 'rb') as fp:\\n images_dict = pickle.load(fp)\\n\\n f = open(os.path.join(dirname, 'All_Ratings.txt'), encoding='utf-8-sig').readlines()\\n imgs = []\\n landmarks = []\\n ratings = []\\n for row in f:\\n data = row.strip().split('\\\\t')\\n if 'images\\\\\\\\' + data[0] in images_dict:\\n img = images_dict['images\\\\\\\\' + data[0]][0]\\n img = img.transpose([2, 0, 1])[::-1].transpose([1, 2, 0])\\n imgs.append(img)\\n landmark = images_dict['images\\\\\\\\' + data[0]][1].astype(np.float32)\\n landmarks.append(landmark)\\n rating = (float(data[1])) / 5.00\\n ratings.append(rating)\\n print('{0} faces loaded...'.format(len(imgs)))\\n imgdata = ImageDataset(images=imgs, object_type=ObjectType.rgb, symbol='faces')\\n landmarkdata = LandmarkDataset(landmarks=landmarks, object_type=ObjectType.landmarks, symbol='target_landmarks')\\n labeldata = LabelDataset(data=ratings,object_type=ObjectType.classification_label, symbol='target_beauty')\\n data_provider = DataProvider(dataset_name=dataset_name, traindata=Iterator(data=imgdata, label=Dataset.zip(landmarkdata,labeldata)))\\n return data_provider\\n\\n elif dataset_name == 'examples_facelandmarks':\\n download_file_from_google_drive('1GtswQBAHPa_bXaB4tW2uOOQ8Lxfz2L5B', dirname, 'ibug_300W.tar')\\n tar_file_path = os.path.join(dirname, 'ibug_300W.tar')\\n extract_archive(tar_file_path, dirname, archive_format='tar')\\n root_dir=os.path.join(dirname, 'ibug_300W_large_face_landmark_dataset')\\n image_paths = {}\\n landmarks = {}\\n crops = {}\\n\\n for mode in ['train','test']:\\n make_dir_if_need(os.path.join(dirname, 'crops',mode))\\n tree = ElementTree.parse(os.path.join(root_dir, 'labels_ibug_300W_{0}.xml'.format(mode)))\\n root = tree.getroot()\\n image_paths[mode]=[]\\n landmarks[mode] = []\\n crops[mode] = []\\n\\n offset=5\\n for j in tqdm(range(len(root[2]))):\\n try:\\n filename=root[2][j]\\n landmark = []\\n for num in range(68):\\n x_coordinate = int(filename[0][num].attrib['x'])\\n y_coordinate = int(filename[0][num].attrib['y'])\\n landmark.append([x_coordinate, y_coordinate])\\n landmark=np.asarray(landmark)\\n\\n crop = filename[0].attrib\\n for k in crop.keys():\\n crop[k] = int(crop[k]) if isinstance(crop[k], str) else crop[k]\\n for k in crop.keys():\\n if k=='top' and int(landmark[:,1].min())<int(crop[k]):\\n crop[k] = int( landmark[:,1].min())\\n crop[ 'height']+=crop[k]-int(landmark[:,1].min())\\n elif k=='left' and int(landmark[:,0].min())<int(crop[k]):\\n crop[k] = int( landmark[:,0].min())\\n crop['width']+= crop[k] - int(landmark[:, 0].min())\\n elif k == 'width' and int(landmark[:, 0].max()-landmark[:, 0].min()) > int(crop[k]):\\n crop[k] = int(landmark[:, 0].max()-landmark[:, 0].min())\\n elif k == 'height' and int(landmark[:, 1].max()-landmark[:, 1].min()) > int(crop[k]):\\n crop[k] = int(landmark[:, 1].max()-landmark[:, 1].min())\\n\\n crop['left']-=offset\\n crop['top'] -= offset\\n crop['width'] += 2*offset\\n crop['height'] += 2*offset\\n\\n\\n landmark[:,0]-=crop['left']\\n landmark[:, 1] -= crop['top']\\n\\n\\n if not os.path.exists(os.path.join(dirname, 'crops', mode, '{0}.png'.format(j))):\\n im=image2array(os.path.join(root_dir, filename.attrib['file']))\\n if im.ndim==2:\\n im=cv2.cvtColor(im,cv2.COLOR_GRAY2RGB)\\n im=im[crop['top']:min(crop['top']+crop['height'],im.shape[0]),crop['left']:min(crop['left']+crop['width'],im.shape[1]),:]\\n\\n if max(im.shape[:2])/max(min(im.shape[:2]),0)<=5:\\n\\n array2image(im).save(os.path.join(dirname, 'crops',mode,'{0}.png'.format(j)))\\n image_paths[mode].append(os.path.join(dirname, 'crops', mode, '{0}.png'.format(j)))\\n crops[mode].append(crop)\\n landmarks[mode].append(landmark)\\n del im\\n else:\\n #im = image2array(os.path.join(dirname, 'crops',mode,'{0}.png'.format(j)))\\n image_paths[mode].append(os.path.join(dirname, 'crops',mode,'{0}.png'.format(j)))\\n crops[mode].append(crop)\\n landmarks[mode].append(landmark)\\n\\n if j%100==0:\\n gc.collect()\\n except Exception as e:\\n pass\\n\\n print('ibug 300w train dataset: images: {0} landmarks:{1} \\\\n'.format(len(image_paths['train']),len(landmarks['train'])))\\n print('ibug 300w test dataset: images: {0} landmarks:{1} \\\\n'.format(len(image_paths['test']), len(landmarks['test'])))\\n imdata=ImageDataset(images=image_paths['train'],symbol='faces',object_type=ObjectType.rgb)\\n landmarkdata = LandmarkDataset(landmarks=landmarks['train'], symbol='landmarks',object_type=ObjectType.landmarks)\\n imtestdata = ImageDataset(images=image_paths['test'], symbol='faces',object_type=ObjectType.rgb)\\n landmarktestdata = LandmarkDataset(landmarks=landmarks['test'], symbol='landmarks',object_type=ObjectType.landmarks)\\n data_provider=DataProvider(traindata=Iterator(data=imdata,label=landmarkdata),testdata=Iterator(data=imtestdata,label=landmarktestdata))\\n return data_provider\\n\\n elif dataset_name == 'examples_antisproofing':\\n download_file_from_google_drive('1e7Zjn2MHNCvA5gXdJUECzY8NjK4KVpa7', dirname, 'antisproofing.tar')\\n tar_file_path = os.path.join(dirname, 'antisproofing.tar')\\n make_dir_if_need(os.path.join(dirname, 'antisproofing'))\\n extract_archive(tar_file_path, dirname, archive_format='tar')\\n data_provider = load_folder_images(dataset_name,os.path.join(dirname, 'antisproofing'))\\n return data_provider\\n elif dataset_name == 'examples_anpr':\\n download_file_from_google_drive('1uGBd8tXlP0TZAXNgrR6H0jl5MXj7VPbN', dirname, 'anpr.tar')\\n tar_file_path = os.path.join(dirname, 'anpr.tar')\\n extract_archive(tar_file_path, dirname, archive_format='tar')\\n imgs = glob.glob(os.path.join(dirname, '*.*g'))\\n imgs = list(sorted(imgs))\\n\\n # CCPD (Chinese City Parking Dataset, ECCV) and PDRC (license Plate Detection and Recognition Challenge)\\n # https://github.com/detectRecog/CCPD\\n provinces = [\\\"皖\\\", \\\"沪\\\", \\\"津\\\", \\\"渝\\\", \\\"冀\\\", \\\"晋\\\", \\\"蒙\\\", \\\"辽\\\", \\\"吉\\\", \\\"黑\\\", \\\"苏\\\", \\\"浙\\\", \\\"京\\\", \\\"闽\\\", \\\"赣\\\", \\\"鲁\\\", \\\"豫\\\", \\\"鄂\\\", \\\"湘\\\", \\\"粤\\\",\\n \\\"桂\\\", \\\"琼\\\", \\\"川\\\", \\\"贵\\\", \\\"云\\\", \\\"藏\\\", \\\"陕\\\", \\\"甘\\\", \\\"青\\\", \\\"宁\\\", \\\"新\\\", \\\"警\\\", \\\"学\\\", \\\"O\\\"]\\n alphabets = ['A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'J', 'K', 'L', 'M', 'N', 'P', 'Q', 'R', 'S', 'T', 'U', 'V',\\n 'W', 'X', 'Y', 'Z', 'O']\\n ads = ['A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'J', 'K', 'L', 'M', 'N', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W',\\n 'X', 'Y', 'Z', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'O']\\n\\n def lp2char(lp):\\n cols = lp.split('_')\\n charstring = ''\\n for i in range(len(cols)):\\n if i == 0:\\n charstring += provinces[int(cols[i])]\\n elif i == 1:\\n charstring += alphabets[int(cols[i])]\\n else:\\n charstring += ads[int(cols[i])]\\n return charstring\\n\\n width = 720\\n height = 1160\\n for im_path in imgs:\\n lbl = im_path.split('/')[-1].rsplit('.', 1)[0].split('-')[-3]\\n charstring = lp2char(lbl)\\n iname = im_path.rsplit('/', 1)[-1].rsplit('.', 1)[0].split('-')\\n [leftUp, rightDown] = [[int(eel) for eel in el.split('&')] for el in iname[2].split('_')]\\n box = [leftUp[0], leftUp[1], rightDown[0], rightDown[1]]\\n ori_w, ori_h = [float(int(el)) for el in [width, height]]\\n new_labels = [(leftUp[0] + rightDown[0]) / (2 * ori_w), (leftUp[1] + rightDown[1]) / (2 * ori_h),\\n (rightDown[0] - leftUp[0]) / ori_w, (rightDown[1] - leftUp[1]) / ori_h]\\n download_file_from_google_drive('1e7Zjn2MHNCvA5gXdJUECzY8NjK4KVpa7', dirname, 'antisproofing.tar')\\n tar_file_path = os.path.join(dirname, 'antisproofing.tar')\\n make_dir_if_need(os.path.join(dirname, 'antisproofing'))\\n extract_archive(tar_file_path, dirname, archive_format='tar')\\n data_provider = load_folder_images(dataset_name, os.path.join(dirname, 'antisproofing'))\\n return data_provider\\n\\n\\n\\n elif dataset_name == 'examples_dogs-vs-cats':\\n download_file_from_google_drive('10czW0On7eIXkPP-MuQ-IRxMWdTizWjNC', dirname, 'dogs-vs-cats.tar')\\n tar_file_path = os.path.join(dirname, 'dogs-vs-cats.tar')\\n extract_archive(tar_file_path, dirname, archive_format='tar')\\n data_provider = load_folder_images(dataset_name, dirname)\\n return data_provider\\n elif dataset_name == 'examples_chinese':\\n to_half=ToHalfWidth()\\n to_sc=ChineseConvert(convert_to='simplified')\\n download_file_from_google_drive('1yzRzXpLuhSUxnixqCgpbdTk16ajnTEWF', dirname, 'chinese.tar')\\n tar_file_path = os.path.join(dirname, 'chinese.tar')\\n extract_archive(tar_file_path, dirname, archive_format='tar')\\n\\n as_train = remove_nonprintable(to_half(codecs.open(os.path.join(dirname, 'as_training.utf8'), encoding='utf-8-sig').read().strip().replace('\\\\u3000' ,'|'))).splitlines()\\n cityu_train =remove_nonprintable(to_half(codecs.open(os.path.join(dirname, 'cityu_training.utf8'), encoding='utf-8-sig').read().strip().replace(' ','|'))).splitlines()\\n\\n as_test = remove_nonprintable(to_half(codecs.open(os.path.join(dirname, 'as_testing_gold.utf8'), encoding='utf-8-sig').read().strip().replace('\\\\u3000', '|'))).splitlines()\\n cityu_test = remove_nonprintable(to_half(codecs.open(os.path.join(dirname, 'cityu_test_gold.utf8'), encoding='utf-8-sig').read().strip().replace(' ', '|'))).splitlines()\\n\\n\\n data = as_train + cityu_train # 把兩個語料合併\\n test_data=as_test + cityu_test # 把兩個語料合併\\n\\n\\n raw_data_train = [row.strip('\\\\n').strip('\\\\r') for row in data] # 移除分行字元\\n raw_data_test = [row.strip('\\\\n').strip('\\\\r') for row in test_data] # 移除分行字元\\n\\n process_data_train=[]\\n process_seg_label_train = []\\n process_simplifided_label_train = []\\n process_traditional_label_train = []\\n\\n tmp_data_train = []\\n tmp_seg_label_train = []\\n tmp_simplifided_label_train = []\\n tmp_pronunce_label_train = []\\n for k in tqdm(range(len(raw_data_train))):\\n row=raw_data_train[k]\\n if row.startswith('∥'):\\n row=row[1:]\\n words=row.replace('||','|').split('|')\\n for k in range(len(words)):\\n\\n word = words[k]\\n\\n for i in range(len(word)):\\n tmp_data_train.append(word[i])\\n #tmp_simplifided_label_train.append(to_half(to_sc(word[i])))\\n #轉換為BMES\\n\\n if i==0 and len(word)>1: #B 是一個詞的開始\\n tmp_seg_label_train.append('B')\\n elif i==len(word)-1 and len(word)>=2 and tmp_seg_label_train[-1] in ['B','M']: #E 是一個詞的結束\\n tmp_seg_label_train.append('E')\\n elif len(word)==1 and i==0: #S 自己就是一個單詞\\n tmp_seg_label_train.append('S')\\n elif len(word)>=3 and tmp_seg_label_train[-1] in ['B','M']: #M 是一個詞的中間\\n tmp_seg_label_train.append('M')\\n\\n if len(tmp_seg_label_train)>0 and tmp_seg_label_train[-1] in ['E','S']:\\n if len(word) > 1 and (is_alphabet(word) or is_punctuation(word)) and k+1<len(words):\\n if word in [ '。','﹖']:\\n pass\\n\\n elif random.random() < 0.6 or is_alphabet(word):\\n tmp_data_train.append(' ')\\n tmp_seg_label_train.append('S')\\n\\n if (k+1<len(raw_data_train) and not raw_data_train[k+1].startswith( '」')) and words[-1] in [ '。','﹖']:\\n #process_traditional_label_train.append(tmp_data_train)\\n\\n tmp_data_train=to_half(''.join(tmp_data_train))\\n tmp_seg_label_train = ''.join(tmp_seg_label_train)\\n # if len(tmp_data_train)!=len(tmp_seg_label_train):\\n # print('')\\n tmp_simplifided_label_train =to_sc(tmp_data_train)\\n\\n process_data_train.append(tmp_data_train)\\n process_seg_label_train.append(tmp_seg_label_train)\\n process_simplifided_label_train.append(tmp_simplifided_label_train)\\n tmp_data_train = []\\n tmp_seg_label_train = []\\n tmp_simplifided_label_train = []\\n tmp_pronunce_label_train = []\\n # else:\\n # tmp_data_train.append('\\\\n')\\n # tmp_simplifided_label_train.append('\\\\n')\\n # tmp_seg_label_train.append('\\\\n')\\n corpus=process_data_train\\n seg_corpus=process_seg_label_train\\n simplifided_corpus =process_simplifided_label_train\\n\\n process_data_test = []\\n process_seg_label_test = []\\n process_simplifided_label_test = []\\n process_traditional_label_test = []\\n print('generate test labels')\\n tmp_data_test = []\\n tmp_seg_label_test = []\\n tmp_simplifided_label_test = []\\n tmp_pronunce_label_test = []\\n for k in tqdm(range(len(raw_data_test))):\\n row=raw_data_test[k]\\n if row.startswith('∥'):\\n row=row[1:]\\n words = row.replace('||', '|').split('|')\\n for k in range(len(words)):\\n\\n word = words[k]\\n\\n for i in range(len(word)):\\n tmp_data_test.append(word[i])\\n # tmp_simplifided_label_test.append(to_half(to_sc(word[i])))\\n # 轉換為BMES\\n\\n if i == 0 and len(word) > 1: # B 是一個詞的開始\\n tmp_seg_label_test.append('B')\\n elif i == len(word) - 1 and len(word) >= 2 and tmp_seg_label_test[-1] in ['B', 'M']: # E 是一個詞的結束\\n tmp_seg_label_test.append('E')\\n elif len(word) == 1 and i == 0: # S 自己就是一個單詞\\n tmp_seg_label_test.append('S')\\n elif len(word) >= 3 and tmp_seg_label_test[-1] in ['B', 'M']: # M 是一個詞的中間\\n tmp_seg_label_test.append('M')\\n\\n if len(tmp_seg_label_test) > 0 and tmp_seg_label_test[-1] in ['E', 'S'] and k+1<len(words):\\n if len(word) > 1 and (is_alphabet(word) or is_punctuation(word)):\\n if word in ['。', '﹖']:\\n pass\\n elif random.random() < 0.6 or is_alphabet(word):\\n tmp_data_test.append(' ')\\n tmp_seg_label_test.append('S')\\n\\n if (k + 1 < len(raw_data_test) and not raw_data_test[k + 1].startswith('」')) and words[-1] in ['。', '﹖']:\\n # process_traditional_label_test.append(tmp_data_test)\\n\\n tmp_data_test = to_half(''.join(tmp_data_test))\\n tmp_seg_label_test = ''.join(tmp_seg_label_test)\\n # if len(tmp_data_test)!=len(tmp_seg_label_test):\\n # print('')\\n tmp_simplifided_label_test = to_sc(tmp_data_test)\\n\\n process_data_test.append(tmp_data_test)\\n process_seg_label_test.append(tmp_seg_label_test)\\n process_simplifided_label_test.append(tmp_simplifided_label_test)\\n tmp_data_test = []\\n tmp_seg_label_test = []\\n tmp_simplifided_label_test = []\\n tmp_pronunce_label_test = []\\n # else:\\n # tmp_data_test.append('\\\\n')\\n # tmp_simplifided_label_test.append('\\\\n')\\n # tmp_seg_label_test.append('\\\\n')\\n test_corpus = process_data_test\\n test_seg_corpus = process_seg_label_test\\n test_simplifided_corpus = process_simplifided_label_test\\n\\n\\n data=TextSequenceDataset(corpus=corpus,sequence_length=64,sequence_start_at='section_start',object_type=ObjectType.corpus,symbol='input')\\n seg_label = TextSequenceDataset(corpus=seg_corpus,sequence_length=64, sequence_start_at='section_start', object_type=ObjectType.sequence_label,symbol='seg_label')\\n simplifided_label = TextSequenceDataset(corpus=simplifided_corpus,sequence_length=64, sequence_start_at='section_start', object_type=ObjectType.sequence_label,symbol='simplified_label')\\n traditional_label = TextSequenceDataset(corpus= copy.deepcopy(corpus), sequence_length=64, sequence_start_at='section_start', object_type=ObjectType.sequence_label,symbol='traditional_label')\\n\\n data_test=TextSequenceDataset(corpus=test_corpus,sequence_length=64,sequence_start_at='section_start',object_type=ObjectType.corpus,symbol='input')\\n seg_test_label = TextSequenceDataset(corpus=test_seg_corpus,sequence_length=64, sequence_start_at='section_start', object_type=ObjectType.sequence_label,symbol='seg_label')\\n simplifided_test_label = TextSequenceDataset(corpus=test_simplifided_corpus,sequence_length=64, sequence_start_at='section_start', object_type=ObjectType.sequence_label,symbol='simplified_label')\\n traditional_test_label = TextSequenceDataset(corpus= copy.deepcopy(test_corpus), sequence_length=64, sequence_start_at='section_start', object_type=ObjectType.sequence_label,symbol='traditional_label')\\n\\n\\n chars = list(sorted(set(list( ''.join(corpus) +bpmf_phonetic+'\\\\n\\\\r\\\\t∥'+ ''.join(simplifided_corpus)+''.join(test_data)))))\\n chars.insert(0, '[CLS]')\\n chars.insert(1, '[SEP]')\\n chars.insert(2, '[UNK]')\\n chars.insert(3, '[PAD]')\\n chars.insert(4, '[MASK]')\\n\\n data.vocabs =data_test.vocabs=simplifided_label.vocabs=simplifided_test_label.vocabs = chars\\n data.text2index=data_test.text2index =simplifided_label.text2index=simplifided_test_label.text2index = dict((c, i) for i, c in enumerate(chars))\\n data.index2text =data_test.index2text =simplifided_label.index2text=simplifided_test_label.index2text= dict((i, c) for i, c in enumerate(chars))\\n traditional_label = copy.deepcopy(data)\\n traditional_test_label = copy.deepcopy(data_test)\\n traditional_label.object_type =traditional_test_label.object_type = ObjectType.sequence_label\\n traditional_label.symbol =traditional_test_label.symbol = 'traditional_label'\\n\\n mask_label = copy.deepcopy(data)\\n mask_test_label = copy.deepcopy(data_test)\\n #mask_label.object_type =mask_test_label.object_type= ObjectType.corpus\\n mask_label.symbol = mask_test_label.symbol = 'mask_label'\\n\\n\\n\\n nextword=copy.deepcopy(data)\\n nextword_test = copy.deepcopy(data_test)\\n nextword.object_type=nextword_test.object_type=ObjectType.sequence_label\\n nextword.symbol=nextword_test.symbol='nextword_label'\\n nextword.sequence_offset=nextword_test.sequence_offset=1\\n\\n label=ZipDataset(seg_label,nextword,simplifided_label,traditional_label,mask_label)\\n label_test = ZipDataset(seg_test_label, nextword_test, simplifided_test_label, traditional_test_label, mask_test_label)\\n provider=TextSequenceDataProvider(\\n traindata=Iterator(data=data,label=label),\\n testdata=Iterator(data=data_test,label=label_test))\\n return provider\\n #,sample_filter=lambda x:x[0][-1]==3\\n else:\\n return None\",\n \"def test_dataaug():\\n # test len\\n augdataset = AugmentedDataset(4, foldername=\\\"test_data\\\")\\n assert len(augdataset) == 40\\n\\n augbaldatset = AugmentedBalancedDataset(2, foldername=\\\"test_data\\\")\\n assert len(augbaldatset) == 2*(3*4)\\n\\n # test getitem\\n assert augdataset[35][0].size() == (1, 299, 299)\\n assert augbaldatset[40040][0].size() == (1, 299, 299)\",\n \"def Test_data():\\n print (\\\"loading test data ...\\\")\\n time_start = time.time()\\n data_root = '/media/keziwen/86AA9651AA963E1D'\\n\\n with h5py.File(join(data_root, './data/test_real2.h5')) as f:\\n test_real = f['test_real'][:]\\n with h5py.File(join(data_root, './data/test_imag2.h5')) as f:\\n test_imag = f['test_imag'][:]\\n test_real = np.transpose(test_real, (0, 1, 3, 2))\\n test_imag = np.transpose(test_imag, (0, 1, 3, 2))\\n test_data = test_real+1j*test_imag\\n time_end = time.time()\\n print ('dataset has been created using {}s'.format(time_end - time_start))\\n return test_data\",\n \"def _load_testing_data(base_dir):\\n test_data = pd.read_csv(os.path.join(base_dir, \\\"test_vale.csv\\\")).adjclose.values\\n return _data_transformation(test_data)\",\n \"def load_data(self):\",\n \"def test_compute_glycemic_load(self):\\n pass\",\n \"def test_dataset_from_dir(dir_dataset):\\n dummy = \\\"malesuada. Integer id magna et ipsum cursus vestibulum. Mauris magna.\\\"\\n assert dir_dataset[0][0] == dummy\\n assert dir_dataset[0][1] == '8'\\n\\n dummy = \\\"Sed molestie. Sed id risus quis diam luctus lobortis. Class\\\"\\n assert dir_dataset[100][0] == dummy\\n assert dir_dataset[100][1] == '6'\",\n \"def test_wool():\\n test_path = tempfile.mkdtemp()\\n x_train, metadata = wool(test_path)\\n try:\\n assert x_train.shape == (309, 2)\\n except:\\n shutil.rmtree(test_path)\\n raise()\",\n \"def test_import():\\n assert hasattr(waves, 'wave_number')\",\n \"def load_dataset_test():\\n df_test = load_csv_file(\\\"31_test.csv\\\")\\n return df_test.values\",\n \"def test_Conll2003Loader(self):\\n dataset_path = \\\"test/data_for_tests/conll_2003_example.txt\\\"\\n loader = Conll2003Loader()\\n dataset_2003 = loader.load(dataset_path)\",\n \"def setUp(self):\\n self.test_data = self.read_data('test_data/clients.txt')\",\n \"def testCreateWmsDataset(self):\\n\\n # create the source\\n\\n path = '/minerva_source_wms'\\n name = 'testWMS'\\n typeName = 'geonode:global_temp'\\n username = ''\\n password = ''\\n baseURL = 'http://demo.boundlessgeo.com/geoserver/ows'\\n params = {\\n 'name': name,\\n 'username': username,\\n 'password': password,\\n 'baseURL': baseURL\\n }\\n response = self.request(path=path, method='POST', params=params, user=self._user)\\n self.assertStatusOk(response)\\n wmsSource = response.json\\n\\n # create the dataset\\n\\n path = '/minerva_dataset_wms'\\n name = 'testWMSdataset'\\n wmsParams = {}\\n params = {\\n 'name': name,\\n 'wmsSourceId': wmsSource['_id'],\\n 'typeName': typeName,\\n 'wmsParams': wmsParams\\n }\\n response = self.request(path=path, method='POST', params=params, user=self._user)\\n self.assertStatusOk(response)\\n wmsDataset = response.json\\n minerva_metadata = wmsDataset['meta']['minerva']\\n self.assertEquals(wmsDataset['name'], name, 'incorrect wms dataset name')\\n self.assertEquals(minerva_metadata['source_id'], wmsSource['_id'], 'incorrect wms source_id')\\n self.assertEquals(minerva_metadata['dataset_type'], 'wms', 'incorrect wms dataset type')\\n self.assertEquals(minerva_metadata['base_url'], wmsSource['meta']['minerva']['wms_params']['base_url'],'incorrect wms dataset baseURL')\\n self.assertEquals(minerva_metadata['type_name'], typeName, 'incorrect wms dataset typeName')\\n legend = 'PD94bWwgdmVyc2lvbj0iMS4wIiBlbmNvZGluZz0iVVRGLTgiPz48U2VydmljZUV4Y2VwdGlvblJlcG9ydCB2ZXJzaW9uPSIxLjMuMCIgeG1sbnM9Imh0dHA6Ly93d3cub3Blbmdpcy5uZXQvb2djIiB4bWxuczp4c2k9Imh0dHA6Ly93d3cudzMub3JnLzIwMDEvWE1MU2NoZW1hLWluc3RhbmNlIiB4c2k6c2NoZW1hTG9jYXRpb249Imh0dHA6Ly93d3cub3Blbmdpcy5uZXQvb2djIGh0dHA6Ly9kZW1vLmJvdW5kbGVzc2dlby5jb206ODAvZ2Vvc2VydmVyL3NjaGVtYXMvd21zLzEuMy4wL2V4Y2VwdGlvbnNfMV8zXzAueHNkIj4gICA8U2VydmljZUV4Y2VwdGlvbj4KICAgICAgQ2FuJmFwb3M7dCBvYnRhaW4gdGhlIHNjaGVtYSBmb3IgdGhlIHJlcXVpcmVkIGxheWVyLgpnZW9ub2RlOmdsb2JhbF90ZW1wIGxheWVyIGRvZXMgbm90IGV4aXN0Lgo8L1NlcnZpY2VFeGNlcHRpb24+PC9TZXJ2aWNlRXhjZXB0aW9uUmVwb3J0Pg==\\\\n'\\n # TODO determine if legend is stable, if not, needs to be mocked\\n self.assertEquals(minerva_metadata['legend'], legend, 'incorrect wms dataset legend')\",\n \"def test_ingest_zipfile():\\n\\n try:\\n\\n adult_data_df = ingest_csv_from_zipfile(Directories.ZIP_FILE_DIR.value, FileNames.DATA_FILE.value)\\n\\n except Exception as exception:\\n\\n pytest.fail('Ingest zip file error: {}'.format(exception))\\n\\n pass\",\n \"def load_dataset():\\n\\n\\n train_dd_loader = DailyDialogLoader(PATH_TO_TRAIN_DATA, load=False)\\n train_dataloader = DataLoader(train_dd_loader, batch_size=16, shuffle=True, num_workers=0,\\n collate_fn=PadCollate())\\n\\n test_dd_loader = DailyDialogLoader(PATH_TO_TEST_DATA, load=True)\\n test_dataloader = DataLoader(test_dd_loader, batch_size=1, shuffle=False, num_workers=0,\\n collate_fn=PadCollate())\\n\\n assert train_dd_loader.vocabulary.n_words == test_dd_loader.vocabulary.n_words\\n\\n return train_dd_loader, train_dataloader, test_dataloader\",\n \"def test_dataset_autogen_dir_with_test(autogen_dataset_dir_with_test):\\n train_dummy = \\\"Donec non justo. Proin non massa non ante bibendum ullamcorper.\\\"\\n val_dummy = \\\"nibh. Aliquam ornare, libero at auctor ullamcorper, nisl arcu iaculis\\\"\\n test_dummy = \\\"a sollicitudin orci sem eget massa. Suspendisse eleifend. Cras sed\\\"\\n\\n assert autogen_dataset_dir_with_test.train[0][0] == train_dummy\\n assert autogen_dataset_dir_with_test.train[0][1] == '4'\\n assert len(autogen_dataset_dir_with_test.train) == 201\\n\\n assert autogen_dataset_dir_with_test.val[0][0] == val_dummy\\n assert autogen_dataset_dir_with_test.val[0][1] == '10'\\n assert len(autogen_dataset_dir_with_test.val) == 51\\n\\n assert autogen_dataset_dir_with_test.test[0][0] == test_dummy\\n assert autogen_dataset_dir_with_test.test[0][1] == '3'\\n assert len(autogen_dataset_dir_with_test.test) == 50\",\n \"def setup(self):\\n self.rows = test_helpers.fetch_sample_teradata_rows()\\n self.csv_path = 'not/a/real/path'\",\n \"def test_invlaid_data(self):\\n # Currently, there are no PowerPlant or Project objects in the database\\n self.assertEqual(PowerPlant.objects.count(), 0)\\n self.assertEqual(Project.objects.count(), 0)\\n\\n # Call the command with invalid data.\\n # The first row is for a power plant, but it has an invalid latitude.\\n # The second row is for a project, but it has an invalid project capacity.\\n # The third row is for a project, but it has an invalid project capacity unit.\\n # The fourth row is for a power plant, but has an invalid status.\\n self.call_command(filename='power_plant_import/tests/data/invalid_data.csv')\\n\\n # Each of the objects were created, though the invalid data was not saved.\\n self.assertEqual(PowerPlant.objects.count(), 3)\\n self.assertEqual(Project.objects.count(), 2)\",\n \"def test_import(self):\\r\\n descriptor = self.get_dummy_course(START)\",\n \"def load_data(self) -> None:\",\n \"def test_dataset():\\n # File paths\\n intervals_file = \\\"example_files/intervals.bed\\\"\\n target_file = \\\"example_files/targets.tsv\\\"\\n gtf_file = \\\"example_files/gencode.v24.annotation_chr22.gtf\\\"\\n fasta_file = \\\"example_files/hg38_chr22.fa\\\"\\n ds = SeqDistDataset(intervals_file, fasta_file, gtf_file, target_file)\\n\\n ds[0]\\n ds[10]\\n it = ds.batch_iter(32)\\n next(it)\",\n \"def load_data(opt=\\\"mnist\\\"):\\n if opt == \\\"mnist\\\":\\n train, test = tf.keras.datasets.mnist.load_data()\\n \\n x_train, y_train = train\\n x_test, y_test = test\\n \\n x_train = x_train.reshape(x_train.shape[0], 28 * 28)\\n x_test = x_test.reshape(x_test.shape[0], 28 * 28)\\n \\n y_train = y_train.astype(np.int)\\n y_test = y_test.astype(np.int)\\n for i in range(len(y_train)):\\n y_train[i] = 1 if y_train[i] % 2 == 0 else -1\\n for i in range(len(y_test)):\\n y_test[i] = 1 if y_test[i] % 2 == 0 else -1\\n\\n elif opt == \\\"covertype\\\":\\n df = pd.read_csv(\\\"covtype.data\\\", header=None)\\n x = df.iloc[:, 0:54].values\\n y = df[54].values\\n for i in range(len(y)):\\n y[i] = 1 if y[i] % 2 == 0 else -1\\n x_train, x_test, y_train, y_test = train_test_split(x, y, test_size=0.3)\\n \\n else:\\n logging.error(\\\"Unknown dataset!!\\\")\\n\\n logging.info(\\\"train data shape: {}\\\".format(x_train.shape))\\n logging.info(\\\"test data shape: {}\\\".format(x_test.shape))\\n return (x_train, y_train), (x_test, y_test)\",\n \"def import_data_handler():\\n\\n result = ''\\n try:\\n current_dir = os.getcwd()\\n directory_name = current_dir + '\\\\\\\\lesson5\\\\\\\\data\\\\\\\\'\\n file_name_dict = {'products': 'products.csv', 'customers': 'customers.csv',\\n 'rentals': 'rentals.csv'}\\n for key, value in file_name_dict.items():\\n tmp_file = directory_name + value\\n mongo_insert = ImportUnitTestData()\\n result = mongo_insert.import_data(key, tmp_file)\\n print(result)\\n except FileNotFoundError as e:\\n logger.error('exception %s', e, exc_info=True)\\n result = 'exception {}'.format(e)\\n print(result)\\n return result\",\n \"def load_data():\\n directories=[\\\"./track1/\\\",\\n \\\"./track1_recovery/\\\",\\n \\\"./track2/\\\",\\n \\\"./track1_reverse/\\\",\\n \\\"./track2_reverse/\\\",#Additional data for model built on top of lenet.h5\\n \\\"./track2_recovery/\\\",#Additions data for model built on top of lenet.h5\\n ]\\n lines=[]\\n for directory in directories:\\n with open(directory+\\\"driving_log.csv\\\") as csvfile:\\n reader=csv.reader(csvfile)\\n for line in reader:\\n lines.append(line)\\n train_samples, validation_samples = train_test_split(lines, test_size=0.2)\\n return train_samples, validation_samples\",\n \"def test_ExtendSpine1(self):\\n\\n self.delayDisplay(\\\"Starting the test\\\")\\n #\\n # first, get some data\\n #\\n import urllib\\n downloads = (\\n ('http://slicer.kitware.com/midas3/download?items=5767', 'FA.nrrd', slicer.util.loadVolume),\\n )\\n\\n for url,name,loader in downloads:\\n filePath = slicer.app.temporaryPath + '/' + name\\n if not os.path.exists(filePath) or os.stat(filePath).st_size == 0:\\n logging.info('Requesting download %s from %s...\\\\n' % (name, url))\\n urllib.urlretrieve(url, filePath)\\n if loader:\\n logging.info('Loading %s...' % (name,))\\n loader(filePath)\\n self.delayDisplay('Finished with download and loading')\\n\\n volumeNode = slicer.util.getNode(pattern=\\\"FA\\\")\\n logic = ExtendSpineLogic()\\n self.assertIsNotNone( logic.hasImageData(volumeNode) )\\n self.delayDisplay('Test passed!')\",\n \"def import_datasets(snli_path):\\n print('extract data from snli directory..')\\n train = dict(); dev = dict(); test = dict()\\n gold_labels = {'entailment': 0, 'neutral': 1, 'contradiction': 2}\\n\\n for file_type in ['train', 'dev', 'test']:\\n path = os.path.join(snli_path, 'snli_1.0_{}.jsonl'.format(file_type))\\n with open(path) as file:\\n data = [json.loads(line) for line in file]\\n eval(file_type)['premise'] = [entry['sentence1'] for entry in data if entry['gold_label'] != '-']\\n eval(file_type)['hypothesis'] = [entry['sentence2'] for entry in data if entry['gold_label'] != '-']\\n g_labels = np.array([gold_labels[entry['gold_label']] for entry in data if entry['gold_label'] != '-'])\\n eval(file_type)['label'] = g_labels\\n print('extraction process was finished successfully!')\\n return train, dev, test\",\n \"def setUpTestData(cls):\\n call_command('loaddata', 'db.json', verbosity=0)\",\n \"def test_data_path(self):\\n path = self._api.GetDatapath()\\n self._api.End()\\n self.assertRaises(\\n RuntimeError, self._api.Init, path=(self._test_dir + os.path.sep)\\n ) # no tessdata\\n if _TESSERACT_VERSION >= 0x3999800:\\n new_path = path\\n else:\\n new_path = os.path.abspath(os.path.join(path, os.path.pardir)) + os.path.sep\\n self._api.End()\\n self._api.Init(new_path)\\n self.assertEqual(self._api.GetDatapath(), path)\",\n \"def runTest(self):\\n # workaround for Python 2.6\\n if self.skip:\\n return\\n\\n f = Dataset(self.file, 'a')\\n w = f.variables[\\\"vl2\\\"]\\n v = f.variables[\\\"vl\\\"]\\n w[0:3] = np.arange(3, dtype=np.float64)\\n v[0] # sometimes crashes\\n v[0].tolist() # sometimes crashes\\n v[0].size # BOOM!\\n f.close()\",\n \"def load_data(train_path, test_path):\\n\\n train_data = pd.read_csv(train_path)\\n test_data = pd.read_csv(test_path)\\n\\n print(\\\"number of training examples = \\\" + str(train_data.shape[0]))\\n print(\\\"number of test examples = \\\" + str(test_data.shape[0]))\\n print(\\\"train shape: \\\" + str(train_data.shape))\\n print(\\\"test shape: \\\" + str(test_data.shape))\\n\\n return train_data, test_data\",\n \"def load_data(train_path, test_path):\\n\\n train_data = pd.read_csv(train_path)\\n test_data = pd.read_csv(test_path)\\n\\n print(\\\"number of training examples = \\\" + str(train_data.shape[0]))\\n print(\\\"number of test examples = \\\" + str(test_data.shape[0]))\\n print(\\\"train shape: \\\" + str(train_data.shape))\\n print(\\\"test shape: \\\" + str(test_data.shape))\\n\\n return train_data, test_data\",\n \"def load_dataset(display = False, flag=\\\"train\\\"):\\n\\n if flag ==\\\"train\\\":\\n print(\\\"Loading training set image X ...\\\")\\n train_X_data = DataUtils(filename=trainfile_X).getImage()\\n print(\\\"Loading training set label y ...\\\")\\n train_y_data = DataUtils(filename=trainfile_y).getLabel()\\n print(\\\"size of training set X = \\\", train_X_data.shape)\\n print(\\\"size of training set y = \\\", train_y_data.shape) \\n\\n if display:\\n path_trainset = \\\"MNIST_dataset/imgs_train\\\"\\n if not os.path.exists(path_trainset):\\n os.mkdir(path_trainset)\\n outImg(train_X_data, train_y_data, 30, out_path)\\n DataUtils(outpath=path_trainset).outImg(train_X_data, train_y_data, 30)\\n\\n return train_X_data, train_y_data\\n \\n elif flag == \\\"test\\\":\\n print(\\\"Loading test set image X ...\\\")\\n test_X_data = DataUtils(testfile_X).getImage()\\n print(\\\"Loading test set label y ...\\\")\\n test_y_data = DataUtils(testfile_y).getLabel()\\n print(\\\"size of test set X = \\\", test_X_data.shape)\\n print(\\\"size of test set y = \\\", test_y_data.shape)\\n\\n if display:\\n path_testset = \\\"MNIST_dataset/imgs_test\\\"\\n if not os.path.exists(path_testset):\\n os.mkdir(path_testset)\\n DataUtils(outpath=path_testset).outImg(test_X_data, test_y_data, 30)\\n\\n return test_X_data, test_y_data\",\n \"def train_dataset():\\n return TabularDataset.from_path('tests/data/dummy_tabular/train.csv', sep=',')\",\n \"def test_includes_two_new_datasets(self):\\n new_datasets = factories.SourceDatasetFactory.create_batch(2, source_study_version=self.study_version_3)\\n response = self.client.get(self.get_url(self.study.pk))\\n context = response.context\\n table = context['source_dataset_table']\\n for new_dataset in new_datasets:\\n self.assertIn(new_dataset, table.data)\",\n \"def setUpClass(cls):\\n super(Module05Tests, cls).setUpClass()\\n cls.datasets = {\\n 0: DATASETS_ROOT + 'diffusion_synthetic_normal_L8_r2_slices_41_50_gr15_b1200',\\n 1: DATASETS_ROOT + 'filtered',\\n 2: DATASETS_ROOT + 'noise'\\n }\\n cls.data = smns.load_object(file_path=cls.datasets[2])\",\n \"def data_import(path):\\n train_path = os.path.join(path, \\\"train.csv\\\")\\n test_path = os.path.join(path, \\\"test.csv\\\")\\n df_train = pd.read_csv(train_path)\\n df_test = pd.read_csv(test_path)\\n return df_train, df_test\",\n \"def test_import_python(self):\\n provider = ProcessingProvider()\\n registry = QgsApplication.processingRegistry()\\n if not registry.providerById(provider.id()):\\n registry.addProvider(provider)\\n feedback = LoggerProcessingFeedBack(True)\\n project = QgsProject()\\n context = QgsProcessingContext()\\n context.setProject(project)\\n couche = QgsVectorLayer(plugin_test_data_path('portions.gpkg'), 'layer', 'ogr')\\n\\n params = {\\n \\\"INPUT\\\": couche,\\n \\\"TABLE\\\": \\\"portion\\\",\\n \\\"SCHEMA\\\": \\\"veloroutes\\\",\\n \\\"DATABASE\\\": \\\"test\\\",\\n 'MATRIX': [\\n \\\"TYPE_PORTION_COVADIS\\\", \\\"type_portion\\\",\\n \\\"MONTANT_SUBVENTION\\\", \\\"mont_subv\\\",\\n \\\"ANNE_SUBVENTION\\\", \\\"annee_subv\\\", \\\"fid\\\", \\\"id_import\\\",\\n \\\"LIEN_ITIN\\\", \\\"lien_itin\\\", \\\"LIEN_CYCLO\\\", \\\"lien_segm\\\"]\\n }\\n\\n alg = \\\"{}:import_covadis\\\".format(provider.id())\\n processing.run(\\n alg, params, feedback=feedback, context=context\\n )\\n\\n p = \\\"\\\"\\\"\\n SELECT id_portion FROM imports.import_portion LIMIT 1;\\n \\\"\\\"\\\"\\n self.cursor.execute(p)\\n p1 = self.cursor.fetchone()\\n self.assertIsNotNone(p1[0])\",\n \"def test_training(self):\\n\\t\\tpass\",\n \"def train(self, trainfile):\",\n \"def test_drop_data_handler(self):\\n # insert some test data\\n try:\\n current_dir = os.getcwd()\\n directory_name = current_dir + '\\\\\\\\lesson5\\\\\\\\data\\\\\\\\'\\n file_name_dict = {'products': 'products.csv', 'customers': 'customers.csv',\\n 'rentals': 'rentals.csv'}\\n for key, value in file_name_dict.items():\\n tmp_file = directory_name + value\\n mongo_insert = mdb.ImportData(key, tmp_file)\\n print(mongo_insert)\\n except FileNotFoundError as e:\\n logger.error('exception %s', e, exc_info=True)\\n result = main.drop_data_handler()\\n self.assertEqual(result, 'all data dropped- good luck on your next job')\",\n \"def load_test(data_file, labels=True, skip_rows=0):\\n dat = iter_loadtxt(data_file, delimiter='\\\\t', skiprows=skip_rows)\\n if labels:\\n Dat = DataSet(images=dat[:, 0:-1], labels=dat[:, -1].astype(int), reshape=False)\\n else:\\n nrow = dat.shape[0]\\n Dat = DataSet(images=dat, labels=np.full(nrow, np.nan), reshape=False)\\n return Dat\",\n \"def __loadDataset(self, parameters):\\n # self.localConfigured = Settings.instance().readValue( key = 'Common/local-repo' )\\n for pr in parameters:\\n if pr['type'] == 'dataset':\\n if pr['value'].startswith('undefined:/'):\\n fileName = pr['value'].split('undefined:/')[1]\\n if not os.path.exists( fileName ):\\n raise Exception(\\\"the following test data file is missing: %s \\\" % fileName)\\n\\n doc = FileModelTestData.DataModel()\\n res = doc.load( absPath = fileName )\\n pr['value'] = \\\"undefined:/%s\\\" % doc.getRaw()\\n elif pr['value'].startswith('local-tests:/'):\\n fileName = pr['value'].split('local-tests:/')[1]\\n\\n if not os.path.exists( fileName ):\\n raise Exception(\\\"the following test data file is missing: %s \\\" % fileName)\\n \\n doc = FileModelTestData.DataModel()\\n res = doc.load( absPath = fileName )\\n pr['value'] = \\\"local-tests:/%s\\\" % doc.getRaw()\\n else:\\n pass\",\n \"def load_raw_dataset(name):\\n assert name in VALID_NAMES, 'Invalid data set requested. Please make sure name is one of ' + ', '.join(VALID_NAMES) + '.'\\n\\n os.makedirs('downloads', exist_ok=True)\\n path = os.path.join('downloads', name)\\n path_raw = os.path.join(path, 'raw')\\n\\n if name == 'iris':\\n prep_path(path)\\n safe_dl('https://archive.ics.uci.edu/ml/machine-learning-databases/iris/iris.data', path_raw)\\n safe_dl('https://archive.ics.uci.edu/ml/machine-learning-databases/iris/iris.names', path_raw)\\n return pd.read_csv(os.path.join(path_raw, 'iris.data'), names=['sepal_len', 'sepal_wid', 'petal_len', 'petal_wid', 'species'])\\n\\n elif name == 'wine':\\n prep_path(path)\\n safe_dl('https://archive.ics.uci.edu/ml/machine-learning-databases/wine/wine.data', path_raw)\\n safe_dl('https://archive.ics.uci.edu/ml/machine-learning-databases/wine/wine.names', path_raw)\\n return pd.read_csv(os.path.join(path_raw, 'wine.data'), names=['class',\\n 'alcohol',\\n 'malic_acid',\\n 'ash',\\n 'alkalinity',\\n 'magnesium',\\n 'phenols',\\n 'flavanoids',\\n 'nonflavanoid_phenols',\\n 'proanthocyanins',\\n 'color_intensity',\\n 'hue',\\n 'dilution',\\n 'proline'])\\n\\n elif name == 'titanic':\\n import kaggle; kaggle.api.authenticate()\\n prep_path(path)\\n if len(os.listdir(path_raw)) == 0:\\n kaggle.api.competition_download_files('titanic', path_raw)\\n titanic = pd.read_csv(os.path.join(path_raw, 'train.csv'))\\n titanic_test = pd.read_csv(os.path.join(path_raw, 'test.csv'))\\n return titanic, titanic_test\\n\\n elif name == 'lanl':\\n import kaggle; kaggle.api.authenticate()\\n prep_path(path)\\n if len(os.listdir(path)) == 0:\\n kaggle.api.competition_download_files('LANL-Earthquake-Prediction', path_raw)\\n if not os.path.exists(os.path.join(path_raw, 'test')):\\n zip_ref = zipfile.ZipFile(os.path.join(path_raw, 'test.zip'), 'r')\\n zip_ref.extractall(os.path.join(path_raw, 'test'))\\n zip_ref.close()\\n return pd.read_csv(os.path.join(path_raw, 'train.csv.zip'))\\n\\n elif name == 'MNIST':\\n mnist = torchvision.datasets.MNIST('downloads', train=True, download=True)\\n mnist_test = torchvision.datasets.MNIST('downloads', train=False, download=True)\\n return mnist, mnist_test\\n\\n elif name == 'FashionMNIST':\\n fmnist = torchvision.datasets.FashionMNIST('downloads', train=True, download=True)\\n fmnist_test = torchvision.datasets.FashionMNIST('downloads', train=False, download=True)\\n return fmnist, fmnist_test\",\n \"def load_data(conso_train_file='../input/conso_train.csv',\\n meteo_train_file='../input/meteo_train.csv',\\n meteo_test_file='../input/meteo_prev.csv'):\\n # Loading the weather data\\n train_meteo = pd.read_csv(meteo_train_file, sep=';')\\n test_meteo = pd.read_csv(meteo_test_file, sep=';')\\n\\n # Marking the type and merge the train/test dataframes\\n train_meteo['type'] = 'train'\\n test_meteo['type'] = 'test'\\n data_meteo = pd.concat([train_meteo, test_meteo])\\n # Correct the weather data\\n data_meteo = correct_weather_data(data_meteo)\\n\\n # Load the train consumption\\n train_conso = pd.read_csv(conso_train_file, sep=';')\\n # Correct the consumption data\\n train_conso = correct_conso_data(train_conso)\\n\\n # Mark the type and merge the consumption/weather dataframes\\n train_conso['type'] = 'train'\\n data = pd.merge(train_conso, data_meteo,\\n on=['date', 'type'], how='outer', sort=True)\\n\\n # Complete the test dates\\n data = add_test_dates(data)\\n # Correct the test data from the merging\\n data = correct_test_data(data)\\n\\n return data\",\n \"def test_record_is_dataset_file(self) -> None:\\n path = \\\"/home/user/dataset.record\\\"\\n result = is_dataset_file(path)\\n self.assertTrue(result)\",\n \"def load():\\n filepath = dirname(abspath(__file__))\\n##### EDIT THE FOLLOWING TO POINT TO DatasetName.csv #####\\n data = recfromtxt(open(filepath + '/spector.csv',\\\"rb\\\"), delimiter=\\\" \\\",\\n names=True, dtype=float, usecols=(1,2,3,4))\\n names = list(data.dtype.names)\\n endog = array(data[names[3]], dtype=float)\\n endog_name = names[3]\\n exog = column_stack(data[i] for i in names[:3]).astype(float)\\n exog_name = names[:3]\\n dataset = Dataset(data=data, names=names, endog=endog, exog=exog,\\n endog_name = endog_name, exog_name=exog_name)\\n return dataset\",\n \"def setUp(self):\\n super(FrameImportCSVTest, self).setUp()\\n self.dataset = self.get_file(\\\"int_str_int.csv\\\")\\n self.schema = [(\\\"num1\\\", int), (\\\"letter\\\", str), (\\\"num2\\\", int)]\\n self.frame = self.context.frame.import_csv(self.dataset,\\n schema=self.schema)\",\n \"def test_import_software_asset(self):\\n pass\",\n \"def load_data(y_name='Species'):\\n train_path = tf.keras.utils.get_file(args.TRAIN_URL.split('/')[-1], args.TRAIN_URL)\\n test_path = tf.keras.utils.get_file(args.TEST_URL.split('/')[-1], args.TEST_URL)\\n\\n train = pd.read_csv(train_path, names=args.CSV_COLUMN_NAMES, header=0)\\n train_x, train_y = train, train.pop(y_name)\\n\\n test = pd.read_csv(test_path, names=args.CSV_COLUMN_NAMES, header=0)\\n test_x, test_y = test, test.pop(y_name)\\n\\n return (train_x, train_y), (test_x, test_y)\",\n \"def setUp(self):\\n self.dataset = self.dataset_cls()\",\n \"def test(self, dataset) -> None:\\n raise NotImplementedError()\",\n \"def test_load_data_single_column():\\n f = ImageFeaturizer()\\n f.load_data(**LOAD_DATA_ARGS)\\n compare_featurizer_class(f, (227, 227), np.zeros((1)), **COMPARE_ARGS)\\n\\n # Remove path to the generated csv at end of test\\n remove_generated_paths()\",\n \"def load_data_raw(source='local'):\\n import os\\n\\n if source == 'kaggle':\\n # Download the Ames Housing Dataset\\n # Set the enviroment variables\\n import zipfile\\n os.environ['KAGGLE_USERNAME'] = \\\"lubomrstraka\\\"\\n os.environ['KAGGLE_KEY'] = \\\"c7347462ef834e6645ce238c2f2fa561\\\"\\n \\n # Import dependencies\\n os.system(\\\"pip install kaggle --upgrade --quiet\\\")\\n\\n # Download datasets\\n os.system(\\\"kaggle competitions download -c house-prices-advanced-regression-techniques --quiet\\\")\\n \\n # Extract data\\n with zipfile.ZipFile('house-prices-advanced-regression-techniques.zip', 'r') as archive:\\n archive.extractall()\\n\\n # Read Train & Test Baseline Data\\n train_bl = pd.read_csv('train.csv', index_col='Id')\\n test_bl = pd.read_csv('test.csv', index_col='Id')\\n \\n # Using local data used while registering dataset\\n # prevents \\\"Too many requests\\\" response from Kaggle\\n elif source == 'local': \\n train_bl = pd.read_csv('train.csv', index_col='Id')\\n test_bl = pd.read_csv('test.csv', index_col='Id')\\n \\n else:\\n print('Missing data!')\\n train_bl = pd.DataFrame()\\n test_bl = pd.DataFrame()\\n\\n\\n return train_bl, test_bl\",\n \"def test_dataset_autogen(autogen_dataset):\\n train_dummy = \\\"eget, venenatis a, magna. Lorem ipsum dolor sit amet, consectetuer\\\"\\n val_dummy = \\\"leo. Vivamus nibh dolor, nonummy ac, feugiat non, lobortis quis,\\\"\\n test_dummy = \\\"turpis egestas. Aliquam fringilla cursus purus. Nullam scelerisque neque sed\\\"\\n\\n assert autogen_dataset.train[0][0] == train_dummy\\n assert autogen_dataset.train[0][1] == '8'\\n assert len(autogen_dataset.train) == 64\\n\\n assert autogen_dataset.val[0][0] == val_dummy\\n assert autogen_dataset.val[0][1] == '1'\\n assert len(autogen_dataset.val) == 16\\n\\n assert autogen_dataset.test[0][0] == test_dummy\\n assert autogen_dataset.test[0][1] == '6'\\n assert len(autogen_dataset.test) == 20\",\n \"def test_dataloader(self) -> torch.utils.data.DataLoader: \\n return torch.utils.data.DataLoader(self.dataset_test, **self.dl_kwargs)\",\n \"def test_load_model_data(self):\\n add_components_and_load_data(\\n prereq_modules=IMPORTED_PREREQ_MODULES,\\n module_to_test=MODULE_BEING_TESTED,\\n test_data_dir=TEST_DATA_DIRECTORY,\\n subproblem=\\\"\\\",\\n stage=\\\"\\\",\\n )\",\n \"def test_load_model_data(self):\\n add_components_and_load_data(\\n prereq_modules=IMPORTED_PREREQ_MODULES,\\n module_to_test=MODULE_BEING_TESTED,\\n test_data_dir=TEST_DATA_DIRECTORY,\\n subproblem=\\\"\\\",\\n stage=\\\"\\\",\\n )\",\n \"def test_get_denoiser_data_dir(self):\\r\\n\\r\\n obs = get_denoiser_data_dir()\\r\\n\\r\\n self.assertTrue(exists(obs))\\r\\n self.assertTrue(exists(obs + 'FLX_error_profile.dat'))\",\n \"def Train_data():\\n print (\\\"loading train data ...\\\")\\n time_start = time.time()\\n data_root = '/media/keziwen/86AA9651AA963E1D'\\n with h5py.File(join(data_root, './data/train_real2.h5')) as f:\\n data_real = f['train_real'][:]\\n num, nt, ny, nx = data_real.shape\\n data_real = np.transpose(data_real, (0, 1, 3, 2))\\n with h5py.File(join(data_root, './data/train_imag2.h5')) as f:\\n data_imag = f['train_imag'][:]\\n num, nt, ny, nx = data_imag.shape\\n data_imag = np.transpose(data_imag, (0, 1, 3, 2))\\n data = data_real+1j*data_imag\\n num_train = 15000\\n num_validate = 2000\\n train_data = data[0:num_train]\\n validate_data = data[num_train:num_train+num_validate]\\n\\n train_data = np.random.permutation(train_data)\\n\\n time_end = time.time()\\n print ('dataset has been created using {}s'.format(time_end-time_start))\\n return train_data, validate_data\",\n \"def setUp(self):\\n\\n self.test_data_path = 'testing/test_data/'\",\n \"def test_alien_data(self):\",\n \"def get_test_data():\\n\\n # test set\\n test = pd.read_csv(\\\"test.csv\\\")\\n\\n return test\",\n \"def test_import_values_densetxt():\\n x = np.random.rand(7, 11)\\n export_data('/tmp/test.densetxt', x)\\n assert np.array_equal(x, import_data('/tmp/test.densetxt'))\",\n \"def test_import_process(self):\\r\\n good_file = self._get_del_file()\\r\\n imp = Importer(good_file, username=u\\\"admin\\\")\\r\\n imp.process()\\r\\n\\r\\n # now let's do some db sanity checks\\r\\n self._delicious_data_test()\",\n \"def test_data():\\n current_dir = os.path.dirname(os.path.abspath(__file__))\\n test_data_dir = os.path.join(current_dir, \\\"test_data\\\")\\n\\n return pd.read_csv(os.path.join(test_data_dir, \\\"test_data_6m.csv\\\"))\",\n \"def load_data_simple_train_test(train_pos_data_path, train_neg_data_path, stopwords):\\n\\n\\ttrain_files_pos = [join(train_pos_data_path, f) for f in listdir(train_pos_data_path) if isfile(join(train_pos_data_path, f))]\\n\\ttrain_files_neg = [join(train_neg_data_path, f) for f in listdir(train_neg_data_path) if isfile(join(train_neg_data_path, f))]\\n\\n\\ttrain_files_pos.sort(key = lambda x: x.split(\\\"_\\\")[0].replace(\\\"cv\\\", \\\"\\\"))\\n\\ttrain_files_neg.sort(key = lambda x: x.split(\\\"_\\\")[0].replace(\\\"cv\\\", \\\"\\\"))\\n\\n\\tprint(\\\"The count of all positive files is: \\\", len(train_files_pos))\\n\\tprint(\\\"The count of all negative files is: \\\", len(train_files_neg))\\n\\n\\tall_pos_docs = collect_train_data(train_files_pos, stopwords)\\n\\tall_neg_docs = collect_train_data(train_files_neg, stopwords)\\n\\n\\tpos_train = all_pos_docs[:900]\\n\\tneg_train = all_neg_docs[:900]\\n\\tpos_test = all_pos_docs[900:]\\n\\tneg_test = all_neg_docs[900:]\\n\\n\\tprint(\\\"The size of the positive training set is: \\\", len(pos_train))\\n\\tprint(\\\"The size of the negative training set is: \\\", len(neg_train))\\n\\tprint(\\\"The size of the positive test set is: \\\", len(pos_test))\\n\\tprint(\\\"The size of the negative test set is: \\\", len(neg_test))\\n\\n\\treturn pos_train, pos_test, neg_train, neg_test\",\n \"def _create_data():\\n tf.logging.info(\\\"Create records..\\\")\\n train, val, test = util.load_data(data_dir, FLAGS[\\\"is_aug\\\"])\\n tf.logging.info(\\\"Dataset size: Train-{} Test-{} Val-{}\\\".format(len(train), len(test), len(val)))\\n return train, val, test\",\n \"def __test_and_train(self):\\n f = open(\\\"all_data_info.csv\\\")\\n reader = csv.DictReader(f, delimiter=\\\",\\\")\\n data = []\\n for line in reader:\\n if line['artist_group'] == \\\"train_and_test\\\" and line[\\\"in_train\\\"] == \\\"False\\\":\\n # the img's artist is in training set\\n # but the img is in test set only\\n data.append((line['artist'], line['new_filename']))\\n\\n return data\",\n \"def load_wmt_en_fr_dataset(data_dir=\\\"wmt\\\"):\\n # URLs for WMT data.\\n _WMT_ENFR_TRAIN_URL = \\\"http://www.statmt.org/wmt10/training-giga-fren.tar\\\"\\n _WMT_ENFR_DEV_URL = \\\"http://www.statmt.org/wmt15/dev-v2.tgz\\\"\\n\\n def maybe_download(directory, filename, url):\\n \\\"\\\"\\\"Download filename from url unless it's already in directory.\\\"\\\"\\\"\\n if not os.path.exists(directory):\\n print(\\\"Creating directory %s\\\" % directory)\\n os.mkdir(directory)\\n filepath = os.path.join(directory, filename)\\n if not os.path.exists(filepath):\\n print(\\\"Downloading %s to %s\\\" % (url, filepath))\\n filepath, _ = urllib.request.urlretrieve(url, filepath)\\n statinfo = os.stat(filepath)\\n print(\\\"Succesfully downloaded\\\", filename, statinfo.st_size, \\\"bytes\\\")\\n return filepath\\n\\n def gunzip_file(gz_path, new_path):\\n \\\"\\\"\\\"Unzips from gz_path into new_path.\\\"\\\"\\\"\\n print(\\\"Unpacking %s to %s\\\" % (gz_path, new_path))\\n with gzip.open(gz_path, \\\"rb\\\") as gz_file:\\n with open(new_path, \\\"wb\\\") as new_file:\\n for line in gz_file:\\n new_file.write(line)\\n\\n def get_wmt_enfr_train_set(directory):\\n \\\"\\\"\\\"Download the WMT en-fr training corpus to directory unless it's there.\\\"\\\"\\\"\\n train_path = os.path.join(directory, \\\"giga-fren.release2\\\")\\n if not (gfile.Exists(train_path +\\\".fr\\\") and gfile.Exists(train_path +\\\".en\\\")):\\n corpus_file = maybe_download(directory, \\\"training-giga-fren.tar\\\",\\n _WMT_ENFR_TRAIN_URL)\\n print(\\\"Extracting tar file %s\\\" % corpus_file)\\n with tarfile.open(corpus_file, \\\"r\\\") as corpus_tar:\\n corpus_tar.extractall(directory)\\n gunzip_file(train_path + \\\".fr.gz\\\", train_path + \\\".fr\\\")\\n gunzip_file(train_path + \\\".en.gz\\\", train_path + \\\".en\\\")\\n return train_path\\n\\n def get_wmt_enfr_dev_set(directory):\\n \\\"\\\"\\\"Download the WMT en-fr training corpus to directory unless it's there.\\\"\\\"\\\"\\n dev_name = \\\"newstest2013\\\"\\n dev_path = os.path.join(directory, dev_name)\\n if not (gfile.Exists(dev_path + \\\".fr\\\") and gfile.Exists(dev_path + \\\".en\\\")):\\n dev_file = maybe_download(directory, \\\"dev-v2.tgz\\\", _WMT_ENFR_DEV_URL)\\n print(\\\"Extracting tgz file %s\\\" % dev_file)\\n with tarfile.open(dev_file, \\\"r:gz\\\") as dev_tar:\\n fr_dev_file = dev_tar.getmember(\\\"dev/\\\" + dev_name + \\\".fr\\\")\\n en_dev_file = dev_tar.getmember(\\\"dev/\\\" + dev_name + \\\".en\\\")\\n fr_dev_file.name = dev_name + \\\".fr\\\" # Extract without \\\"dev/\\\" prefix.\\n en_dev_file.name = dev_name + \\\".en\\\"\\n dev_tar.extract(fr_dev_file, directory)\\n dev_tar.extract(en_dev_file, directory)\\n return dev_path\\n ## ==================\\n if data_dir == \\\"\\\":\\n print(\\\"Load or Download WMT English-to-French translation > %s\\\"\\n % os.getcwd())\\n else:\\n print(\\\"Load or Download WMT English-to-French translation > %s\\\"\\n % data_dir)\\n ## ======== Download if not exist\\n train_path = get_wmt_enfr_train_set(data_dir)\\n dev_path = get_wmt_enfr_dev_set(data_dir)\\n\\n return train_path, dev_path\",\n \"def test_readSongData():\\n\\n # make sure the number of columns pull out from the database is correct\\n assert svd.song_df.shape[1] == 8\",\n \"def _load_training_data(self):\\n self._save_training_data()\",\n \"def test_import_controls_with_evidence(self):\\n response = self.import_file(\\\"controls_no_warnings.csv\\\")\\n self._check_csv_response(response, {})\\n\\n evidence = models.Document.query.filter_by(title=\\\"Some title 3\\\").all()\\n self.assertEqual(len(evidence), 1)\\n control = models.Control.query.filter_by(slug=\\\"control-3\\\").first()\\n self.assertEqual(control.document_evidence[0].title, \\\"Some title 3\\\")\",\n \"def test_i_large_datasets(self):\\n\\n # If foma is not installed, exit.\\n if not h.foma_installed(force_check=True):\\n return\\n\\n # Configuration\\n\\n # The ``old_dump_file`` variable holds the name of a MySQL dump file in /tests/data/datasets\\n # that will be used to populate the database.\\n old_dump_file = 'blaold.sql'\\n backup_dump_file = 'old_test_dump.sql'\\n\\n # The ``precompiled_morphophonology`` variable holds the name of a compiled foma FST that\\n # maps surface representations to sequences of morphemes. A file with this name should be\\n # present in /tests/data/morphophonologies or else the variable should be set to None.\\n pregenerated_morphophonology = None # 'blaold_morphophonology.script'\\n precompiled_morphophonology = None # 'blaold_morphophonology.foma'\\n\\n # Here we load a whole database from the mysqpl dump file specified in ``tests/data/datasets/<old_dump_file>``.\\n old_dump_file_path = os.path.join(self.test_datasets_path, old_dump_file)\\n backup_dump_file_path = os.path.join(self.test_datasets_path, backup_dump_file)\\n tmp_script_path = os.path.join(self.test_datasets_path, 'tmp.sh')\\n if not os.path.isfile(old_dump_file_path):\\n return\\n config = h.get_config(config_filename='test.ini')\\n SQLAlchemyURL = config['sqlalchemy.url']\\n if not SQLAlchemyURL.split(':')[0] == 'mysql':\\n return\\n rdbms, username, password, db_name = SQLAlchemyURL.split(':')\\n username = username[2:]\\n password = password.split('@')[0]\\n db_name = db_name.split('/')[-1]\\n # First dump the existing database so we can load it later.\\n # Note: the --single-transaction option seems to be required (on Mac MySQL 5.6 using InnoDB tables ...)\\n # see http://forums.mysql.com/read.php?10,108835,112951#msg-112951\\n with open(tmp_script_path, 'w') as tmpscript:\\n tmpscript.write('#!/bin/sh\\\\nmysqldump -u %s -p%s --single-transaction --no-create-info --result-file=%s %s' % (\\n username, password, backup_dump_file_path, db_name))\\n os.chmod(tmp_script_path, 0744)\\n with open(os.devnull, \\\"w\\\") as fnull:\\n call([tmp_script_path], stdout=fnull, stderr=fnull)\\n # Now load the dump file of the large database (from old_dump_file)\\n with open(tmp_script_path, 'w') as tmpscript:\\n tmpscript.write('#!/bin/sh\\\\nmysql -u %s -p%s %s < %s' % (username, password, db_name, old_dump_file_path))\\n with open(os.devnull, \\\"w\\\") as fnull:\\n call([tmp_script_path], stdout=fnull, stderr=fnull)\\n\\n # Recreate the default users that the loaded dump file deleted\\n administrator = h.generate_default_administrator()\\n contributor = h.generate_default_contributor()\\n viewer = h.generate_default_viewer()\\n Session.add_all([administrator, contributor, viewer])\\n Session.commit()\\n\\n\\n ################################################################################\\n # PHONOLOGY\\n ################################################################################\\n\\n # Create a Blackfoot phonology with the test phonology script\\n params = self.phonology_create_params.copy()\\n params.update({\\n 'name': u'Blackfoot Phonology',\\n 'description': u'The phonological rules of Frantz (1997) as FSTs',\\n 'script': self.blackfoot_phonology_script\\n })\\n params = json.dumps(params)\\n response = self.app.post(url('phonologies'), params, self.json_headers,\\n self.extra_environ_admin)\\n resp = json.loads(response.body)\\n phonology_id = resp['id']\\n\\n \\\"\\\"\\\"\\n\\n\\n ################################################################################\\n # MORPHOLOGY\\n ################################################################################\\n\\n # Create a lexicon form search and corpus\\n # The code below constructs a query that finds a (large) subset of the Blackfoot morphemes.\\n # Notes for future morphology creators:\\n # 1. the \\\"oth\\\" category is a mess: detangle the nominalizer, inchoative, transitive suffixes, etc. from\\n # one another and from the numerals and temporal modifiers -- ugh!\\n # 2. the \\\"pro\\\" category\\\" is also a mess: clearly pronoun-forming iisto does not have the same distribution \\n # as the verbal suffixes aiksi and aistsi! And oht, the LING/means thing, is different again...\\n # 3. hkayi, that thing at the end of demonstratives, is not agra, what is it? ...\\n # 4. the dim category contains only 'sst' 'DIM' and is not used in any forms ...\\n lexical_category_names = ['nan', 'nin', 'nar', 'nir', 'vai', 'vii', 'vta', 'vti', 'vrt', 'adt',\\n 'drt', 'prev', 'med', 'fin', 'oth', 'o', 'und', 'pro', 'asp', 'ten', 'mod', 'agra', 'agrb', 'thm', 'whq',\\n 'num', 'stp', 'PN']\\n durative_morpheme = 15717\\n hkayi_morpheme = 23429\\n query = {'filter': ['and', [['Form', 'syntactic_category', 'name', 'in', lexical_category_names],\\n ['not', ['Form', 'morpheme_break', 'regex', '[ -]']],\\n ['not', ['Form', 'id', 'in', [durative_morpheme, hkayi_morpheme]]],\\n ['not', ['Form', 'grammaticality', '=', '*']]\\n ]]}\\n smaller_query_for_rapid_testing = {'filter': ['and', [['Form', 'id', '<', 1000],\\n ['Form', 'syntactic_category', 'name', 'in', lexical_category_names]]]}\\n params = self.form_search_create_params.copy()\\n params.update({\\n 'name': u'Blackfoot morphemes',\\n 'search': query\\n })\\n params = json.dumps(params)\\n response = self.app.post(url('formsearches'), params, self.json_headers, self.extra_environ_admin)\\n lexicon_form_search_id = json.loads(response.body)['id']\\n params = self.corpus_create_params.copy()\\n params.update({\\n 'name': u'Corpus of Blackfoot morphemes',\\n 'form_search': lexicon_form_search_id\\n })\\n params = json.dumps(params)\\n response = self.app.post(url('corpora'), params, self.json_headers, self.extra_environ_admin)\\n lexicon_corpus_id = json.loads(response.body)['id']\\n\\n # Create a rules corpus\\n\\n # Create a corpus of forms containing words -- to be used to estimate ngram probabilities\\n # The goal here is to exclude things that look like words but are not really words, i.e., \\n # morphemes; as a heuristic we search for grammatical forms categorized as 'sent' or whose\\n # transcription value contains a space or a dash.\\n query = {'filter': ['and', [['or', [['Form', 'syntactic_category', 'name', '=', u'sent'],\\n ['Form', 'morpheme_break', 'like', '% %'],\\n ['Form', 'morpheme_break', 'like', '%-%']]],\\n ['Form', 'syntactic_category_string', '!=', None],\\n ['Form', 'grammaticality', '=', '']]]}\\n params = self.form_search_create_params.copy()\\n params.update({\\n 'name': u'Find Blackfoot sentences',\\n 'description': u'Returns all forms containing words',\\n 'search': query\\n })\\n params = json.dumps(params)\\n response = self.app.post(url('formsearches'), params, self.json_headers, self.extra_environ_admin)\\n rules_form_search_id = json.loads(response.body)['id']\\n params = self.corpus_create_params.copy()\\n params.update({\\n 'name': u'Corpus of Blackfoot sentences',\\n 'form_search': rules_form_search_id\\n })\\n params = json.dumps(params)\\n response = self.app.post(url('corpora'), params, self.json_headers, self.extra_environ_admin)\\n rules_corpus_id = json.loads(response.body)['id']\\n\\n # Now we reduce the number of category-based word-formation rules by removing all such\\n # rules implicit in the rules corpus that have fewer than two exemplar tokens.\\n\\n # Get the category sequence types of all of the words in the rules corpus ordered by their counts, minus\\n # those with fewer than ``minimum_token_count`` counts.\\n minimum_token_count = 2\\n params = {'minimum_token_count': minimum_token_count}\\n response = self.app.get(url(controller='corpora', action='get_word_category_sequences', id=rules_corpus_id),\\n params, self.json_headers, self.extra_environ_admin)\\n resp = json.loads(response.body)\\n\\n word_category_sequences = u' '.join([word_category_sequence for word_category_sequence, ids in resp])\\n #word_category_sequences = u'agra-vai vai-agrb'\\n\\n # Now create a morphology using the lexicon and rules defined by word_category_sequences\\n rich_upper = False\\n name = u'Morphology of Blackfoot'\\n params = self.morphology_create_params.copy()\\n params.update({\\n 'name': name,\\n 'lexicon_corpus': lexicon_corpus_id,\\n 'rules': word_category_sequences,\\n 'script_type': u'lexc',\\n 'extract_morphemes_from_rules_corpus': False,\\n 'rich_upper': rich_upper\\n })\\n params = json.dumps(params)\\n response = self.app.post(url('morphologies'), params, self.json_headers, self.extra_environ_admin_appset)\\n resp = json.loads(response.body)\\n morphology_id = resp['id']\\n assert resp['name'] == name\\n assert resp['script_type'] == u'lexc'\\n\\n # Generate the morphology's script without compiling it.\\n response = self.app.put(url(controller='morphologies', action='generate',\\n id=morphology_id), headers=self.json_headers,\\n extra_environ=self.extra_environ_contrib)\\n resp = json.loads(response.body)\\n generate_attempt = resp['generate_attempt']\\n\\n # Poll ``GET /morphologies/morphology_id`` until ``generate_attempt`` has changed.\\n seconds_elapsed = 0\\n wait = 2\\n while True:\\n response = self.app.get(url('morphology', id=morphology_id),\\n headers=self.json_headers, extra_environ=self.extra_environ_contrib)\\n resp = json.loads(response.body)\\n if generate_attempt != resp['generate_attempt']:\\n log.debug('Generate attempt for morphology %d has terminated.' % morphology_id)\\n break\\n else:\\n log.debug('Waiting for morphology %d\\\\'s script to generate: %s' % (\\n morphology_id, self.human_readable_seconds(seconds_elapsed)))\\n sleep(wait)\\n seconds_elapsed = seconds_elapsed + wait\\n\\n ################################################################################\\n # MORPHEME LANGUAGE MODEL\\n ################################################################################\\n\\n # Create a morpheme language model\\n name = u'Blackfoot morpheme language model'\\n params = self.morpheme_language_model_create_params.copy()\\n params.update({\\n 'name': name,\\n 'corpus': rules_corpus_id,\\n 'toolkit': 'mitlm'\\n })\\n params = json.dumps(params)\\n response = self.app.post(url('morphemelanguagemodels'), params, self.json_headers, self.extra_environ_admin)\\n resp = json.loads(response.body)\\n morpheme_language_model_id = resp['id']\\n assert resp['name'] == name\\n assert resp['toolkit'] == u'mitlm'\\n assert resp['order'] == 3\\n assert resp['smoothing'] == u'' # The ModKN smoothing algorithm is the implicit default with MITLM\\n\\n # Generate the files of the language model\\n response = self.app.put(url(controller='morphemelanguagemodels', action='generate', id=morpheme_language_model_id),\\n {}, self.json_headers, self.extra_environ_admin)\\n resp = json.loads(response.body)\\n lm_generate_attempt = resp['generate_attempt']\\n\\n # Poll GET /morphemelanguagemodels/id until generate_attempt changes.\\n requester = lambda: self.app.get(url('morphemelanguagemodel', id=morpheme_language_model_id),\\n headers=self.json_headers, extra_environ=self.extra_environ_admin)\\n resp = self.poll(requester, 'generate_attempt', lm_generate_attempt, log, wait=1, vocal=False)\\n assert resp['generate_message'] == u'Language model successfully generated.'\\n\\n ################################################################################\\n # MORPHOLOGICAL PARSER\\n ################################################################################\\n\\n # Create a morphological parser for Blackfoot\\n params = self.morphological_parser_create_params.copy()\\n params.update({\\n 'name': u'Morphological parser for Blackfoot',\\n 'phonology': phonology_id,\\n 'morphology': morphology_id,\\n 'language_model': morpheme_language_model_id\\n })\\n params = json.dumps(params)\\n response = self.app.post(url('morphologicalparsers'), params, self.json_headers, self.extra_environ_admin)\\n resp = json.loads(response.body)\\n morphological_parser_id = resp['id']\\n\\n # Compile the morphological parser's morphophonology script if necessary, cf. precompiled_morphophonology and pregenerated_morphophonology.\\n morphological_parser_directory = os.path.join(self.morphological_parsers_path, 'morphological_parser_%d' % morphological_parser_id)\\n morphophonology_binary_filename = 'morphophonology.foma'\\n morphophonology_script_filename = 'morphological_parser.script'\\n morphophonology_binary_path = os.path.join(morphological_parser_directory, morphophonology_binary_filename )\\n morphophonology_script_path = os.path.join(morphological_parser_directory, morphophonology_script_filename )\\n try:\\n precompiled_morphophonology_path = os.path.join(self.test_morphophonologies_path, precompiled_morphophonology)\\n pregenerated_morphophonology_path = os.path.join(self.test_morphophonologies_path, pregenerated_morphophonology)\\n except Exception:\\n precompiled_morphophonology_path = None\\n pregenerated_morphophonology_path = None\\n if (precompiled_morphophonology_path and pregenerated_morphophonology_path and \\n os.path.exists(precompiled_morphophonology_path) and os.path.exists(pregenerated_morphophonology_path)):\\n # Use the precompiled morphophonology script if it's available,\\n copyfileobj(open(precompiled_morphophonology_path, 'rb'), open(morphophonology_binary_path, 'wb'))\\n copyfileobj(open(pregenerated_morphophonology_path, 'rb'), open(morphophonology_script_path, 'wb'))\\n else:\\n # Generate the parser's morphophonology FST, compile it and generate the morphemic language model\\n response = self.app.put(url(controller='morphologicalparsers', action='generate_and_compile',\\n id=morphological_parser_id), headers=self.json_headers, extra_environ=self.extra_environ_admin)\\n resp = json.loads(response.body)\\n morphological_parser_compile_attempt = resp['compile_attempt']\\n\\n # Generate the parser's morphophonology FST, compile it and generate the morphemic language model\\n response = self.app.put(url(controller='morphologicalparsers', action='generate_and_compile',\\n id=morphological_parser_id), headers=self.json_headers, extra_environ=self.extra_environ_admin)\\n\\n # Poll ``GET /morphologicalparsers/mophological_parser_id`` until ``compile_attempt`` has changed.\\n requester = lambda: self.app.get(url('morphologicalparser', id=morphological_parser_id),\\n headers=self.json_headers, extra_environ=self.extra_environ_admin)\\n resp = self.poll(requester, 'compile_attempt', morphological_parser_compile_attempt, log,\\n wait=10, vocal=True, task_descr='compile morphological parser %s' % morphological_parser_id)\\n assert resp['compile_message'] == \\\\\\n u'Compilation process terminated successfully and new binary file was written.'\\n\\n # Poll ``GET /morphologicalparsers/mophological_parser_id`` until ``compile_attempt`` has changed.\\n requester = lambda: self.app.get(url('morphologicalparser', id=morphological_parser_id),\\n headers=self.json_headers, extra_environ=self.extra_environ_admin)\\n resp = self.poll(requester, 'compile_attempt', morphological_parser_compile_attempt, log,\\n wait=10, vocal=True, task_descr='compile morphological parser %s' % morphological_parser_id)\\n assert resp['compile_message'] == \\\\\\n u'Compilation process terminated successfully and new binary file was written.'\\n\\n # Some reusable transcriptions and their parses\\n transcription1 = u'nitsspiyi'\\n transcription1_correct_parse = u'%s-%s' % (\\n h.rare_delimiter.join([u'nit', u'1', u'agra']),\\n h.rare_delimiter.join([u'ihpiyi', u'dance', u'vai']))\\n transcription1_impoverished_parse = u'nit-ihpiyi'\\n transcription2 = u'aaniit'\\n transcription2_correct_parse = u'%s-%s' % (\\n h.rare_delimiter.join([u'waanii', u'say', u'vai']),\\n h.rare_delimiter.join([u't', u'IMP', u'agrb']))\\n transcription2_impoverished_parse = u'waanii-t'\\n\\n # Test applyup on the mophological parser's morphophonology FST\\n params = json.dumps({'transcriptions': [transcription1, transcription2]})\\n response = self.app.put(url(controller='morphologicalparsers', action='applyup',\\n id=morphological_parser_id), params, self.json_headers, self.extra_environ_admin)\\n resp = json.loads(response.body)\\n if rich_upper:\\n assert transcription1_correct_parse in resp[transcription1]\\n assert transcription2_correct_parse in resp[transcription2]\\n else:\\n assert transcription1_impoverished_parse in resp[transcription1]\\n assert transcription2_impoverished_parse in resp[transcription2]\\n\\n # Test how well the morphological parser parses some test words.\\n params = json.dumps({'transcriptions': [transcription1, transcription2]})\\n response = self.app.put(url(controller='morphologicalparsers', action='parse',\\n id=morphological_parser_id), params, self.json_headers, self.extra_environ_admin)\\n resp = json.loads(response.body)\\n assert resp[transcription1] == transcription1_correct_parse\\n # aaniit will have waaniit 'scatter' as its most likely parse and the correct parse waanii-t 'say-IMP'\\n # as its second most likely...\\n assert resp[transcription2] != transcription2_correct_parse\\n\\n\\n\\n \\\"\\\"\\\"\\n\\n\\n ################################################################################\\n # LOUIE MORPHOLOGY\\n ################################################################################\\n\\n # Create a form search that returns forms containing analyzed words elicited by Louie.\\n\\n conjuncts = [['or', [['Form', 'syntactic_category', 'name', '=', u'sent'],\\n ['Form', 'morpheme_break', 'like', '% %'],\\n ['Form', 'morpheme_break', 'like', '%-%']]],\\n ['Form', 'syntactic_category_string', '!=', None],\\n ['Form', 'grammaticality', '=', ''],\\n ['Form', 'elicitor', 'last_name', '=', 'Louie']]\\n query = {'filter': ['and', conjuncts]}\\n\\n params = self.form_search_create_params.copy()\\n params.update({\\n 'name': u'Forms containing analyzed words elicited by Louie',\\n 'search': query\\n })\\n params = json.dumps(params)\\n response = self.app.post(url('formsearches'), params, self.json_headers, self.extra_environ_admin)\\n louie_form_search_id = json.loads(response.body)['id']\\n\\n params = self.corpus_create_params.copy()\\n params.update({\\n 'name': u'Corpus of forms containing analyzed words elicited by Louie',\\n 'form_search': louie_form_search_id\\n })\\n params = json.dumps(params)\\n response = self.app.post(url('corpora'), params, self.json_headers, self.extra_environ_admin)\\n louie_corpus_id = json.loads(response.body)['id']\\n\\n # Now create a morphology using the Louie corpus as both the lexicon and rules corpora.\\n rich_upper = False\\n name = u'Morphology of Blackfoot based on words elicited by Louie'\\n params = self.morphology_create_params.copy()\\n params.update({\\n 'name': name,\\n 'lexicon_corpus': louie_corpus_id,\\n 'rules_corpus': louie_corpus_id,\\n 'script_type': u'regex',\\n 'extract_morphemes_from_rules_corpus': True,\\n 'rich_upper': rich_upper\\n })\\n params = json.dumps(params)\\n response = self.app.post(url('morphologies'), params, self.json_headers, self.extra_environ_admin_appset)\\n resp = json.loads(response.body)\\n louie_morphology_id = resp['id']\\n assert resp['name'] == name\\n assert resp['script_type'] == u'regex'\\n\\n # Generate the morphology's script without compiling it.\\n response = self.app.put(url(controller='morphologies', action='generate',\\n id=louie_morphology_id), headers=self.json_headers,\\n extra_environ=self.extra_environ_contrib)\\n resp = json.loads(response.body)\\n generate_attempt = resp['generate_attempt']\\n\\n # Poll ``GET /morphologies/morphology_id`` until ``generate_attempt`` has changed.\\n seconds_elapsed = 0\\n wait = 2\\n while True:\\n response = self.app.get(url('morphology', id=louie_morphology_id),\\n headers=self.json_headers, extra_environ=self.extra_environ_contrib)\\n resp = json.loads(response.body)\\n if generate_attempt != resp['generate_attempt']:\\n log.debug('Generate attempt for morphology %d has terminated.' % louie_morphology_id)\\n break\\n else:\\n log.debug('Waiting for morphology %d\\\\'s script to generate: %s' % (\\n louie_morphology_id, self.human_readable_seconds(seconds_elapsed)))\\n sleep(wait)\\n seconds_elapsed = seconds_elapsed + wait\\n\\n\\n ################################################################################\\n # MORPHEME LANGUAGE MODEL -- LOUIE\\n ################################################################################\\n\\n # Create a morpheme language model based on the data elicited by Louie\\n name = u'Blackfoot morpheme language model based on data elicited by Louie'\\n params = self.morpheme_language_model_create_params.copy()\\n params.update({\\n 'name': name,\\n 'corpus': louie_corpus_id,\\n 'toolkit': 'mitlm'\\n })\\n params = json.dumps(params)\\n response = self.app.post(url('morphemelanguagemodels'), params, self.json_headers, self.extra_environ_admin)\\n resp = json.loads(response.body)\\n louie_language_model_id = resp['id']\\n assert resp['name'] == name\\n assert resp['toolkit'] == u'mitlm'\\n assert resp['order'] == 3\\n assert resp['smoothing'] == u'' # The ModKN smoothing algorithm is the implicit default with MITLM\\n\\n # Generate the files of the language model\\n response = self.app.put(url(controller='morphemelanguagemodels', action='generate',\\n id=louie_language_model_id),\\n {}, self.json_headers, self.extra_environ_admin)\\n resp = json.loads(response.body)\\n lm_generate_attempt = resp['generate_attempt']\\n\\n # Poll GET /morphemelanguagemodels/id until generate_attempt changes.\\n requester = lambda: self.app.get(url('morphemelanguagemodel', id=louie_language_model_id),\\n headers=self.json_headers, extra_environ=self.extra_environ_admin)\\n resp = self.poll(requester, 'generate_attempt', lm_generate_attempt, log, wait=1, vocal=False)\\n assert resp['generate_message'] == u'Language model successfully generated.'\\n\\n ################################################################################\\n # MORPHOLOGICAL PARSER -- LOUIE\\n ################################################################################\\n\\n # Create a morphological parser for Blackfoot based on data elicited by Louie\\n params = self.morphological_parser_create_params.copy()\\n params.update({\\n 'name': u'Morphological parser for Blackfoot based on data elicited by Louie',\\n 'phonology': phonology_id,\\n 'morphology': louie_morphology_id,\\n 'language_model': louie_language_model_id\\n })\\n params = json.dumps(params)\\n response = self.app.post(url('morphologicalparsers'), params, self.json_headers,\\n self.extra_environ_admin)\\n resp = json.loads(response.body)\\n louie_parser_id = resp['id']\\n\\n # Compile the morphological parser's morphophonology script if necessary, cf.\\n # precompiled_morphophonology and pregenerated_morphophonology.\\n morphological_parser_directory = os.path.join(self.morphological_parsers_path,\\n 'morphological_parser_%d' % louie_parser_id)\\n morphophonology_binary_filename = 'morphophonology.foma'\\n morphophonology_script_filename = 'morphological_parser.script'\\n morphophonology_binary_path = os.path.join(morphological_parser_directory,\\n morphophonology_binary_filename )\\n morphophonology_script_path = os.path.join(morphological_parser_directory,\\n morphophonology_script_filename )\\n try:\\n precompiled_morphophonology_path = os.path.join(self.test_morphophonologies_path,\\n precompiled_morphophonology)\\n pregenerated_morphophonology_path = os.path.join(self.test_morphophonologies_path,\\n pregenerated_morphophonology)\\n except Exception:\\n precompiled_morphophonology_path = None\\n pregenerated_morphophonology_path = None\\n if (precompiled_morphophonology_path and pregenerated_morphophonology_path and \\n os.path.exists(precompiled_morphophonology_path) and os.path.exists(pregenerated_morphophonology_path)):\\n # Use the precompiled morphophonology script if it's available,\\n copyfileobj(open(precompiled_morphophonology_path, 'rb'), open(morphophonology_binary_path, 'wb'))\\n copyfileobj(open(pregenerated_morphophonology_path, 'rb'), open(morphophonology_script_path, 'wb'))\\n else:\\n # Generate the parser's morphophonology FST, compile it and generate the morphemic language model\\n response = self.app.put(url(controller='morphologicalparsers', action='generate_and_compile',\\n id=louie_parser_id), headers=self.json_headers, extra_environ=self.extra_environ_admin)\\n resp = json.loads(response.body)\\n morphological_parser_compile_attempt = resp['compile_attempt']\\n\\n # Generate the parser's morphophonology FST, compile it and generate the morphemic language model\\n response = self.app.put(url(controller='morphologicalparsers', action='generate_and_compile',\\n id=louie_parser_id), headers=self.json_headers, extra_environ=self.extra_environ_admin)\\n\\n # Poll ``GET /morphologicalparsers/mophological_parser_id`` until ``compile_attempt`` has changed.\\n requester = lambda: self.app.get(url('morphologicalparser', id=louie_parser_id),\\n headers=self.json_headers, extra_environ=self.extra_environ_admin)\\n resp = self.poll(requester, 'compile_attempt', morphological_parser_compile_attempt, log,\\n wait=10, vocal=True, task_descr='compile morphological parser %s' % louie_parser_id)\\n assert resp['compile_message'] == \\\\\\n u'Compilation process terminated successfully and new binary file was written.'\\n\\n # Poll ``GET /morphologicalparsers/mophological_parser_id`` until ``compile_attempt`` has changed.\\n requester = lambda: self.app.get(url('morphologicalparser', id=louie_parser_id),\\n headers=self.json_headers, extra_environ=self.extra_environ_admin)\\n resp = self.poll(requester, 'compile_attempt', morphological_parser_compile_attempt, log,\\n wait=10, vocal=True, task_descr='compile morphological parser %s' % louie_parser_id)\\n assert resp['compile_message'] == \\\\\\n u'Compilation process terminated successfully and new binary file was written.'\\n\\n # Some reusable transcriptions and their parses\\n transcription1 = u'nitsspiyi'\\n transcription1_correct_parse = u'%s-%s' % (\\n h.rare_delimiter.join([u'nit', u'1', u'agra']),\\n h.rare_delimiter.join([u'ihpiyi', u'dance', u'vai']))\\n transcription1_impoverished_parse = u'nit-ihpiyi'\\n transcription2 = u'aaniit'\\n transcription2_correct_parse = u'%s-%s' % (\\n h.rare_delimiter.join([u'waanii', u'say', u'vai']),\\n h.rare_delimiter.join([u't', u'IMP', u'agrb']))\\n transcription2_impoverished_parse = u'waanii-t'\\n\\n # Test applyup on the mophological parser's morphophonology FST\\n params = json.dumps({'transcriptions': [transcription1, transcription2]})\\n response = self.app.put(url(controller='morphologicalparsers', action='applyup',\\n id=louie_parser_id), params, self.json_headers, self.extra_environ_admin)\\n resp = json.loads(response.body)\\n if rich_upper:\\n assert transcription1_correct_parse in resp[transcription1]\\n assert transcription2_correct_parse not in resp[transcription2]\\n else:\\n assert transcription1_impoverished_parse in resp[transcription1]\\n assert transcription2_impoverished_parse not in resp[transcription2]\\n\\n # Test how well the morphological parser parses some test words.\\n params = json.dumps({'transcriptions': [transcription1, transcription2]})\\n response = self.app.put(url(controller='morphologicalparsers', action='parse',\\n id=louie_parser_id), params, self.json_headers, self.extra_environ_admin)\\n resp = json.loads(response.body)\\n assert resp[transcription1] == transcription1_correct_parse\\n # aaniit will have waaniit 'scatter' as its most likely parse and the correct parse waanii-t 'say-IMP'\\n # as its second most likely...\\n assert resp[transcription2] != transcription2_correct_parse\\n\\n\\n # Finally, load the original database back in so that subsequent tests can work.\\n with open(tmp_script_path, 'w') as tmpscript:\\n tmpscript.write('#!/bin/sh\\\\nmysql -u %s -p%s %s < %s' % (username, password, db_name, backup_dump_file_path))\\n with open(os.devnull, \\\"w\\\") as fnull:\\n call([tmp_script_path], stdout=fnull, stderr=fnull)\\n os.remove(tmp_script_path)\\n os.remove(backup_dump_file_path)\\n\\n # Implement category-based class LMs and test them against morpheme-based ones.\\n # Build multiple Bf morphological parsers and test them out, find the best one, write a paper on it!\",\n \"def _load_test_data(self):\\n\\n self.test_loader = data.Test_loader(self.N_max, self.n_per_conn,\\n self.data_path, self.device)\\n\\n self.test_loader.load_data()\\n\\n # load mean and std from train\\n scc_mean_std = np.loadtxt(\\n os.path.join(self.data_path, 'scc_mean_std.csv'), delimiter=',')\\n self.mean = torch.Tensor(scc_mean_std[0])\\n self.std = torch.Tensor(scc_mean_std[1])\",\n \"def test_income():\\n test_path = tempfile.mkdtemp()\\n x_train, metadata = income(test_path)\\n try:\\n assert x_train.shape == (44, 4)\\n except:\\n shutil.rmtree(test_path)\\n raise()\",\n \"def test_get_mnist_data(self):\\n # TODO: Remove once get_mnist_data(...) is fixed.\\n pass\\n # mnist = get_mnist_data()\\n # self.assertEqual(len(mnist.data), 60000)\\n # self.assertEqual(len(mnist.labels), 60000)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6878423","0.6717447","0.66107994","0.6513562","0.64724684","0.6419172","0.635929","0.63393587","0.6322275","0.6305654","0.6271661","0.6262919","0.6250121","0.62494475","0.6245525","0.6239293","0.62058556","0.61902046","0.61705625","0.615137","0.6088381","0.6088035","0.60806745","0.6071837","0.6068435","0.6050993","0.6012012","0.6005831","0.6002931","0.59972286","0.5996182","0.59872067","0.5986804","0.5981131","0.5970025","0.59659684","0.5928484","0.5917993","0.5908277","0.5895235","0.5892047","0.58893734","0.58815444","0.5869902","0.58642554","0.5852821","0.5850442","0.58482057","0.5847811","0.5840844","0.5838442","0.5837475","0.5832688","0.5825508","0.5825508","0.58248246","0.5824666","0.5822631","0.5819901","0.5814439","0.58027995","0.5795979","0.5790869","0.5787777","0.57764524","0.57716197","0.5770973","0.5768669","0.5767273","0.5763533","0.5762509","0.57550955","0.57542163","0.5751685","0.5748207","0.57468784","0.57442576","0.5744172","0.57441014","0.5742329","0.5742329","0.5737742","0.57364744","0.57351726","0.5733789","0.5731187","0.5729076","0.57280517","0.57240725","0.57220286","0.5719414","0.5715694","0.5715279","0.5710077","0.57081044","0.57053834","0.57045674","0.5700325","0.5699108","0.5698457"],"string":"[\n \"0.6878423\",\n \"0.6717447\",\n \"0.66107994\",\n \"0.6513562\",\n \"0.64724684\",\n \"0.6419172\",\n \"0.635929\",\n \"0.63393587\",\n \"0.6322275\",\n \"0.6305654\",\n \"0.6271661\",\n \"0.6262919\",\n \"0.6250121\",\n \"0.62494475\",\n \"0.6245525\",\n \"0.6239293\",\n \"0.62058556\",\n \"0.61902046\",\n \"0.61705625\",\n \"0.615137\",\n \"0.6088381\",\n \"0.6088035\",\n \"0.60806745\",\n \"0.6071837\",\n \"0.6068435\",\n \"0.6050993\",\n \"0.6012012\",\n \"0.6005831\",\n \"0.6002931\",\n \"0.59972286\",\n \"0.5996182\",\n \"0.59872067\",\n \"0.5986804\",\n \"0.5981131\",\n \"0.5970025\",\n \"0.59659684\",\n \"0.5928484\",\n \"0.5917993\",\n \"0.5908277\",\n \"0.5895235\",\n \"0.5892047\",\n \"0.58893734\",\n \"0.58815444\",\n \"0.5869902\",\n \"0.58642554\",\n \"0.5852821\",\n \"0.5850442\",\n \"0.58482057\",\n \"0.5847811\",\n \"0.5840844\",\n \"0.5838442\",\n \"0.5837475\",\n \"0.5832688\",\n \"0.5825508\",\n \"0.5825508\",\n \"0.58248246\",\n \"0.5824666\",\n \"0.5822631\",\n \"0.5819901\",\n \"0.5814439\",\n \"0.58027995\",\n \"0.5795979\",\n \"0.5790869\",\n \"0.5787777\",\n \"0.57764524\",\n \"0.57716197\",\n \"0.5770973\",\n \"0.5768669\",\n \"0.5767273\",\n \"0.5763533\",\n \"0.5762509\",\n \"0.57550955\",\n \"0.57542163\",\n \"0.5751685\",\n \"0.5748207\",\n \"0.57468784\",\n \"0.57442576\",\n \"0.5744172\",\n \"0.57441014\",\n \"0.5742329\",\n \"0.5742329\",\n \"0.5737742\",\n \"0.57364744\",\n \"0.57351726\",\n \"0.5733789\",\n \"0.5731187\",\n \"0.5729076\",\n \"0.57280517\",\n \"0.57240725\",\n \"0.57220286\",\n \"0.5719414\",\n \"0.5715694\",\n \"0.5715279\",\n \"0.5710077\",\n \"0.57081044\",\n \"0.57053834\",\n \"0.57045674\",\n \"0.5700325\",\n \"0.5699108\",\n \"0.5698457\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.74175483"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":89889,"cells":{"query":{"kind":"string","value":"Constructor. Sets the parent, sets up the UI and fills the tree."},"document":{"kind":"string","value":"def __init__(self, iface=None):\n parent = None if iface is None else iface.mainWindow()\n super(DockWidget, self).__init__(parent)\n # Set up the user interface from Designer.\n # After setupUI you can access any designer object by doing\n # self.<objectname>, and you can use autoconnect slots - see\n # http://qt-project.org/doc/qt-4.8/designer-using-a-ui-file.html\n # #widgets-and-dialogs-with-auto-connect\n\n self.config = QSettings()\n self.readconfig()\n\n self.setupUi(self)\n\n self.iface = iface"},"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 create(self, parent):\n self.widget = QtGui.QTreeView(parent)","def __init__(self, parent=None):\n super(Representative, self).__init__(parent)\n self.setupUi(self)","def __init__(self,parent, id = wx.ID_ANY, pos = (10,10), size=(-1,-1)):\n\n wx.TreeCtrl.__init__(self, parent, id,pos,size,style =\n wx.TR_HIDE_ROOT | wx.TR_HAS_BUTTONS |\n wx.TR_HAS_VARIABLE_ROW_HEIGHT)\n\n self.root = self.AddRoot(\"Top\")\n self.classes = []\n self.base_cls = []","def __init__(self, parent: View):\n self.parent = parent\n self.root = self.parent.root\n # Content frame\n self.frame = tk.Frame(self.parent.frame)\n # Reference\n self.visible = False","def __init__(self):\n super().__init__()\n self.root = tk.Tk() # different Tk than this class.\n self.root.title(\"Python Pyui!\")\n self.top_frame = tk.Frame(self.root, bg=\"yellow\")\n self.top_frame.pack(fill=c.BOTH, expand=1)\n self.bottom_frame = tk.Frame(self.root, bg=\"blue\",\n borderwidth=1, relief=c.RAISED)\n self.bottom_frame.pack(fill=c.X)\n okButton = tk.Button(self.bottom_frame, text=\"OK\",\n command=self.cb_ok)\n okButton.pack(fill='none', padx=5, pady=5, side=c.RIGHT)\n cancelButton = tk.Button(self.bottom_frame, text=\"Cancel\",\n command=self.cb_cancel)\n cancelButton.pack(fill='none', padx=5, pady=5, side=c.RIGHT)\n\n self.not_cancelled = False\n self.current_parent = self.top_frame\n self.parent_is_grid= False\n self.entries = {}","def __init__(self, parent=None):\n self._window = None\n\n self.setup_ui()","def __init__(self, parent):\n self._parent = parent","def __init__(self, parent, name=wx.PanelNameStr):\n super(FilesTreeViewCtrl, self).__init__(parent, name)\n\n # Create an instance of our model and associate to the view.\n self._model = FilesTreeViewModel()\n self.AssociateModel(self._model)\n self._model.DecRef()\n\n # Create the columns that the model wants in the view.\n for i in range(self._model.GetColumnCount()):\n col = BaseTreeViewCtrl._create_column(self._model, i)\n if i == self._model.GetExpanderColumn():\n self.SetExpanderColumn(col)\n wx.dataview.DataViewCtrl.AppendColumn(self, col)\n\n # Bind events.\n # Used to remember the expend/collapse status of items after a refresh.\n self.Bind(wx.dataview.EVT_DATAVIEW_ITEM_EXPANDED, self._on_item_expanded)\n self.Bind(wx.dataview.EVT_DATAVIEW_ITEM_COLLAPSED, self._on_item_collapsed)\n self.Bind(wx.dataview.EVT_DATAVIEW_ITEM_ACTIVATED, self._on_item_activated)\n self.Bind(wx.dataview.EVT_DATAVIEW_SELECTION_CHANGED, self._on_item_selection_changed)","def __init__(self, parent: View):\n super().__init__(parent)\n # Crossword title\n self.title = tk.StringVar(self.root)\n self.title_label = tk.Label(self.frame, textvariable=self.title)\n # Crossword author\n self.author = tk.StringVar(self.root)\n self.author_label = tk.Label(self.frame, textvariable=self.author)\n # Dividing line separating the header and other groups\n self.separator = tk.Frame(self.frame)\n # Load\n self.load()","def __init__(self, parent=None):\n super(RobotSelection, self).__init__(parent)\n self.parent = parent\n self.initUI()","def __init__(self, treeView, isChildView=True, parent=None):\n super().__init__(parent)\n self.treeView = treeView\n self.isChildView = isChildView\n self.hideChildView = not globalref.genOptions['InitShowChildPane']\n self.setAcceptRichText(False)\n self.setLineWrapMode(QTextEdit.NoWrap)\n self.setTabChangesFocus(True)\n self.setUndoRedoEnabled(False)\n self.treeSelectAction = QAction(_('Select in Tree'), self)\n self.treeSelectAction.triggered.connect(self.selectLineInTree)\n self.textChanged.connect(self.readChange)","def __init__(self, parent):\r\n Frame.__init__(self, parent) \r\n \r\n self.parent = parent\r\n self.initUI()","def __init__(self, parent):\n if isinstance(parent, Node):\n self.parent = parent\n self.tree = parent.tree\n self.depth = parent.depth + 1\n else:\n self.parent = None\n self.tree = parent\n self.depth = 0\n self.children = []\n self.childrencreated = 0\n self.expanded = 0\n self.selected = 0\n \n self.text_id = 0\n self.image_id = 0\n self.minusplus_id = 0\n \n self.oldy = -1000\n self.changed = 0\n \n if not self.parent: self.tree._setnode(self) # Root Node must be passed to the tree.","def _setupUi(self):\n self.setupUi(self)\n self.twTree.setStyleSheet(\"background-color: rgb(200, 200, 200)\")","def gui_init(self):\n if not self.parent is None:\n self.parent.children.append(self)\n self.children = []\n self.priority = PRIORITY_GUI_ELEMENTS","def __init__(self, parent=None):\n super(Inj, self).__init__(parent)\n self.setupUi(self)","def __init__(self, root, *args, **kwargs):\n super().__init__(root, *args, **kwargs)\n self._Master = root\n self._Master.resizable(self.resize_x, self.resize_y)\n self.winfo_toplevel().title(self.title)\n\n self._PendingJobs = {\n \"event-lock\": None,\n }\n\n self._EventLock = False\n\n # Menu bar\n self._BooleanVars = {}\n self._Buttons = {}\n self._Canvases = {}\n self._Checkboxes = {}\n self._Entries = {}\n self._Frames = {}\n self._Labels = {}\n self._Menus = {\"main-menu\": tk.Menu(self._Master)}\n self._OptionMenus = {}\n self._RadioButtons = {}\n self._StringVars = {}\n\n self.init_all_frames()\n self.init_all_buttons()\n self.init_all_canvases()\n self.init_all_checkboxes()\n self.init_all_entries()\n self.init_all_labels()\n self.init_all_menus()\n self.init_all_optionmenus()\n self.init_all_radiobuttons()","def __init__(self, parent: QWidget, gui: 'MetalGUI', view: QTreeView):\n super().__init__(parent=parent,\n gui=gui,\n view=view,\n child='GDS renderer')","def __init__(self, parent: QWidget):\n super().__init__(parent)\n DiagramFieldView.__diagram_field = self\n\n self.__list: List[DiagramView] = []\n self.__dialog: Dialog = None\n self.__diagram_layout: QVBoxLayout = QVBoxLayout()\n self.__button_layout: QHBoxLayout = QHBoxLayout()\n self.__start_button: StartButtonView = StartButtonView()\n self.__maximize_button: QPushButton = QPushButton()\n\n self.__diagram_group: QtWidgets.QGroupBox = QtWidgets.QGroupBox(self)\n self.__group_layout: QtWidgets.QVBoxLayout = QtWidgets.QVBoxLayout(self.__diagram_group)\n self.__stretch_widget: QtWidgets.QWidget = QtWidgets.QWidget(self)\n self.__diagram_count: int = 0\n\n self.__start_button.start_signal.connect(self.__clear_diagrams)\n self.__maximize_button.clicked.connect(self.__maximize_on_click)\n ManagerModel.set_diagram_notifier(self)\n self.__init_ui()","def construct(self):\n top = Toplevel()\n top.withdraw()\n top.protocol(\"WM_DELETE_WINDOW\", self.view_xml_pane)\n top.columnconfigure(0, weight=1)\n top.rowconfigure(0, weight=1)\n top.title(\"XML Preview\")\n self._pane = top\n\n xml_area = Text(top, borderwidth=2, relief=\"sunken\")\n xml_area.config(font=(\"consolas\", 12), undo=True, wrap='word', state=DISABLED)\n xml_area.grid(row=0, column=0, sticky=\"nsew\", padx=2, pady=2)\n\n scrollbar = Scrollbar(top, command=xml_area.yview)\n scrollbar.grid(row=0, column=1, sticky='nsew')\n xml_area['yscrollcommand'] = scrollbar.set\n\n self._text_area = xml_area","def __init__(self):\n self.view = GuiView(self)\n return","def __init__(self, parent=None):\n super(QCTP, self).__init__(parent)\n self.setupUi(self)","def __init__(self, parent=None):\n super(Form, self).__init__(parent)\n self.setupUi(self)","def __init__(self, parent=None):\n super(Form, self).__init__(parent)\n self.setupUi(self)","def __create_ui(self):\n vbox = gtk.VBox()\n\n # Create the viewable area of the file browser\n self.__view_port = gtk.ScrolledWindow()\n self.__view_port.set_policy(gtk.POLICY_AUTOMATIC,\n gtk.POLICY_AUTOMATIC)\n # Create the tree view and add it to the viewable area\n self.__tree_view = ProjectTreeView()\n self.__project_explorer = ProjectExplorer(self.window, self.__tree_view)\n self.__tree_view.connect('button_press_event',\n self.__on_treeview_button_press_event)\n self.__project_explorer.set_repository()\n self.__view_port.add(self.__tree_view)\n # Create the toolbar\n hbox = gtk.HBox()\n toolbar = gtk.Toolbar()\n toolbar.set_style(gtk.TOOLBAR_ICONS)\n toolbar.set_icon_size(gtk.ICON_SIZE_MENU)\n back = gtk.ToolButton(gtk.STOCK_GO_UP)\n back.connect('clicked', self.__on_back_clicked)\n toolbar.insert(back, 0)\n toolbar.insert(gtk.SeparatorToolItem(), 1)\n refresh = gtk.ToolButton(gtk.STOCK_REFRESH)\n refresh.connect('clicked', self.__on_refresh_clicked)\n toolbar.insert(refresh, 2)\n hbox.pack_start(toolbar, True, True, 0)\n vbox.pack_start(hbox, False, False, 0)\n vbox.pack_start(self.__view_port, True, True, 0)\n\n # Setup the create the buttons for:\n # New File, New Folder\n # ----------------------------------------------------------------------\n hbox1 = gtk.VBox()\n toolbar_actions = gtk.Toolbar()\n toolbar_actions.set_style(gtk.TOOLBAR_ICONS)\n toolbar_actions.set_icon_size(gtk.ICON_SIZE_MENU)\n new_file = gtk.ToolButton(gtk.STOCK_NEW)\n new_file.connect('clicked', self.__on_new_file_clicked_cb)\n toolbar_actions.insert(new_file, 0)\n new_dir = gtk.ToolButton(gtk.STOCK_OPEN) # TODO: use a custom icon\n new_dir.connect('clicked', self.__on_new_dir_clicked_cb)\n toolbar_actions.insert(new_dir, 1)\n hbox1.pack_start(gtk.HSeparator(), True, True, 0)\n hbox1.pack_start(toolbar_actions, True, True, 0)\n vbox.pack_end(hbox1, False, False, 0)\n # ----------------------------------------------------------------------\n vbox.show_all()\n # Attach the project explorer to GMate's side panel\n self.__side_panel = self.window.get_side_panel()\n self.__side_panel.add_tab(vbox, msg0005, gtk.STOCK_HARDDISK)","def __init__(self, parent=None):\n super(MainWindow, self).__init__(parent)\n self.setupUi(self)","def __init__(self, parent=None):\n super(MainWindow, self).__init__(parent)\n self.setupUi(self)","def __init__(self, parent=None):\n super(MainWindow, self).__init__(parent)\n self.setupUi(self)","def __init__(self, parent=None):\n super(MainWindow, self).__init__(parent)\n self.setupUi(self)","def __init__(self, parent=None):\n super(MainWindow, self).__init__(parent)\n self.setupUi(self)","def __init__(self, parent):\n self.parent = parent\n self.dialog = None","def __init__(self, parent=None):\n super(Dialog, self).__init__(parent)\n self.setupUi(self)","def __init__(self, parent):\n self.name = \"Base.View\"\n self.parent = parent\n self.Main = parent.Main","def __init__(self, parent):\n pass","def __init__(self, parent):\n pass","def __init__(self, parent):\n pass","def init_ui(self):\n self.master.title(\"Backbone\")\n self.master.geometry(\"300x150\")\n\n self.pack(fill=BOTH, expand=1)\n\n self.btn_upload_file = Button(self, text=\"Upload file\", command=self.upload_file)\n self.btn_upload_file.place(x=90, y=10)\n\n self.btn_create_training_file = Button(self, text=\"Create & upload training file\",\n command=self.create_training_file)\n self.btn_create_training_file.place(x=30, y=40)\n\n self.btn_run_algorithm = Button(self, text=\"Run algorithm\", command=self.run_algorithm)\n self.btn_run_algorithm.place(x=80, y=70)\n\n self.btn_view_results = Button(self, text=\"View Results\", command=self.view_results)\n self.btn_view_results.place(x=85, y=100)","def __init__(self, parent=None):\n super(MainWindow, self).__init__(parent)\n self.setupUi(self)\n self.path=''\n self.bool=0\n self.child=0\n self.click=\" \"","def __init__(self):\n Tree.__init__(self, \"\")","def __init__(self, root=None):\n self.set_root(root)","def build_gui(self):\n tip = _('Double-click on a row to edit the selected child.')\n self.set_tooltip(tip)\n top = Gtk.TreeView()\n titles = [('', NOSORT, 50,),\n (_('Child'), 1, 250),\n (_('Birth Date'), 3, 100),\n ('', 3, 100),\n (_('Death Date'), 5, 100),\n ('', 5, 100)]\n self.model = ListModel(top, titles, event_func=self.edit_person)\n return top","def build_gui(self):\n tip = _('Double-click on a row to edit the selected child.')\n self.set_tooltip(tip)\n top = Gtk.TreeView()\n titles = [('', NOSORT, 50,),\n (_('Child'), 1, 250),\n (_('Birth Date'), 3, 100),\n ('', 3, 100),\n (_('Death Date'), 5, 100),\n ('', 5, 100),\n (_('Spouse'), 6, 250)]\n self.model = ListModel(top, titles, event_func=self.edit_person)\n return top","def __init__(self):\n super(GraphVisualizerCase, self).__init__()\n\n self._v_layout = QVBoxLayout()\n self.setLayout(self._v_layout)\n\n top_label_layout = QHBoxLayout()\n self._v_layout.addLayout(top_label_layout)\n\n self._top_left_label = MathTextLabel()\n top_label_layout.addWidget(self._top_left_label)\n self._top_right_label = MathTextLabel()\n top_label_layout.addWidget(self._top_right_label)\n\n self._center_widget = QFrame()\n self._center_text_label = QLabel()\n self._center_text_label.setAlignment(Qt.AlignCenter)\n layout = QHBoxLayout()\n layout.addWidget(self._center_text_label)\n self._center_widget.setLayout(layout)\n\n self._v_layout.addWidget(self._center_widget)\n\n bot_label_layout = QHBoxLayout()\n self._v_layout.addLayout(bot_label_layout)\n\n self._bot_left_label = MathTextLabel()\n bot_label_layout.addWidget(self._bot_left_label)\n self._bot_right_label = MathTextLabel()\n bot_label_layout.addWidget(self._bot_right_label)","def __init__( self, window_size=QSize( DEFAULT_H_SIZE, DEFAULT_V_SIZE ) ):\n super().__init__()\n\n self.centralWidget = None\n self.window_size = window_size\n\n self.create_models()\n self.create_widgets()\n self.create_layout()\n self.create_menus()\n self.set_state()","def __init__(self: object) -> None:\n super().__init__()\n self.title(\"dnazip\")\n self.configure(bg='#ebebeb')\n self.create_main()\n self.create_menu()\n self.create_buttons()\n self.file = None","def create(self, parent):\n self.widget = QtCore.QObject(parent)","def __init__(self):\r\n super().__init__()\r\n self.init_ui()","def __init__(self, parent, maze_width, maze_height, scale=20):\n self.parent = parent\n self.parent.title(\"Maze Exploration Visualization\")\n\n self.maze_width = maze_width\n self.maze_height = maze_height\n self.scale = scale\n\n # Compute actual width and height\n self.width = maze_width * scale\n self.height = maze_height * scale\n\n # Store tkinter object\n self.frame = tkinter.Frame(self.parent,\n width=self.width,\n height=self.height,\n highlightthickness=1,\n highlightbackground=\"black\")\n self.canvas = tkinter.Canvas(self.frame,\n width=self.width, \n height=self.height)\n self.canvas.pack(expand=False)\n self.frame.pack(expand=False)\n\n # Initialize look of grid\n self.draw_gray_grid()\n\n self.person = None\n self.draw_person(self.maze_width // 2, self.maze_height // 2)","def __init__(self):\n self.root = None","def __init__(self):\n self.root = None","def __init__(self, parent=None):\n super(union_Dialog, self).__init__(parent)\n self.setupUi(self)","def __init__(self, tree):\n self._tree = tree","def __init__(self, tree):\n self._tree = tree","def __init__(self, parent=None):\n super().__init__(parent)\n\n # Filters on the model\n self.filters = Filters.NoFilter\n self.sorting = Sorting.Date\n\n # Contains all the submitted levels.\n # Key: level code\n # Value: Level instance\n self.levels_dict = {}\n self.dict_lock = threading.RLock() # Prevent access racing on levels dict\n\n # Contains all the levels that should be shown to the view\n # The index in this list is the row for the view.\n self.view_list = []\n self.view_keys = [] # keys for sorting the view\n self.list_lock = threading.RLock() # Prevent access racing on view list","def __init__(self):\n # Passing the class make this Python 2 and Python 3 compatible\n super(MayaSceneLevelGeneratorUI, self).__init__(parent=maya_main_window())\n\n # Create the generators needed\n self._level_gen = level.LevelGenerator([blocks.BlockFile(\"\", blk_type) for blk_type in VALID_BLOCK_TYPES])\n self._scene_gen = MayaSceneLevelGenerator(None) # Fill in level at button press time\n\n # Window things\n self.setWindowTitle(\"Maya Scene Level Generator\")\n self.resize(500, 200)\n self.setWindowFlags(self.windowFlags() ^ PySide2.QtCore.Qt.WindowContextHelpButtonHint)\n\n # Set up for the first time\n self._create_widgets()\n self._create_layout()\n self._refresh_view()\n self._create_connections() # Order matters, since refreshing triggers connections\n\n print(self._level_gen.block_list) # TODO delete","def __init__(self, parent=None):\n super(addOne, self).__init__(parent)\n self.setupUi(self)\n \n # 内部自定义初始化操作 ---------------------------------------------------------------------begin\n self.zShow = Fdebug(self);\n self.zShow.show();\n self.verticalLayout.insertWidget(0, self.zShow)","def __init__(self, parent):\n super(StageVisualizer, self).__init__(parent)\n\n self.figure = matplotlib.figure.Figure()\n self.axes = self.figure.add_subplot(111)\n self.figure.subplots_adjust(top=1, bottom=0, right=1, left=0)\n\n self.axes.get_xaxis().set_visible(False)\n self.axes.get_yaxis().set_visible(False)\n\n self.canvas = FigureCanvas(self, -1, self.figure)\n\n self.sizer = wx.BoxSizer(wx.VERTICAL)\n self.sizer.Add(self.canvas, 1, wx.LEFT | wx.TOP | wx.GROW)\n self.SetSizer(self.sizer)\n\n self.toolbar = NavigationToolbar(self.canvas)\n self.toolbar.pan()\n self.toolbar.Hide()\n\n self.Fit()\n\n self.zoomer = self.zoom_factory(self.axes, base_scale=1.5)\n\n self.canvas.Bind(wx.EVT_PAINT, self.on_paint)","def init_ui(self):\n # Create GUI elements, set them in dict structure\n labelwidth = 150\n\n # Add parameter line edit for Factor Tm to Tp\n self.input_elements['factor Tm Tp'] = widgets.ParameterInputLine(\n label='Factor Tm naar Tp:',\n labelwidth=labelwidth,\n unitlabel='(NVT: Tp aanwezig)' if 'Tp' in self.hydraulic_loads.columns else '',\n validator=QtGui.QDoubleValidator(0.01, 99.99, 20),\n )\n\n if 'Tp' in self.hydraulic_loads.columns or self.parent_tab.step != 'I1':\n self.input_elements['factor Tm Tp'].set_enabled(False)\n\n # Add line edit with browsebutton for Master template\n self.input_elements['mastertemplate'] = widgets.ExtendedLineEdit(\n label='Master template bestand:',\n labelwidth=labelwidth,\n browsebutton=QtWidgets.QPushButton('...', clicked=self.select_master_template)\n )\n\n # Add line edit with browsebutton for depth file\n self.input_elements['depthfile'] = widgets.ExtendedLineEdit(\n label='Bathymetry bestand:',\n labelwidth=labelwidth,\n browsebutton=QtWidgets.QPushButton('...', clicked=self.select_bathymetry_file)\n )\n\n # Add line edit with browsebutton for swan result folder\n self.input_elements['swanfolder'] = widgets.ExtendedLineEdit(\n label='SWAN uitvoer folder:',\n labelwidth=labelwidth,\n browsebutton=QtWidgets.QPushButton('...', clicked=self.select_swan_folder)\n )\n\n\n self.setLayout(QtWidgets.QVBoxLayout())\n self.layout().setSpacing(10)\n\n for _, item in self.input_elements.items():\n self.layout().addWidget(item)\n\n line = QtWidgets.QFrame()\n line.setFrameShape(QtWidgets.QFrame.HLine)\n line.setFrameShadow(QtWidgets.QFrame.Sunken)\n self.layout().addWidget(line)\n\n # OK and Cancel buttons\n self.generateButton = QtWidgets.QPushButton('Genereer invoer')\n self.generateButton.setDefault(True)\n self.generateButton.clicked.connect(self.generate)\n\n self.cancelButton = QtWidgets.QPushButton('Annuleren')\n self.cancelButton.setAutoDefault(False)\n self.cancelButton.clicked.connect(self.cancel)\n\n button_box = QtWidgets.QDialogButtonBox(QtCore.Qt.Horizontal, self)\n button_box.addButton(self.generateButton, QtWidgets.QDialogButtonBox.ActionRole)\n button_box.addButton(self.cancelButton, QtWidgets.QDialogButtonBox.RejectRole)\n button_box.accepted.connect(QtWidgets.QDialog.accept)\n\n self.layout().addWidget(button_box)","def __init__(self, parent):\n QtGui.QMenu.__init__(self, parent)\n self.parent = parent","def __init__(self, parent):\n self.parent = parent\n parent_frame = self.parent.get_frame()\n self.text_frame = tk.Frame(parent_frame)\n self.text_frame.grid(row=1, padx=10, pady=10)\n self.model_frame = tk.Frame(parent_frame)\n self.model_frame.grid(row=2, padx=10, pady=10)\n self.connect_frame = tk.Frame(parent_frame)\n self.connect_frame.grid(row=0, padx=10, pady=10)\n self.electric_frame = tk.Frame(parent_frame)\n self.electric_frame.grid(row=4, padx=10, pady=10)\n\n self.freq_edit = tk.Entry(self.electric_frame)\n self.duty_edit = tk.Entry(self.electric_frame)\n\n self.ports_listbox = tk.Listbox(self.connect_frame)\n\n self.text_transfer = tk.Entry(self.text_frame)\n\n self.model_image = tk.Label(self.model_frame)\n self.model_image.grid(row=0, column=1)\n\n self.model = ''\n self.counter = 0\n self.font14 = ImageFont.truetype('Segment14.otf', 64)","def __init__(self, parent):\n\n self.__node = avg.RectNode(\n parent=parent,\n strokewidth=3,\n color=vs_config.SELECTION_FEEDBACK_COLOR,\n sensitive=False\n )","def _initUI(self) -> None:\n self._createActions()\n self._addActionsToMoveButtons()\n self._createToolBar()\n self._createStatusBar()\n self._createMainContextMenu()","def __init__(self, parent, rokucontrol=None, is_error=False, error_message=''):\n tk.Frame.__init__(self, parent, background=\"black\")\n self.style = ttk.Style()\n self.parent = parent\n self.rokucontrol = rokucontrol\n\n self.init_ui()\n\n if is_error:\n self.place_error_message(error_message)\n else:\n self.place_buttons()\n self.place_app_buttons()","def __init__(self, parent, *args, **kwargs):\n tk.LabelFrame.__init__(self, parent, *args, **kwargs)\n self.canvas = MainCanvas(self, bg=\"orange\")\n self.canvas.pack(side='top', fill='both', expand=True)","def __init__(self, parent=None):\n\t\tScriptedLoadableModuleWidget.__init__(self, parent)\n\t\tVTKObservationMixin.__init__(self) # needed for parameter node observation\n\t\tself.logic = None\n\t\tself._parameterNode = None\n\t\tself._updatingGUIFromParameterNode = False\n\t\t\n\t\tself.elecModel = None\n\t\tself.elecModelLastButton = None\n\t\tself.elecModelButton = 0\n\t\tself.elecChanLastButton = None\n\t\tself.elecChanButton = 0\n\t\tself.lastPolButton=0\n\t\tself.active = False","def __init__(self, root):\n self.app=root\n self.app.geometry('800x500')\n self.app.title(\"Bryce Streeper: Asset Allocation Visual \")\n self.makeTitle()\n self.makeGraph()\n self.makeSliders()\n self.update()","def __init__(self, parent):\n super(StageInterface, self).__init__(parent)\n\n # Make the sizer\n self.sizer = wx.BoxSizer(wx.HORIZONTAL)\n\n # Make the toolbar, then add it to the sizer\n self.tb = wx.ToolBar(self, style=wx.TB_VERTICAL)\n self.sizer.Add(self.tb, 0, wx.EXPAND)\n\n # Make the visualizer\n self.set_visualization(StageVisualizer(self))\n\n # We want to see what's in the sizer\n self.SetSizer(self.sizer)","def __init__(self, parent=None):\n super().__init__(parent)\n\n topLayout = QtGui.QVBoxLayout(self)\n self.setLayout(topLayout)\n self.setTitle(_('Choose export format subtype'))\n self.subtypeButtons = QtGui.QButtonGroup(self)\n self.subtypeButtons.buttonClicked[int].connect(self.setCurrentSubtype)","def __init__(self):\n # Root window\n self.root = tk.Tk()\n self.root.title(\"Crossword\")\n # Padding frame\n self.frame = tk.Frame(self.root)\n self.frame.pack(fill=\"both\", padx=PAD, pady=PAD)\n # Initialize widget groups\n self.header = HeaderView(self)\n self.puzzle = PuzzleView(self)\n self.clues = CluesView(self)\n # Show widgets\n self.header.show()\n self.puzzle.show()\n self.clues.show()","def initialize(self):\n super(QtTreeView, self).initialize()\n self.set_header_visible(self.shell_obj.header_visible)","def initializeUI(self):\n self.setStyleSheet(abstyle)\n self.setGeometry(140, 100, 860, 484)\n self.setWindowTitle('Emotions Data View')\n self.setupModelView()","def __init__(self, parent):","def __init__(self, parent=None):\n super(ProgressDlg, self).__init__(parent)\n self.setupUi(self)","def initGUI(self):\n\n\t\t# Set main frame's location \n\t\tself.grid(row=0, column=0, sticky=\"nsew\")\n\n\t\t# Set path entry frame and its location\n\t\tself.entryFrame = Frame(self, relief = RAISED, borderwidth = 1)\n\t\tself.entryFrame.pack(fill = BOTH, expand = False)\n\t\t# Make label\n\t\tif self.message:\n\t\t\tmessageLabel = Label(self.entryFrame, text = self.message, font=(\"Bradley\", 10))\n\t\t\tmessageLabel.pack(anchor=W, padx=0, pady=0)\n\n\t\t# Set path entry and its location\n\t\tself.filePathEntry = Entry(self.entryFrame, bd = 4, width = 50)\n\t\tself.filePathEntry.pack(side = LEFT, padx=2, pady=1)","def _initialize(self):\n self._frame = ttk.Frame(master=self._root)\n self._ingredients_frame = ttk.Frame(master=self._frame)\n\n self._create_header()\n self._show_ingredient_list()\n self._create_footer()\n\n self._ingredients_frame.grid(row=1, column=1, columnspan=2)\n self._frame.grid_columnconfigure(1, weight=1, minsize=250)","def Tree_Frame( self ):\r\n #Create pane\r\n p = self.pane_widget.add( \"Tree\", min = 0.2, max = 0.9, size = 0.5 )\r\n frame_tree = Frame( p )\r\n #Add the scale\r\n self.canvas_scale = Canvas( frame_tree, height = 10 )\r\n self.canvas_scale.bind( '<Button-1>', self.Scale_Pick )\r\n self.canvas_scale.bind( '<B1-Motion>', self.Scale_Pick )\r\n self.canvas_scale.pack(side = TOP)\r\n #canvas for drawing the tree on \r\n self.canvas_one = Canvas( frame_tree )\r\n #Make sure these values are consistent with self.canvas_two in Data_Frame\r\n self.canvas_one.pack( side = TOP , fill = BOTH , expand = 1 )\r\n self.canvas_one.bind( '<ButtonRelease-1>', self.Tree_Pick )\r\n frame_tree.pack( side = LEFT, fill = BOTH )","def __init__(self):\n self.root = self.Node()","def __init__(self, parent):\r\n\r\n BasicDialog.__init__(self, parent, title=None)","def __init__(self):\n super().__init__()\n # init attributes\n self.grScene: Union[GraphicsScene, None] = None\n\n self.nodes = []\n self.edges = []\n self.scene_width = 64000\n self.scene_height = 64000\n\n # custom flag used to suppress triggering onItemSelected which does a bunch of stuff\n self._silent_selection_events = False\n # flag identifying wether the current scene has been modified\n self._has_been_modified = False\n self._last_selected_items = None\n\n # initialize all listeners\n self._has_been_modified_listeners = [] # list of function to call when the scene is modified\n self._item_selected_listeners = []\n self._items_deselected_listeners = []\n\n # Store callback for retrieving the class for Nodes\n self.node_class_selector = None\n\n self.initUI()\n self.history = SceneHistory(self)\n self.clipboard = SceneClipboard(self)\n\n self.grScene.itemSelected.connect(self.onItemSelected)\n self.grScene.itemsDeselected.connect(self.onItemsDeselected)","def create(self, parent):\n self.widget = QFrame(parent)","def init_file_tree(self):\r\n # layout for the file explorer\r\n path=QtCore.QDir.currentPath()\r\n\r\n # file system model init\r\n self.model = QtWidgets.QFileSystemModel()\r\n self.model.setRootPath(path)\r\n self.model.setNameFilterDisables(False)\r\n \r\n # tree view init and settings\r\n self.tree = QtWidgets.QTreeView()\r\n self.tree.setModel(self.model)\r\n self.tree.setRootIndex(self.model.index(path))\r\n self.tree.setAnimated(False)\r\n self.tree.setIndentation(20)\r\n self.tree.setSortingEnabled(True)\r\n self.tree.sortByColumn(0,QtCore.Qt.AscendingOrder)\r\n self.tree.setColumnWidth(0,200)\r\n self.tree.setColumnWidth(1,100)\r\n self.tree.setColumnWidth(2,100)\r\n self.tree.setItemsExpandable(False)\r\n\r\n # set path\r\n self.set_new_path(path)\r\n\r\n # event mappers\r\n self.tree.selectionModel().selectionChanged.connect(self.select_change)\r\n self.tree.doubleClicked.connect(self.open_file_directory) \r\n self.tree.activated.connect(self.open_file_directory)\r\n\r\n # adding the tree to the layout\r\n self.layout_explorer_tree = QtWidgets.QGridLayout()\r\n self.layout_explorer_tree.addWidget(self.tree)","def __init__(self, parent, controller):\n super().__init__(parent, width=\"10m\")\n\n self.parent = parent\n self.controller = controller\n\n self.grid_propagate(0)\n\n self.rowconfigure(0, weight=1)\n self.rowconfigure(1, weight=20)\n self.rowconfigure(2, weight=20)\n self.columnconfigure(0, weight=1)\n self.columnconfigure(1, weight=1)\n\n if (self.controller.game.color_queried and\n self.controller.game.in_turn == 0):\n self.create_title()\n self.create_buttons()","def __init__(self):\n super().__init__()\n self.geometry('{}x{}'.format(425, 185))\n self.title('PAD Tracker')\n self.frame = Frame(self)\n self.populateFields()\n self.frame.pack()","def init_gui(self):\n # Choose a layout.\n main_vb = QtGui.QVBoxLayout(self)\n\n # Add a list or tree view.\n self.list_view = QtGui.QListWidget()\n\n # Add the buttons.\n load_btn = QtGui.QPushButton('Load Selected')\n cancel_btn = QtGui.QPushButton('Cancel')\n load_btn.clicked.connect(self.update_list_view)\n cancel_btn.clicked.connect(self.close)\n\n # Connect the list/tree view with a method appropriate for user interaction.\n self.list_view.currentItemChanged['QListWidgetItem*', 'QListWidgetItem*'].connect(self.set_current_name)\n self.list_view.itemChanged['QListWidgetItem*'].connect(self.change_name)\n\n # Add the widgets to the layout.\n btn_hb = QtGui.QHBoxLayout()\n btn_hb.addWidget(load_btn)\n btn_hb.addWidget(cancel_btn)\n main_vb.addWidget(self.list_view)\n main_vb.addLayout(btn_hb)\n\n # Show the GUI.\n self.setGeometry(300, 300, 450, 300)\n self.setWindowTitle('Hello World')\n img_icon = 'C:/Users/caj150430/code/so_much_win.png'\n self.setWindowIcon(QtGui.QIcon(img_icon))\n self.show()","def __init__(self):\n self.root = self.Node(None)","def __init__(self):\n self.root = TreeNode(\"\")","def __init__(self):\n self.root = TreeNode(\"\")","def __init__(self, parent, id, title):\n wx.Frame.__init__(self, parent, id, title, size=(1200, 560))\n self.SetBackgroundColour(wx.Colour(0, 0, 360))\n self.SetIcon(wx.Icon(gv.ICO_PATH))\n gv.iGeoMgr = self.geoMgr = GeoMgr(self)\n gv.iDCPosMgr = DataCenterMgr(self)\n self.SetSizer(self._buidUISizer())","def __init__(self, parent: View):\n super().__init__(parent)\n # Across label\n self.across_label = tk.Label(self.frame)\n # Across frame\n self.across_frame = tk.Frame(self.frame)\n # Across list and scrollbar\n self.across_listbox = tk.Listbox(self.across_frame)\n self.across = ListVar(self.across_listbox)\n self.across_scrollbar = tk.Scrollbar(self.across_frame)\n # Down Label\n self.down_label = tk.Label(self.frame)\n # Down frame\n self.down_frame = tk.Frame(self.frame)\n # Down list and scrollbar\n self.down_listbox = tk.Listbox(self.down_frame)\n self.down = ListVar(self.down_listbox)\n self.down_scrollbar = tk.Scrollbar(self.down_frame)\n # Load\n self.load()","def __init__(self):\n self.root = Node('')","def initializeUI(self):\n self.setGeometry(100, 100, 450, 300)\n self.setWindowTitle('Model and View Example')\n\n self.setupModelView()\n\n self.show()","def init_ui(self):\n raise NotImplementedError","def init_ui(self):\n raise NotImplementedError","def __init__(self, model):\r\n\r\n gtk.Frame.__init__(self)\r\n\r\n # Define private dictionary attributes.\r\n\r\n # Define private list attributes.\r\n self._lst_count_labels = [u\"<span foreground=\\\"blue\\\">\\u03BB<sub>EQUIP</sub> = \\u03BB<sub>g</sub></span>\",\r\n u\"\\u03BB<sub>g</sub>:\"]\r\n self._lst_stress_labels = [u\"<span foreground=\\\"blue\\\">\\u03BB<sub>p</sub> = \\u03BB<sub>b</sub>\\u03C0<sub>E</sub></span>\",\r\n u\"\\u03BB<sub>b</sub>:\",\r\n u\"\\u03C0<sub>E</sub>:\"]\r\n\r\n # Define private scalar attributes.\r\n self._hardware_model = model\r\n self._subcategory = model.subcategory\r\n\r\n # Define public dictionary attributes.\r\n\r\n # Define public list attributes.\r\n\r\n # Define public scalar attributes.\r\n self.txtLambdaB = Widgets.make_entry(width=100, editable=False,\r\n bold=True)\r\n self.txtPiE = Widgets.make_entry(width=100, editable=False, bold=True)\r\n\r\n # Create the tooltips for all the results display widgets.\r\n self.txtLambdaB.set_tooltip_text(_(u\"Displays the base hazard rate \"\r\n u\"for the selected fuse.\"))\r\n self.txtPiE.set_tooltip_text(_(u\"Displays the environment factor for \"\r\n u\"the selected fuse.\"))","def __init__(self):\n self.root = TreeNode('#')","def __init__(self,tree):\n self._tree = tree","def __init__(self, level, parent):\n self.color = Color(0, 0, 0)\n self.pixel_count = 0\n self.palette_index = 0\n self.children = [None for _ in range(8)]\n # add node to current level\n if level < OctreeQuantizer.MAX_DEPTH - 1:\n parent.add_level_node(level, self)","def __init__(self):\n super(ProcessorHeader, self).__init__()\n self.setupUi(self)\n self.layout().setContentsMargins(0, 0, 0, 0)\n \n # Override path to CBSD logo\n logoPath = os.path.join(os.path.dirname(__file__),\n '../resources/images/cbsd_logo.png')\n logoPath = os.path.normpath(logoPath)\n \n self.logoLabel.setPixmap(QtGui.QPixmap(logoPath))\n \n self.notesLabel.setSizePolicy(QtGui.QSizePolicy.Preferred,\n QtGui.QSizePolicy.Ignored)\n \n ## \\c{(bool)} Whether additional instructions related to the shot\n # processor configuration are visible.\n self.notesVisible = False\n \n ## \\c{(hiero.core.FnExportStructure.ExportStructure2)} A reference to\n # the current preset's export template.\n #\n # @details Set externally by WiretapShotProcessor.populateUI().\n self.exportTemplate = None\n \n ## \\c{(hiero.ui.ExportStructureViewer)} A reference to the Wiretap shot\n # processor's export structure viewer.\n #\n # @details Set externally by WiretapShotProcessor.populateUI().\n self.exportStructureViewer = None\n \n # Signal-slot pairs\n self.notesButton.clicked.connect(self.ToggleNotes)\n self.chooseButton.clicked.connect(self.ChooseNodePath)\n self.clipNameEdit.textEdited.connect(self.__FixClipName)\n self.addElementButton.clicked.connect(self.AddElement)","def set_ui(self):\r\n\r\n self.canvas = tk.Canvas(self)\r\n self.canvas.pack()\r\n\r\n self.entry = ttk.Entry(self.canvas, justify=\"center\", font=(\"Calibri\", 12))\r\n\r\n self.grid = Grid(self.canvas)","def create(self, parent):\n self.widget = _QMainWindow(parent)","def initCentralUic(self):\n self.initFileTableWidget()\n self.initViewerStack()\n self.splitter.setSizes([150, 850])"],"string":"[\n \"def create(self, parent):\\n self.widget = QtGui.QTreeView(parent)\",\n \"def __init__(self, parent=None):\\n super(Representative, self).__init__(parent)\\n self.setupUi(self)\",\n \"def __init__(self,parent, id = wx.ID_ANY, pos = (10,10), size=(-1,-1)):\\n\\n wx.TreeCtrl.__init__(self, parent, id,pos,size,style =\\n wx.TR_HIDE_ROOT | wx.TR_HAS_BUTTONS |\\n wx.TR_HAS_VARIABLE_ROW_HEIGHT)\\n\\n self.root = self.AddRoot(\\\"Top\\\")\\n self.classes = []\\n self.base_cls = []\",\n \"def __init__(self, parent: View):\\n self.parent = parent\\n self.root = self.parent.root\\n # Content frame\\n self.frame = tk.Frame(self.parent.frame)\\n # Reference\\n self.visible = False\",\n \"def __init__(self):\\n super().__init__()\\n self.root = tk.Tk() # different Tk than this class.\\n self.root.title(\\\"Python Pyui!\\\")\\n self.top_frame = tk.Frame(self.root, bg=\\\"yellow\\\")\\n self.top_frame.pack(fill=c.BOTH, expand=1)\\n self.bottom_frame = tk.Frame(self.root, bg=\\\"blue\\\",\\n borderwidth=1, relief=c.RAISED)\\n self.bottom_frame.pack(fill=c.X)\\n okButton = tk.Button(self.bottom_frame, text=\\\"OK\\\",\\n command=self.cb_ok)\\n okButton.pack(fill='none', padx=5, pady=5, side=c.RIGHT)\\n cancelButton = tk.Button(self.bottom_frame, text=\\\"Cancel\\\",\\n command=self.cb_cancel)\\n cancelButton.pack(fill='none', padx=5, pady=5, side=c.RIGHT)\\n\\n self.not_cancelled = False\\n self.current_parent = self.top_frame\\n self.parent_is_grid= False\\n self.entries = {}\",\n \"def __init__(self, parent=None):\\n self._window = None\\n\\n self.setup_ui()\",\n \"def __init__(self, parent):\\n self._parent = parent\",\n \"def __init__(self, parent, name=wx.PanelNameStr):\\n super(FilesTreeViewCtrl, self).__init__(parent, name)\\n\\n # Create an instance of our model and associate to the view.\\n self._model = FilesTreeViewModel()\\n self.AssociateModel(self._model)\\n self._model.DecRef()\\n\\n # Create the columns that the model wants in the view.\\n for i in range(self._model.GetColumnCount()):\\n col = BaseTreeViewCtrl._create_column(self._model, i)\\n if i == self._model.GetExpanderColumn():\\n self.SetExpanderColumn(col)\\n wx.dataview.DataViewCtrl.AppendColumn(self, col)\\n\\n # Bind events.\\n # Used to remember the expend/collapse status of items after a refresh.\\n self.Bind(wx.dataview.EVT_DATAVIEW_ITEM_EXPANDED, self._on_item_expanded)\\n self.Bind(wx.dataview.EVT_DATAVIEW_ITEM_COLLAPSED, self._on_item_collapsed)\\n self.Bind(wx.dataview.EVT_DATAVIEW_ITEM_ACTIVATED, self._on_item_activated)\\n self.Bind(wx.dataview.EVT_DATAVIEW_SELECTION_CHANGED, self._on_item_selection_changed)\",\n \"def __init__(self, parent: View):\\n super().__init__(parent)\\n # Crossword title\\n self.title = tk.StringVar(self.root)\\n self.title_label = tk.Label(self.frame, textvariable=self.title)\\n # Crossword author\\n self.author = tk.StringVar(self.root)\\n self.author_label = tk.Label(self.frame, textvariable=self.author)\\n # Dividing line separating the header and other groups\\n self.separator = tk.Frame(self.frame)\\n # Load\\n self.load()\",\n \"def __init__(self, parent=None):\\n super(RobotSelection, self).__init__(parent)\\n self.parent = parent\\n self.initUI()\",\n \"def __init__(self, treeView, isChildView=True, parent=None):\\n super().__init__(parent)\\n self.treeView = treeView\\n self.isChildView = isChildView\\n self.hideChildView = not globalref.genOptions['InitShowChildPane']\\n self.setAcceptRichText(False)\\n self.setLineWrapMode(QTextEdit.NoWrap)\\n self.setTabChangesFocus(True)\\n self.setUndoRedoEnabled(False)\\n self.treeSelectAction = QAction(_('Select in Tree'), self)\\n self.treeSelectAction.triggered.connect(self.selectLineInTree)\\n self.textChanged.connect(self.readChange)\",\n \"def __init__(self, parent):\\r\\n Frame.__init__(self, parent) \\r\\n \\r\\n self.parent = parent\\r\\n self.initUI()\",\n \"def __init__(self, parent):\\n if isinstance(parent, Node):\\n self.parent = parent\\n self.tree = parent.tree\\n self.depth = parent.depth + 1\\n else:\\n self.parent = None\\n self.tree = parent\\n self.depth = 0\\n self.children = []\\n self.childrencreated = 0\\n self.expanded = 0\\n self.selected = 0\\n \\n self.text_id = 0\\n self.image_id = 0\\n self.minusplus_id = 0\\n \\n self.oldy = -1000\\n self.changed = 0\\n \\n if not self.parent: self.tree._setnode(self) # Root Node must be passed to the tree.\",\n \"def _setupUi(self):\\n self.setupUi(self)\\n self.twTree.setStyleSheet(\\\"background-color: rgb(200, 200, 200)\\\")\",\n \"def gui_init(self):\\n if not self.parent is None:\\n self.parent.children.append(self)\\n self.children = []\\n self.priority = PRIORITY_GUI_ELEMENTS\",\n \"def __init__(self, parent=None):\\n super(Inj, self).__init__(parent)\\n self.setupUi(self)\",\n \"def __init__(self, root, *args, **kwargs):\\n super().__init__(root, *args, **kwargs)\\n self._Master = root\\n self._Master.resizable(self.resize_x, self.resize_y)\\n self.winfo_toplevel().title(self.title)\\n\\n self._PendingJobs = {\\n \\\"event-lock\\\": None,\\n }\\n\\n self._EventLock = False\\n\\n # Menu bar\\n self._BooleanVars = {}\\n self._Buttons = {}\\n self._Canvases = {}\\n self._Checkboxes = {}\\n self._Entries = {}\\n self._Frames = {}\\n self._Labels = {}\\n self._Menus = {\\\"main-menu\\\": tk.Menu(self._Master)}\\n self._OptionMenus = {}\\n self._RadioButtons = {}\\n self._StringVars = {}\\n\\n self.init_all_frames()\\n self.init_all_buttons()\\n self.init_all_canvases()\\n self.init_all_checkboxes()\\n self.init_all_entries()\\n self.init_all_labels()\\n self.init_all_menus()\\n self.init_all_optionmenus()\\n self.init_all_radiobuttons()\",\n \"def __init__(self, parent: QWidget, gui: 'MetalGUI', view: QTreeView):\\n super().__init__(parent=parent,\\n gui=gui,\\n view=view,\\n child='GDS renderer')\",\n \"def __init__(self, parent: QWidget):\\n super().__init__(parent)\\n DiagramFieldView.__diagram_field = self\\n\\n self.__list: List[DiagramView] = []\\n self.__dialog: Dialog = None\\n self.__diagram_layout: QVBoxLayout = QVBoxLayout()\\n self.__button_layout: QHBoxLayout = QHBoxLayout()\\n self.__start_button: StartButtonView = StartButtonView()\\n self.__maximize_button: QPushButton = QPushButton()\\n\\n self.__diagram_group: QtWidgets.QGroupBox = QtWidgets.QGroupBox(self)\\n self.__group_layout: QtWidgets.QVBoxLayout = QtWidgets.QVBoxLayout(self.__diagram_group)\\n self.__stretch_widget: QtWidgets.QWidget = QtWidgets.QWidget(self)\\n self.__diagram_count: int = 0\\n\\n self.__start_button.start_signal.connect(self.__clear_diagrams)\\n self.__maximize_button.clicked.connect(self.__maximize_on_click)\\n ManagerModel.set_diagram_notifier(self)\\n self.__init_ui()\",\n \"def construct(self):\\n top = Toplevel()\\n top.withdraw()\\n top.protocol(\\\"WM_DELETE_WINDOW\\\", self.view_xml_pane)\\n top.columnconfigure(0, weight=1)\\n top.rowconfigure(0, weight=1)\\n top.title(\\\"XML Preview\\\")\\n self._pane = top\\n\\n xml_area = Text(top, borderwidth=2, relief=\\\"sunken\\\")\\n xml_area.config(font=(\\\"consolas\\\", 12), undo=True, wrap='word', state=DISABLED)\\n xml_area.grid(row=0, column=0, sticky=\\\"nsew\\\", padx=2, pady=2)\\n\\n scrollbar = Scrollbar(top, command=xml_area.yview)\\n scrollbar.grid(row=0, column=1, sticky='nsew')\\n xml_area['yscrollcommand'] = scrollbar.set\\n\\n self._text_area = xml_area\",\n \"def __init__(self):\\n self.view = GuiView(self)\\n return\",\n \"def __init__(self, parent=None):\\n super(QCTP, self).__init__(parent)\\n self.setupUi(self)\",\n \"def __init__(self, parent=None):\\n super(Form, self).__init__(parent)\\n self.setupUi(self)\",\n \"def __init__(self, parent=None):\\n super(Form, self).__init__(parent)\\n self.setupUi(self)\",\n \"def __create_ui(self):\\n vbox = gtk.VBox()\\n\\n # Create the viewable area of the file browser\\n self.__view_port = gtk.ScrolledWindow()\\n self.__view_port.set_policy(gtk.POLICY_AUTOMATIC,\\n gtk.POLICY_AUTOMATIC)\\n # Create the tree view and add it to the viewable area\\n self.__tree_view = ProjectTreeView()\\n self.__project_explorer = ProjectExplorer(self.window, self.__tree_view)\\n self.__tree_view.connect('button_press_event',\\n self.__on_treeview_button_press_event)\\n self.__project_explorer.set_repository()\\n self.__view_port.add(self.__tree_view)\\n # Create the toolbar\\n hbox = gtk.HBox()\\n toolbar = gtk.Toolbar()\\n toolbar.set_style(gtk.TOOLBAR_ICONS)\\n toolbar.set_icon_size(gtk.ICON_SIZE_MENU)\\n back = gtk.ToolButton(gtk.STOCK_GO_UP)\\n back.connect('clicked', self.__on_back_clicked)\\n toolbar.insert(back, 0)\\n toolbar.insert(gtk.SeparatorToolItem(), 1)\\n refresh = gtk.ToolButton(gtk.STOCK_REFRESH)\\n refresh.connect('clicked', self.__on_refresh_clicked)\\n toolbar.insert(refresh, 2)\\n hbox.pack_start(toolbar, True, True, 0)\\n vbox.pack_start(hbox, False, False, 0)\\n vbox.pack_start(self.__view_port, True, True, 0)\\n\\n # Setup the create the buttons for:\\n # New File, New Folder\\n # ----------------------------------------------------------------------\\n hbox1 = gtk.VBox()\\n toolbar_actions = gtk.Toolbar()\\n toolbar_actions.set_style(gtk.TOOLBAR_ICONS)\\n toolbar_actions.set_icon_size(gtk.ICON_SIZE_MENU)\\n new_file = gtk.ToolButton(gtk.STOCK_NEW)\\n new_file.connect('clicked', self.__on_new_file_clicked_cb)\\n toolbar_actions.insert(new_file, 0)\\n new_dir = gtk.ToolButton(gtk.STOCK_OPEN) # TODO: use a custom icon\\n new_dir.connect('clicked', self.__on_new_dir_clicked_cb)\\n toolbar_actions.insert(new_dir, 1)\\n hbox1.pack_start(gtk.HSeparator(), True, True, 0)\\n hbox1.pack_start(toolbar_actions, True, True, 0)\\n vbox.pack_end(hbox1, False, False, 0)\\n # ----------------------------------------------------------------------\\n vbox.show_all()\\n # Attach the project explorer to GMate's side panel\\n self.__side_panel = self.window.get_side_panel()\\n self.__side_panel.add_tab(vbox, msg0005, gtk.STOCK_HARDDISK)\",\n \"def __init__(self, parent=None):\\n super(MainWindow, self).__init__(parent)\\n self.setupUi(self)\",\n \"def __init__(self, parent=None):\\n super(MainWindow, self).__init__(parent)\\n self.setupUi(self)\",\n \"def __init__(self, parent=None):\\n super(MainWindow, self).__init__(parent)\\n self.setupUi(self)\",\n \"def __init__(self, parent=None):\\n super(MainWindow, self).__init__(parent)\\n self.setupUi(self)\",\n \"def __init__(self, parent=None):\\n super(MainWindow, self).__init__(parent)\\n self.setupUi(self)\",\n \"def __init__(self, parent):\\n self.parent = parent\\n self.dialog = None\",\n \"def __init__(self, parent=None):\\n super(Dialog, self).__init__(parent)\\n self.setupUi(self)\",\n \"def __init__(self, parent):\\n self.name = \\\"Base.View\\\"\\n self.parent = parent\\n self.Main = parent.Main\",\n \"def __init__(self, parent):\\n pass\",\n \"def __init__(self, parent):\\n pass\",\n \"def __init__(self, parent):\\n pass\",\n \"def init_ui(self):\\n self.master.title(\\\"Backbone\\\")\\n self.master.geometry(\\\"300x150\\\")\\n\\n self.pack(fill=BOTH, expand=1)\\n\\n self.btn_upload_file = Button(self, text=\\\"Upload file\\\", command=self.upload_file)\\n self.btn_upload_file.place(x=90, y=10)\\n\\n self.btn_create_training_file = Button(self, text=\\\"Create & upload training file\\\",\\n command=self.create_training_file)\\n self.btn_create_training_file.place(x=30, y=40)\\n\\n self.btn_run_algorithm = Button(self, text=\\\"Run algorithm\\\", command=self.run_algorithm)\\n self.btn_run_algorithm.place(x=80, y=70)\\n\\n self.btn_view_results = Button(self, text=\\\"View Results\\\", command=self.view_results)\\n self.btn_view_results.place(x=85, y=100)\",\n \"def __init__(self, parent=None):\\n super(MainWindow, self).__init__(parent)\\n self.setupUi(self)\\n self.path=''\\n self.bool=0\\n self.child=0\\n self.click=\\\" \\\"\",\n \"def __init__(self):\\n Tree.__init__(self, \\\"\\\")\",\n \"def __init__(self, root=None):\\n self.set_root(root)\",\n \"def build_gui(self):\\n tip = _('Double-click on a row to edit the selected child.')\\n self.set_tooltip(tip)\\n top = Gtk.TreeView()\\n titles = [('', NOSORT, 50,),\\n (_('Child'), 1, 250),\\n (_('Birth Date'), 3, 100),\\n ('', 3, 100),\\n (_('Death Date'), 5, 100),\\n ('', 5, 100)]\\n self.model = ListModel(top, titles, event_func=self.edit_person)\\n return top\",\n \"def build_gui(self):\\n tip = _('Double-click on a row to edit the selected child.')\\n self.set_tooltip(tip)\\n top = Gtk.TreeView()\\n titles = [('', NOSORT, 50,),\\n (_('Child'), 1, 250),\\n (_('Birth Date'), 3, 100),\\n ('', 3, 100),\\n (_('Death Date'), 5, 100),\\n ('', 5, 100),\\n (_('Spouse'), 6, 250)]\\n self.model = ListModel(top, titles, event_func=self.edit_person)\\n return top\",\n \"def __init__(self):\\n super(GraphVisualizerCase, self).__init__()\\n\\n self._v_layout = QVBoxLayout()\\n self.setLayout(self._v_layout)\\n\\n top_label_layout = QHBoxLayout()\\n self._v_layout.addLayout(top_label_layout)\\n\\n self._top_left_label = MathTextLabel()\\n top_label_layout.addWidget(self._top_left_label)\\n self._top_right_label = MathTextLabel()\\n top_label_layout.addWidget(self._top_right_label)\\n\\n self._center_widget = QFrame()\\n self._center_text_label = QLabel()\\n self._center_text_label.setAlignment(Qt.AlignCenter)\\n layout = QHBoxLayout()\\n layout.addWidget(self._center_text_label)\\n self._center_widget.setLayout(layout)\\n\\n self._v_layout.addWidget(self._center_widget)\\n\\n bot_label_layout = QHBoxLayout()\\n self._v_layout.addLayout(bot_label_layout)\\n\\n self._bot_left_label = MathTextLabel()\\n bot_label_layout.addWidget(self._bot_left_label)\\n self._bot_right_label = MathTextLabel()\\n bot_label_layout.addWidget(self._bot_right_label)\",\n \"def __init__( self, window_size=QSize( DEFAULT_H_SIZE, DEFAULT_V_SIZE ) ):\\n super().__init__()\\n\\n self.centralWidget = None\\n self.window_size = window_size\\n\\n self.create_models()\\n self.create_widgets()\\n self.create_layout()\\n self.create_menus()\\n self.set_state()\",\n \"def __init__(self: object) -> None:\\n super().__init__()\\n self.title(\\\"dnazip\\\")\\n self.configure(bg='#ebebeb')\\n self.create_main()\\n self.create_menu()\\n self.create_buttons()\\n self.file = None\",\n \"def create(self, parent):\\n self.widget = QtCore.QObject(parent)\",\n \"def __init__(self):\\r\\n super().__init__()\\r\\n self.init_ui()\",\n \"def __init__(self, parent, maze_width, maze_height, scale=20):\\n self.parent = parent\\n self.parent.title(\\\"Maze Exploration Visualization\\\")\\n\\n self.maze_width = maze_width\\n self.maze_height = maze_height\\n self.scale = scale\\n\\n # Compute actual width and height\\n self.width = maze_width * scale\\n self.height = maze_height * scale\\n\\n # Store tkinter object\\n self.frame = tkinter.Frame(self.parent,\\n width=self.width,\\n height=self.height,\\n highlightthickness=1,\\n highlightbackground=\\\"black\\\")\\n self.canvas = tkinter.Canvas(self.frame,\\n width=self.width, \\n height=self.height)\\n self.canvas.pack(expand=False)\\n self.frame.pack(expand=False)\\n\\n # Initialize look of grid\\n self.draw_gray_grid()\\n\\n self.person = None\\n self.draw_person(self.maze_width // 2, self.maze_height // 2)\",\n \"def __init__(self):\\n self.root = None\",\n \"def __init__(self):\\n self.root = None\",\n \"def __init__(self, parent=None):\\n super(union_Dialog, self).__init__(parent)\\n self.setupUi(self)\",\n \"def __init__(self, tree):\\n self._tree = tree\",\n \"def __init__(self, tree):\\n self._tree = tree\",\n \"def __init__(self, parent=None):\\n super().__init__(parent)\\n\\n # Filters on the model\\n self.filters = Filters.NoFilter\\n self.sorting = Sorting.Date\\n\\n # Contains all the submitted levels.\\n # Key: level code\\n # Value: Level instance\\n self.levels_dict = {}\\n self.dict_lock = threading.RLock() # Prevent access racing on levels dict\\n\\n # Contains all the levels that should be shown to the view\\n # The index in this list is the row for the view.\\n self.view_list = []\\n self.view_keys = [] # keys for sorting the view\\n self.list_lock = threading.RLock() # Prevent access racing on view list\",\n \"def __init__(self):\\n # Passing the class make this Python 2 and Python 3 compatible\\n super(MayaSceneLevelGeneratorUI, self).__init__(parent=maya_main_window())\\n\\n # Create the generators needed\\n self._level_gen = level.LevelGenerator([blocks.BlockFile(\\\"\\\", blk_type) for blk_type in VALID_BLOCK_TYPES])\\n self._scene_gen = MayaSceneLevelGenerator(None) # Fill in level at button press time\\n\\n # Window things\\n self.setWindowTitle(\\\"Maya Scene Level Generator\\\")\\n self.resize(500, 200)\\n self.setWindowFlags(self.windowFlags() ^ PySide2.QtCore.Qt.WindowContextHelpButtonHint)\\n\\n # Set up for the first time\\n self._create_widgets()\\n self._create_layout()\\n self._refresh_view()\\n self._create_connections() # Order matters, since refreshing triggers connections\\n\\n print(self._level_gen.block_list) # TODO delete\",\n \"def __init__(self, parent=None):\\n super(addOne, self).__init__(parent)\\n self.setupUi(self)\\n \\n # 内部自定义初始化操作 ---------------------------------------------------------------------begin\\n self.zShow = Fdebug(self);\\n self.zShow.show();\\n self.verticalLayout.insertWidget(0, self.zShow)\",\n \"def __init__(self, parent):\\n super(StageVisualizer, self).__init__(parent)\\n\\n self.figure = matplotlib.figure.Figure()\\n self.axes = self.figure.add_subplot(111)\\n self.figure.subplots_adjust(top=1, bottom=0, right=1, left=0)\\n\\n self.axes.get_xaxis().set_visible(False)\\n self.axes.get_yaxis().set_visible(False)\\n\\n self.canvas = FigureCanvas(self, -1, self.figure)\\n\\n self.sizer = wx.BoxSizer(wx.VERTICAL)\\n self.sizer.Add(self.canvas, 1, wx.LEFT | wx.TOP | wx.GROW)\\n self.SetSizer(self.sizer)\\n\\n self.toolbar = NavigationToolbar(self.canvas)\\n self.toolbar.pan()\\n self.toolbar.Hide()\\n\\n self.Fit()\\n\\n self.zoomer = self.zoom_factory(self.axes, base_scale=1.5)\\n\\n self.canvas.Bind(wx.EVT_PAINT, self.on_paint)\",\n \"def init_ui(self):\\n # Create GUI elements, set them in dict structure\\n labelwidth = 150\\n\\n # Add parameter line edit for Factor Tm to Tp\\n self.input_elements['factor Tm Tp'] = widgets.ParameterInputLine(\\n label='Factor Tm naar Tp:',\\n labelwidth=labelwidth,\\n unitlabel='(NVT: Tp aanwezig)' if 'Tp' in self.hydraulic_loads.columns else '',\\n validator=QtGui.QDoubleValidator(0.01, 99.99, 20),\\n )\\n\\n if 'Tp' in self.hydraulic_loads.columns or self.parent_tab.step != 'I1':\\n self.input_elements['factor Tm Tp'].set_enabled(False)\\n\\n # Add line edit with browsebutton for Master template\\n self.input_elements['mastertemplate'] = widgets.ExtendedLineEdit(\\n label='Master template bestand:',\\n labelwidth=labelwidth,\\n browsebutton=QtWidgets.QPushButton('...', clicked=self.select_master_template)\\n )\\n\\n # Add line edit with browsebutton for depth file\\n self.input_elements['depthfile'] = widgets.ExtendedLineEdit(\\n label='Bathymetry bestand:',\\n labelwidth=labelwidth,\\n browsebutton=QtWidgets.QPushButton('...', clicked=self.select_bathymetry_file)\\n )\\n\\n # Add line edit with browsebutton for swan result folder\\n self.input_elements['swanfolder'] = widgets.ExtendedLineEdit(\\n label='SWAN uitvoer folder:',\\n labelwidth=labelwidth,\\n browsebutton=QtWidgets.QPushButton('...', clicked=self.select_swan_folder)\\n )\\n\\n\\n self.setLayout(QtWidgets.QVBoxLayout())\\n self.layout().setSpacing(10)\\n\\n for _, item in self.input_elements.items():\\n self.layout().addWidget(item)\\n\\n line = QtWidgets.QFrame()\\n line.setFrameShape(QtWidgets.QFrame.HLine)\\n line.setFrameShadow(QtWidgets.QFrame.Sunken)\\n self.layout().addWidget(line)\\n\\n # OK and Cancel buttons\\n self.generateButton = QtWidgets.QPushButton('Genereer invoer')\\n self.generateButton.setDefault(True)\\n self.generateButton.clicked.connect(self.generate)\\n\\n self.cancelButton = QtWidgets.QPushButton('Annuleren')\\n self.cancelButton.setAutoDefault(False)\\n self.cancelButton.clicked.connect(self.cancel)\\n\\n button_box = QtWidgets.QDialogButtonBox(QtCore.Qt.Horizontal, self)\\n button_box.addButton(self.generateButton, QtWidgets.QDialogButtonBox.ActionRole)\\n button_box.addButton(self.cancelButton, QtWidgets.QDialogButtonBox.RejectRole)\\n button_box.accepted.connect(QtWidgets.QDialog.accept)\\n\\n self.layout().addWidget(button_box)\",\n \"def __init__(self, parent):\\n QtGui.QMenu.__init__(self, parent)\\n self.parent = parent\",\n \"def __init__(self, parent):\\n self.parent = parent\\n parent_frame = self.parent.get_frame()\\n self.text_frame = tk.Frame(parent_frame)\\n self.text_frame.grid(row=1, padx=10, pady=10)\\n self.model_frame = tk.Frame(parent_frame)\\n self.model_frame.grid(row=2, padx=10, pady=10)\\n self.connect_frame = tk.Frame(parent_frame)\\n self.connect_frame.grid(row=0, padx=10, pady=10)\\n self.electric_frame = tk.Frame(parent_frame)\\n self.electric_frame.grid(row=4, padx=10, pady=10)\\n\\n self.freq_edit = tk.Entry(self.electric_frame)\\n self.duty_edit = tk.Entry(self.electric_frame)\\n\\n self.ports_listbox = tk.Listbox(self.connect_frame)\\n\\n self.text_transfer = tk.Entry(self.text_frame)\\n\\n self.model_image = tk.Label(self.model_frame)\\n self.model_image.grid(row=0, column=1)\\n\\n self.model = ''\\n self.counter = 0\\n self.font14 = ImageFont.truetype('Segment14.otf', 64)\",\n \"def __init__(self, parent):\\n\\n self.__node = avg.RectNode(\\n parent=parent,\\n strokewidth=3,\\n color=vs_config.SELECTION_FEEDBACK_COLOR,\\n sensitive=False\\n )\",\n \"def _initUI(self) -> None:\\n self._createActions()\\n self._addActionsToMoveButtons()\\n self._createToolBar()\\n self._createStatusBar()\\n self._createMainContextMenu()\",\n \"def __init__(self, parent, rokucontrol=None, is_error=False, error_message=''):\\n tk.Frame.__init__(self, parent, background=\\\"black\\\")\\n self.style = ttk.Style()\\n self.parent = parent\\n self.rokucontrol = rokucontrol\\n\\n self.init_ui()\\n\\n if is_error:\\n self.place_error_message(error_message)\\n else:\\n self.place_buttons()\\n self.place_app_buttons()\",\n \"def __init__(self, parent, *args, **kwargs):\\n tk.LabelFrame.__init__(self, parent, *args, **kwargs)\\n self.canvas = MainCanvas(self, bg=\\\"orange\\\")\\n self.canvas.pack(side='top', fill='both', expand=True)\",\n \"def __init__(self, parent=None):\\n\\t\\tScriptedLoadableModuleWidget.__init__(self, parent)\\n\\t\\tVTKObservationMixin.__init__(self) # needed for parameter node observation\\n\\t\\tself.logic = None\\n\\t\\tself._parameterNode = None\\n\\t\\tself._updatingGUIFromParameterNode = False\\n\\t\\t\\n\\t\\tself.elecModel = None\\n\\t\\tself.elecModelLastButton = None\\n\\t\\tself.elecModelButton = 0\\n\\t\\tself.elecChanLastButton = None\\n\\t\\tself.elecChanButton = 0\\n\\t\\tself.lastPolButton=0\\n\\t\\tself.active = False\",\n \"def __init__(self, root):\\n self.app=root\\n self.app.geometry('800x500')\\n self.app.title(\\\"Bryce Streeper: Asset Allocation Visual \\\")\\n self.makeTitle()\\n self.makeGraph()\\n self.makeSliders()\\n self.update()\",\n \"def __init__(self, parent):\\n super(StageInterface, self).__init__(parent)\\n\\n # Make the sizer\\n self.sizer = wx.BoxSizer(wx.HORIZONTAL)\\n\\n # Make the toolbar, then add it to the sizer\\n self.tb = wx.ToolBar(self, style=wx.TB_VERTICAL)\\n self.sizer.Add(self.tb, 0, wx.EXPAND)\\n\\n # Make the visualizer\\n self.set_visualization(StageVisualizer(self))\\n\\n # We want to see what's in the sizer\\n self.SetSizer(self.sizer)\",\n \"def __init__(self, parent=None):\\n super().__init__(parent)\\n\\n topLayout = QtGui.QVBoxLayout(self)\\n self.setLayout(topLayout)\\n self.setTitle(_('Choose export format subtype'))\\n self.subtypeButtons = QtGui.QButtonGroup(self)\\n self.subtypeButtons.buttonClicked[int].connect(self.setCurrentSubtype)\",\n \"def __init__(self):\\n # Root window\\n self.root = tk.Tk()\\n self.root.title(\\\"Crossword\\\")\\n # Padding frame\\n self.frame = tk.Frame(self.root)\\n self.frame.pack(fill=\\\"both\\\", padx=PAD, pady=PAD)\\n # Initialize widget groups\\n self.header = HeaderView(self)\\n self.puzzle = PuzzleView(self)\\n self.clues = CluesView(self)\\n # Show widgets\\n self.header.show()\\n self.puzzle.show()\\n self.clues.show()\",\n \"def initialize(self):\\n super(QtTreeView, self).initialize()\\n self.set_header_visible(self.shell_obj.header_visible)\",\n \"def initializeUI(self):\\n self.setStyleSheet(abstyle)\\n self.setGeometry(140, 100, 860, 484)\\n self.setWindowTitle('Emotions Data View')\\n self.setupModelView()\",\n \"def __init__(self, parent):\",\n \"def __init__(self, parent=None):\\n super(ProgressDlg, self).__init__(parent)\\n self.setupUi(self)\",\n \"def initGUI(self):\\n\\n\\t\\t# Set main frame's location \\n\\t\\tself.grid(row=0, column=0, sticky=\\\"nsew\\\")\\n\\n\\t\\t# Set path entry frame and its location\\n\\t\\tself.entryFrame = Frame(self, relief = RAISED, borderwidth = 1)\\n\\t\\tself.entryFrame.pack(fill = BOTH, expand = False)\\n\\t\\t# Make label\\n\\t\\tif self.message:\\n\\t\\t\\tmessageLabel = Label(self.entryFrame, text = self.message, font=(\\\"Bradley\\\", 10))\\n\\t\\t\\tmessageLabel.pack(anchor=W, padx=0, pady=0)\\n\\n\\t\\t# Set path entry and its location\\n\\t\\tself.filePathEntry = Entry(self.entryFrame, bd = 4, width = 50)\\n\\t\\tself.filePathEntry.pack(side = LEFT, padx=2, pady=1)\",\n \"def _initialize(self):\\n self._frame = ttk.Frame(master=self._root)\\n self._ingredients_frame = ttk.Frame(master=self._frame)\\n\\n self._create_header()\\n self._show_ingredient_list()\\n self._create_footer()\\n\\n self._ingredients_frame.grid(row=1, column=1, columnspan=2)\\n self._frame.grid_columnconfigure(1, weight=1, minsize=250)\",\n \"def Tree_Frame( self ):\\r\\n #Create pane\\r\\n p = self.pane_widget.add( \\\"Tree\\\", min = 0.2, max = 0.9, size = 0.5 )\\r\\n frame_tree = Frame( p )\\r\\n #Add the scale\\r\\n self.canvas_scale = Canvas( frame_tree, height = 10 )\\r\\n self.canvas_scale.bind( '<Button-1>', self.Scale_Pick )\\r\\n self.canvas_scale.bind( '<B1-Motion>', self.Scale_Pick )\\r\\n self.canvas_scale.pack(side = TOP)\\r\\n #canvas for drawing the tree on \\r\\n self.canvas_one = Canvas( frame_tree )\\r\\n #Make sure these values are consistent with self.canvas_two in Data_Frame\\r\\n self.canvas_one.pack( side = TOP , fill = BOTH , expand = 1 )\\r\\n self.canvas_one.bind( '<ButtonRelease-1>', self.Tree_Pick )\\r\\n frame_tree.pack( side = LEFT, fill = BOTH )\",\n \"def __init__(self):\\n self.root = self.Node()\",\n \"def __init__(self, parent):\\r\\n\\r\\n BasicDialog.__init__(self, parent, title=None)\",\n \"def __init__(self):\\n super().__init__()\\n # init attributes\\n self.grScene: Union[GraphicsScene, None] = None\\n\\n self.nodes = []\\n self.edges = []\\n self.scene_width = 64000\\n self.scene_height = 64000\\n\\n # custom flag used to suppress triggering onItemSelected which does a bunch of stuff\\n self._silent_selection_events = False\\n # flag identifying wether the current scene has been modified\\n self._has_been_modified = False\\n self._last_selected_items = None\\n\\n # initialize all listeners\\n self._has_been_modified_listeners = [] # list of function to call when the scene is modified\\n self._item_selected_listeners = []\\n self._items_deselected_listeners = []\\n\\n # Store callback for retrieving the class for Nodes\\n self.node_class_selector = None\\n\\n self.initUI()\\n self.history = SceneHistory(self)\\n self.clipboard = SceneClipboard(self)\\n\\n self.grScene.itemSelected.connect(self.onItemSelected)\\n self.grScene.itemsDeselected.connect(self.onItemsDeselected)\",\n \"def create(self, parent):\\n self.widget = QFrame(parent)\",\n \"def init_file_tree(self):\\r\\n # layout for the file explorer\\r\\n path=QtCore.QDir.currentPath()\\r\\n\\r\\n # file system model init\\r\\n self.model = QtWidgets.QFileSystemModel()\\r\\n self.model.setRootPath(path)\\r\\n self.model.setNameFilterDisables(False)\\r\\n \\r\\n # tree view init and settings\\r\\n self.tree = QtWidgets.QTreeView()\\r\\n self.tree.setModel(self.model)\\r\\n self.tree.setRootIndex(self.model.index(path))\\r\\n self.tree.setAnimated(False)\\r\\n self.tree.setIndentation(20)\\r\\n self.tree.setSortingEnabled(True)\\r\\n self.tree.sortByColumn(0,QtCore.Qt.AscendingOrder)\\r\\n self.tree.setColumnWidth(0,200)\\r\\n self.tree.setColumnWidth(1,100)\\r\\n self.tree.setColumnWidth(2,100)\\r\\n self.tree.setItemsExpandable(False)\\r\\n\\r\\n # set path\\r\\n self.set_new_path(path)\\r\\n\\r\\n # event mappers\\r\\n self.tree.selectionModel().selectionChanged.connect(self.select_change)\\r\\n self.tree.doubleClicked.connect(self.open_file_directory) \\r\\n self.tree.activated.connect(self.open_file_directory)\\r\\n\\r\\n # adding the tree to the layout\\r\\n self.layout_explorer_tree = QtWidgets.QGridLayout()\\r\\n self.layout_explorer_tree.addWidget(self.tree)\",\n \"def __init__(self, parent, controller):\\n super().__init__(parent, width=\\\"10m\\\")\\n\\n self.parent = parent\\n self.controller = controller\\n\\n self.grid_propagate(0)\\n\\n self.rowconfigure(0, weight=1)\\n self.rowconfigure(1, weight=20)\\n self.rowconfigure(2, weight=20)\\n self.columnconfigure(0, weight=1)\\n self.columnconfigure(1, weight=1)\\n\\n if (self.controller.game.color_queried and\\n self.controller.game.in_turn == 0):\\n self.create_title()\\n self.create_buttons()\",\n \"def __init__(self):\\n super().__init__()\\n self.geometry('{}x{}'.format(425, 185))\\n self.title('PAD Tracker')\\n self.frame = Frame(self)\\n self.populateFields()\\n self.frame.pack()\",\n \"def init_gui(self):\\n # Choose a layout.\\n main_vb = QtGui.QVBoxLayout(self)\\n\\n # Add a list or tree view.\\n self.list_view = QtGui.QListWidget()\\n\\n # Add the buttons.\\n load_btn = QtGui.QPushButton('Load Selected')\\n cancel_btn = QtGui.QPushButton('Cancel')\\n load_btn.clicked.connect(self.update_list_view)\\n cancel_btn.clicked.connect(self.close)\\n\\n # Connect the list/tree view with a method appropriate for user interaction.\\n self.list_view.currentItemChanged['QListWidgetItem*', 'QListWidgetItem*'].connect(self.set_current_name)\\n self.list_view.itemChanged['QListWidgetItem*'].connect(self.change_name)\\n\\n # Add the widgets to the layout.\\n btn_hb = QtGui.QHBoxLayout()\\n btn_hb.addWidget(load_btn)\\n btn_hb.addWidget(cancel_btn)\\n main_vb.addWidget(self.list_view)\\n main_vb.addLayout(btn_hb)\\n\\n # Show the GUI.\\n self.setGeometry(300, 300, 450, 300)\\n self.setWindowTitle('Hello World')\\n img_icon = 'C:/Users/caj150430/code/so_much_win.png'\\n self.setWindowIcon(QtGui.QIcon(img_icon))\\n self.show()\",\n \"def __init__(self):\\n self.root = self.Node(None)\",\n \"def __init__(self):\\n self.root = TreeNode(\\\"\\\")\",\n \"def __init__(self):\\n self.root = TreeNode(\\\"\\\")\",\n \"def __init__(self, parent, id, title):\\n wx.Frame.__init__(self, parent, id, title, size=(1200, 560))\\n self.SetBackgroundColour(wx.Colour(0, 0, 360))\\n self.SetIcon(wx.Icon(gv.ICO_PATH))\\n gv.iGeoMgr = self.geoMgr = GeoMgr(self)\\n gv.iDCPosMgr = DataCenterMgr(self)\\n self.SetSizer(self._buidUISizer())\",\n \"def __init__(self, parent: View):\\n super().__init__(parent)\\n # Across label\\n self.across_label = tk.Label(self.frame)\\n # Across frame\\n self.across_frame = tk.Frame(self.frame)\\n # Across list and scrollbar\\n self.across_listbox = tk.Listbox(self.across_frame)\\n self.across = ListVar(self.across_listbox)\\n self.across_scrollbar = tk.Scrollbar(self.across_frame)\\n # Down Label\\n self.down_label = tk.Label(self.frame)\\n # Down frame\\n self.down_frame = tk.Frame(self.frame)\\n # Down list and scrollbar\\n self.down_listbox = tk.Listbox(self.down_frame)\\n self.down = ListVar(self.down_listbox)\\n self.down_scrollbar = tk.Scrollbar(self.down_frame)\\n # Load\\n self.load()\",\n \"def __init__(self):\\n self.root = Node('')\",\n \"def initializeUI(self):\\n self.setGeometry(100, 100, 450, 300)\\n self.setWindowTitle('Model and View Example')\\n\\n self.setupModelView()\\n\\n self.show()\",\n \"def init_ui(self):\\n raise NotImplementedError\",\n \"def init_ui(self):\\n raise NotImplementedError\",\n \"def __init__(self, model):\\r\\n\\r\\n gtk.Frame.__init__(self)\\r\\n\\r\\n # Define private dictionary attributes.\\r\\n\\r\\n # Define private list attributes.\\r\\n self._lst_count_labels = [u\\\"<span foreground=\\\\\\\"blue\\\\\\\">\\\\u03BB<sub>EQUIP</sub> = \\\\u03BB<sub>g</sub></span>\\\",\\r\\n u\\\"\\\\u03BB<sub>g</sub>:\\\"]\\r\\n self._lst_stress_labels = [u\\\"<span foreground=\\\\\\\"blue\\\\\\\">\\\\u03BB<sub>p</sub> = \\\\u03BB<sub>b</sub>\\\\u03C0<sub>E</sub></span>\\\",\\r\\n u\\\"\\\\u03BB<sub>b</sub>:\\\",\\r\\n u\\\"\\\\u03C0<sub>E</sub>:\\\"]\\r\\n\\r\\n # Define private scalar attributes.\\r\\n self._hardware_model = model\\r\\n self._subcategory = model.subcategory\\r\\n\\r\\n # Define public dictionary attributes.\\r\\n\\r\\n # Define public list attributes.\\r\\n\\r\\n # Define public scalar attributes.\\r\\n self.txtLambdaB = Widgets.make_entry(width=100, editable=False,\\r\\n bold=True)\\r\\n self.txtPiE = Widgets.make_entry(width=100, editable=False, bold=True)\\r\\n\\r\\n # Create the tooltips for all the results display widgets.\\r\\n self.txtLambdaB.set_tooltip_text(_(u\\\"Displays the base hazard rate \\\"\\r\\n u\\\"for the selected fuse.\\\"))\\r\\n self.txtPiE.set_tooltip_text(_(u\\\"Displays the environment factor for \\\"\\r\\n u\\\"the selected fuse.\\\"))\",\n \"def __init__(self):\\n self.root = TreeNode('#')\",\n \"def __init__(self,tree):\\n self._tree = tree\",\n \"def __init__(self, level, parent):\\n self.color = Color(0, 0, 0)\\n self.pixel_count = 0\\n self.palette_index = 0\\n self.children = [None for _ in range(8)]\\n # add node to current level\\n if level < OctreeQuantizer.MAX_DEPTH - 1:\\n parent.add_level_node(level, self)\",\n \"def __init__(self):\\n super(ProcessorHeader, self).__init__()\\n self.setupUi(self)\\n self.layout().setContentsMargins(0, 0, 0, 0)\\n \\n # Override path to CBSD logo\\n logoPath = os.path.join(os.path.dirname(__file__),\\n '../resources/images/cbsd_logo.png')\\n logoPath = os.path.normpath(logoPath)\\n \\n self.logoLabel.setPixmap(QtGui.QPixmap(logoPath))\\n \\n self.notesLabel.setSizePolicy(QtGui.QSizePolicy.Preferred,\\n QtGui.QSizePolicy.Ignored)\\n \\n ## \\\\c{(bool)} Whether additional instructions related to the shot\\n # processor configuration are visible.\\n self.notesVisible = False\\n \\n ## \\\\c{(hiero.core.FnExportStructure.ExportStructure2)} A reference to\\n # the current preset's export template.\\n #\\n # @details Set externally by WiretapShotProcessor.populateUI().\\n self.exportTemplate = None\\n \\n ## \\\\c{(hiero.ui.ExportStructureViewer)} A reference to the Wiretap shot\\n # processor's export structure viewer.\\n #\\n # @details Set externally by WiretapShotProcessor.populateUI().\\n self.exportStructureViewer = None\\n \\n # Signal-slot pairs\\n self.notesButton.clicked.connect(self.ToggleNotes)\\n self.chooseButton.clicked.connect(self.ChooseNodePath)\\n self.clipNameEdit.textEdited.connect(self.__FixClipName)\\n self.addElementButton.clicked.connect(self.AddElement)\",\n \"def set_ui(self):\\r\\n\\r\\n self.canvas = tk.Canvas(self)\\r\\n self.canvas.pack()\\r\\n\\r\\n self.entry = ttk.Entry(self.canvas, justify=\\\"center\\\", font=(\\\"Calibri\\\", 12))\\r\\n\\r\\n self.grid = Grid(self.canvas)\",\n \"def create(self, parent):\\n self.widget = _QMainWindow(parent)\",\n \"def initCentralUic(self):\\n self.initFileTableWidget()\\n self.initViewerStack()\\n self.splitter.setSizes([150, 850])\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.76014423","0.7525523","0.7442736","0.7348248","0.7325853","0.7277504","0.72760564","0.7221381","0.7190728","0.7139197","0.71225977","0.709324","0.7070534","0.7013553","0.691987","0.6911241","0.69035274","0.6893549","0.6848428","0.68216026","0.6812221","0.68075293","0.6796633","0.6796633","0.6791271","0.6784826","0.6784826","0.6784826","0.6784826","0.6784826","0.678154","0.67615324","0.6748353","0.67370784","0.67370784","0.67370784","0.67235494","0.6697958","0.667037","0.66585124","0.6650739","0.6647246","0.66466945","0.66412497","0.6638952","0.6631091","0.66228443","0.66219926","0.66219807","0.66219807","0.66182137","0.660806","0.660806","0.6604037","0.66037637","0.65903443","0.6570517","0.656146","0.65569365","0.6547259","0.6539744","0.6534062","0.65338373","0.65312535","0.6528816","0.6517769","0.6515245","0.6508325","0.6502282","0.6498656","0.6482629","0.64818746","0.6478966","0.6478188","0.6473924","0.64729404","0.6470295","0.6462934","0.6447014","0.6446636","0.6445699","0.64417315","0.6431138","0.6426547","0.6424411","0.64174813","0.64174813","0.6409482","0.64077646","0.64076865","0.6401919","0.6399548","0.6399548","0.6395954","0.6391963","0.63858104","0.6369186","0.6367204","0.63608336","0.6357522","0.6353451"],"string":"[\n \"0.76014423\",\n \"0.7525523\",\n \"0.7442736\",\n \"0.7348248\",\n \"0.7325853\",\n \"0.7277504\",\n \"0.72760564\",\n \"0.7221381\",\n \"0.7190728\",\n \"0.7139197\",\n \"0.71225977\",\n \"0.709324\",\n \"0.7070534\",\n \"0.7013553\",\n \"0.691987\",\n \"0.6911241\",\n \"0.69035274\",\n \"0.6893549\",\n \"0.6848428\",\n \"0.68216026\",\n \"0.6812221\",\n \"0.68075293\",\n \"0.6796633\",\n \"0.6796633\",\n \"0.6791271\",\n \"0.6784826\",\n \"0.6784826\",\n \"0.6784826\",\n \"0.6784826\",\n \"0.6784826\",\n \"0.678154\",\n \"0.67615324\",\n \"0.6748353\",\n \"0.67370784\",\n \"0.67370784\",\n \"0.67370784\",\n \"0.67235494\",\n \"0.6697958\",\n \"0.667037\",\n \"0.66585124\",\n \"0.6650739\",\n \"0.6647246\",\n \"0.66466945\",\n \"0.66412497\",\n \"0.6638952\",\n \"0.6631091\",\n \"0.66228443\",\n \"0.66219926\",\n \"0.66219807\",\n \"0.66219807\",\n \"0.66182137\",\n \"0.660806\",\n \"0.660806\",\n \"0.6604037\",\n \"0.66037637\",\n \"0.65903443\",\n \"0.6570517\",\n \"0.656146\",\n \"0.65569365\",\n \"0.6547259\",\n \"0.6539744\",\n \"0.6534062\",\n \"0.65338373\",\n \"0.65312535\",\n \"0.6528816\",\n \"0.6517769\",\n \"0.6515245\",\n \"0.6508325\",\n \"0.6502282\",\n \"0.6498656\",\n \"0.6482629\",\n \"0.64818746\",\n \"0.6478966\",\n \"0.6478188\",\n \"0.6473924\",\n \"0.64729404\",\n \"0.6470295\",\n \"0.6462934\",\n \"0.6447014\",\n \"0.6446636\",\n \"0.6445699\",\n \"0.64417315\",\n \"0.6431138\",\n \"0.6426547\",\n \"0.6424411\",\n \"0.64174813\",\n \"0.64174813\",\n \"0.6409482\",\n \"0.64077646\",\n \"0.64076865\",\n \"0.6401919\",\n \"0.6399548\",\n \"0.6399548\",\n \"0.6395954\",\n \"0.6391963\",\n \"0.63858104\",\n \"0.6369186\",\n \"0.6367204\",\n \"0.63608336\",\n \"0.6357522\",\n \"0.6353451\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":89890,"cells":{"query":{"kind":"string","value":"Returns ranked accuracy given true classes and predicted probabilities."},"document":{"kind":"string","value":"def top_k_accuracy(y_true : np.ndarray, probs: np.ndarray, k: int) -> float:\r\n \r\n # Top k sorted preds\r\n sorted_probs = probs.argsort()[:,-k:]\r\n\r\n # Does the truth intersect with any of the top k predictions?\r\n matches = np.max(sorted_probs == y_true.reshape(-1, 1), axis=1)\r\n return matches.mean()"},"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 calc_accuracy(true, predicted):\n return sum([t==p for t,p in zip(true, predicted)]) / float(len(true))","def accuracy(preds, labels):\n correct = preds == labels\n return correct.sum().float() / correct.shape[0]","def accuracy(predicted, ground_truth):\n predicted_labels_decoded = np.argmax(predicted, axis=1)\n ground_truth_labels_decoded = np.argmax(ground_truth, axis=1)\n correct_rate = [1 if pred == truth else 0 for (pred, truth) in\n zip(predicted_labels_decoded, ground_truth_labels_decoded)]\n accuracy = sum(correct_rate) / ground_truth_labels_decoded.size\n return accuracy * 100","def accuracy(actual, predicted):\n return np.sum(predicted == actual) / actual.shape[0]","def accuracy(labels, predictions, n_classes):\n\t\tequality = tf.equal(x = predictions, y = labels) # match the type of labels\n\t\treturn tf.reduce_mean(tf.cast(equality, tf.float32))","def accuracy_score(truth, predicted):\n return len(np.where(truth==predicted)[0]) / len(truth)","def accuracy_score(truth, predicted):\n return len(np.where(truth==predicted)[0]) / len(truth)","def accuracy(probabilities: np.ndarray, labels: np.ndarray) -> float:\n # [batch_size]\n predictions = probabilities.argmax(axis=1)\n # [batch_size]\n labels = labels.argmax(axis=1)\n return (predictions == labels).astype(int).mean()","def accuracy(predictions, test_labels):\n return f1_score(test_labels, predictions, average='micro') * 100","def accuracy(labels, preds):\n\tassert labels.shape[0]==preds.shape[0]\n\treturn np.sum(preds==labels)/float(labels.shape[0])","def accuracy(predictions, labels):\n return (100.0 * np.sum(np.argmax(predictions, 1) == np.argmax(labels, 1)) / predictions.shape[0])","def accuracy(labels, predictions):\n if len(labels) != len(predictions):\n return -1\n\n correct = 0\n total = 0\n\n for i,v in enumerate(predictions):\n if labels[i] == str(v):\n correct += 1\n total += 1\n\n return (float(correct) / float(total)) * 100.0","def accuracy(pred, target):\n N = pred.shape[0]\n return (pred == target).sum() * 1.0 / N","def accuracy_score(y_true, y_predict):\n assert y_true.shape[0] == y_predict.shape[0], \\\n \"The size of y_true must be equal to y_predict\"\n\n return sum(y_true == y_predict) / len(y_true)","def accuracy(y_pred, y_true):\n # Number of correct predictions\n correct = (y_pred == y_true).sum()\n # Predictions accuracy\n acc = correct / (len(y_pred[0]) * y_pred.shape[0]) * 100\n # Accuracy of non zero pixels predictions\n non_zero = (y_true > 0).sum()\n non_zero_correct = (y_pred[y_true > 0] == y_true[y_true > 0]).sum()\n if non_zero == 0:\n if non_zero_correct == 0:\n non_zero_acc = 100.0\n else:\n non_zero_acc = 0.0\n else:\n\n non_zero_acc = non_zero_correct / non_zero * 100\n return acc, non_zero_acc, non_zero_correct","def accuracy_score(y_true, y_pred):\n accuracy = np.sum(y_true == y_pred, axis=0) / len(y_true)\n return accuracy","def accuracy_score(y_true, y_pred):\n accuracy = np.sum(y_true == y_pred, axis=0) / len(y_true)\n return accuracy","def get_accuracy(test_sets, predictions, class_index):\n actual_classes = [test_set[class_index] for test_set in test_sets]\n\n num_correct = sum(int(actual == prediction) for actual, prediction in zip(actual_classes, predictions))\n\n return float(num_correct) / len(test_sets)","def evaluate_prediction(classifier, test_data, labels):\n \n predictions = classifier.predict(test_data)\n \n return accuracy_score(labels, predictions)","def multiclass_accuracy(prediction, ground_truth):\n correct = sum(a == b for a, b in zip(prediction, ground_truth))\n\n accuracy = correct / len(ground_truth)\n\n return accuracy","def accuracy(predictions, targets):\n return accuracy","def accuracy(pred, labels):\n pred = torch.sigmoid(pred)\n predicted = (pred > 0.5).int()\n correct = (predicted == labels).sum().item()\n return correct / labels.shape[0]","def predictionAccuracy(self, predicted, actual):\n\t\taccuracyCount=0\n\n\t\t###### your implementation below ######\n\t\tfor x in range(len(predicted)):\n\t\t\tif (predicted[x] == actual[x]):\n\t\t\t\taccuracyCount += 1\n\t\taccuracyCount /= len(predicted)\n\t\treturn accuracyCount;","def accuracy ( actuals, predictions ):\n return np.mean ( actuals == predictions )\n # End accuracy()","def accuracy ( actuals, predictions ):\n return np.mean ( actuals == predictions )\n # End accuracy()","def accuracy_score(Y_true, Y_predict):\n \n true = 0\n\n for i in range(len(Y_predict)):\n if Y_true[i] == Y_predict[i]:\n true+=1\n acc = true/float(len(Y_true))* 100.0\n return acc","def accuracy_score(y_true, y_pred):\n\ttp, fn, fp, tn = confusion_matrix(y_true, y_pred, table_show=False)\n\n\treturn (tp+tn) / (tp+tn+fn+fp)","def accuracy_fn(y_true, y_pred):\n correct = torch.eq(y_true, y_pred).sum().item()\n acc = (correct / len(y_pred)) * 100\n return acc","def compute_accuracy(labels=None, predictions=None):\n labels = np.array(labels, dtype=np.int32)\n if len(labels.shape) == 2:\n labels = np.argmax(labels, -1)\n return np.sum(np.equal(labels, predictions)) / np.size(labels)","def accuracy(predictions, labels):\n predictions = list(predictions)\n labels = list(labels)\n count = 0\n for i in range(len(labels)):\n if labels[i] == predictions[i]:\n count += 1\n\n return count / len(labels)","def accuracy_score(preds, y):\n accuracy = sum([1 for i in range (len(preds)) if preds[i] == y[i]])*1.0/len(preds) \n return accuracy","def accuracy(classifier_output, true_labels):\n\n # TODO: finish this.\n conf_matrix = confusion_matrix(classifier_output, true_labels)\n return (conf_matrix[0][0]+conf_matrix[1][1])/(conf_matrix[0][0] + conf_matrix[0][1]\\\n + conf_matrix[1][0] + conf_matrix[1][1])","def accuracy(predictions, targets):\n correct_count = 0\n for prediction, target in zip(predictions, targets):\n if prediction == target:\n correct_count += 1\n return correct_count / len(predictions)","def accuracy(predictions, targets):\n\n ########################\n # PUT YOUR CODE HERE #\n #######################\n i1 = np.arange(0, len(targets), 1)\n i2 = np.argmax(predictions, axis = 1)\n accuracy = targets[i1, i2].sum()/targets.sum()\n ########################\n # END OF YOUR CODE #\n #######################\n\n return accuracy","def accuracy(predictions, targets):\n\n ########################\n # PUT YOUR CODE HERE #\n #######################\n n_samples = targets.shape[0]\n _, y_pred = predictions.max(dim=1)\n accuracy = (y_pred == targets).sum().item() / n_samples\n ########################\n # END OF YOUR CODE #\n #######################\n\n return accuracy","def accuracy(predictions, targets):\n\n ########################\n # PUT YOUR CODE HERE #\n #######################\n correct = 0\n for i in range(len(targets)):\n if(predictions[i] == targets[i]):\n correct += 1\n accuracy = correct/len(targets)\n #raise NotImplementedError\n ########################\n # END OF YOUR CODE #\n #######################\n\n return accuracy","def label_accuracy_score(label_true, label_pred, n_class):\n hist = _fast_hist(label_true.flatten(), label_pred.flatten(), n_class)\n acc = np.diag(hist).sum() / hist.sum().astype(np.float64)\n acc_cls = np.diag(hist) / hist.sum(axis=1).astype(np.float64)\n acc_cls = np.nanmean(acc_cls)\n iu = np.diag(hist) / (hist.sum(axis=1) + hist.sum(axis=0) - np.diag(hist)).astype(np.float64)\n mean_iu = np.nanmean(iu)\n freq = hist.sum(axis=1) / hist.sum().astype(np.float64)\n fwavacc = (freq[freq > 0] * iu[freq > 0]).sum()\n return acc, acc_cls, mean_iu, fwavacc","def ranked_accuracy(predictions, labels):\n rank1 = 0\n rank5 = 0\n\n for (pred, lbl) in zip(predictions, labels):\n pred = np.argsort(pred)[::-1]\n\n if lbl in pred[:5]:\n rank5+=1\n\n if lbl == pred[0]:\n rank1+=1\n\n rank1 /= float(len(labels))\n rank5 /= float(len(labels))\n\n return (rank1, rank5)","def accuracy(outputs, labels):\n predicted = outputs.argmax(dim=1)\n correct = (predicted == labels).sum().item()\n return correct / labels.size(0)","def accuracy(self, probabilities, labels):\n # TODO: calculate the batch accuracy\n count = 0\n for x in range(len(probabilities)):\n if np.argmax(labels[x]) == np.argmax(probabilities[x]):\n count += 1\n return count/len(probabilities)","def accuracy(cls, test_labels):\n N = len(test_labels)\n\n # Calculate total correct as precentage\n total_correct = 100*(N - np.count_nonzero(cls - test_labels))/N\n\n # Calculate precentag correct for each class\n lab = np.unique(test_labels)\n cls_correct = {}\n for label in lab:\n idx = np.where(test_labels == label)[0]\n N_cls = len(idx)\n cls_correct[label] = 100*(N_cls - np.count_nonzero(label -\n cls[idx]))/N_cls\n\n print(\"Accuracy for:\")\n print(\"All classes is %.2f%%\" % total_correct)\n for label in lab:\n print(\"Class %d is %.2f%%\" % (label, cls_correct[label]))\n return(total_correct, cls_correct)","def accuracy(self,predicted, original):\n TP=0\n TN=0\n FP=0\n FN=0\n for i in range(len(predicted)):\n if(predicted[i]==1 and original[i]==1):\n TP+=1\n elif(predicted[i]==0 and original[i]==1):\n FN+=1\n elif(predicted[i]==1 and original[i]==0):\n FP+=1\n elif(predicted[i]==0 and original[i]==0):\n TN+=1\n\n acc = (TP+TN)/(TP+TN+FP+FN)\n return acc","def accuracy(predictions, targets):\n\n compare = predictions == targets\n # compare = (predictions.argmax(dim=1)) == (targets)\n # compare = (predictions.argmax(dim=1)) == (targets.argmax(dim=1))\n # summed = compare.sum().item()\n summed = compare.sum()\n # print(summed, compare.size())\n # print(compare.size()[0])\n return summed/compare.size","def get_accuracy(actual, predicted):\n predicted_correct = 0\n # for each index in the actual result\n for i in range(len(actual)):\n # if actual is the same as predicted\n if actual[i] == predicted[i]:\n predicted_correct+=1\n return predicted_correct/len(actual)","def accuaracy_score(y_true, y_pred):\n\taccuracy = np.sum(y_true == y_pred, axis=0) / len(y_true)\n\treturn accuracy","def accuracy(y_true, y_pred):\n assert y_true.shape == y_pred.shape\n return (y_true == y_pred).mean()","def percent_accuracy(self, true_values, predicted_values):\n\n correct = 0\n size = len(true_values)\n for i in range(len(true_values)):\n true_labels = true_values[i]\n predicted_labels = predicted_values[i]\n predicted_index = np.argmax(predicted_labels)\n\n if true_labels[predicted_index] == 1:\n correct += 1","def accuracy(y_true, y_pred):\r\n\r\n cm = confusion_matrix(y_true=y_true, y_pred=y_pred)\r\n cost_m = np.max(cm) - cm\r\n indices = linear_sum_assignment(cost_m)\r\n indices = np.asarray(indices)\r\n indexes = np.transpose(indices)\r\n total = 0\r\n for row, column in indexes:\r\n value = cm[row][column]\r\n total += value\r\n return total * 1. / np.sum(cm)","def accuracy(targets: List[List[float]], predict: List[List[float]]):\r\n correct = 0\r\n for i in range(len(targets)):\r\n if predict[i] == targets[i]:\r\n correct += 1\r\n return correct / len(targets) * 100","def get_accuracy(self, gold, predicted):\n # Exercise 3: calculate accuracy\n i = 0\n j = 0\n for labels in gold:\n if labels == predicted[i]:\n j +=1\n i +=1\n return j / i * 100","def accuracy(gt, pred):\n \n return np.mean(gt == pred)","def accuracy(links_true, links_pred=None, total=None):\n\n if isinstance(total, pandas.MultiIndex):\n total = len(total)\n\n if _isconfusionmatrix(links_true):\n confusion_matrix = links_true\n\n v = (confusion_matrix[0, 0] + confusion_matrix[1, 1]) / numpy.sum(\n confusion_matrix\n )\n else:\n tp = true_positives(links_true, links_pred)\n tn = true_negatives(links_true, links_pred, total)\n\n v = (tp + tn) / total\n\n return float(v)","def accuracy_score(predictions, targets):\n if len(predictions.shape) > 1:\n predictions = np.argmax(predictions, axis=1)\n if len(targets.shape) > 1:\n targets = np.argmax(targets, axis=1)\n\n return np.sum(predictions == targets) * 1 / predictions.shape[0]","def discriminator_accuracy(predicted, y_true):\n total = y_true.size(0)\n correct = (torch.abs(predicted - y_true) <= 0.5).sum().item()\n accuracy = 100.0 * correct / total\n return accuracy","def accuracy_score(y_true, y_pred_proba, threshold=0.5):\n\n y_pred = predict_with_threshold(y_pred_proba, threshold)\n\n acc = pd.concat([y_true.rename('y_true'), y_pred], axis=1)\n tp = acc.apply(\n lambda row: 1 if (row.y_true == row.y_pred) else 0,\n axis=1\n ).sum()\n return tp/acc['y_pred'].count()","def evaluate(true_labels, predicted_labels):\n accuracy = np.round(metrics.accuracy_score(true_labels, predicted_labels), \n 2)\n precision = np.round(metrics.precision_score(true_labels, predicted_labels, \n average='weighted'), 2)\n recall = np.round(metrics.recall_score(true_labels, predicted_labels,\n average='weighted'), 2)\n f1 = np.round(metrics.f1_score(true_labels, predicted_labels, \n average='weighted'), 2)\n \n return accuracy, precision, recall, f1","def get_accuracy(pred, test_label, regression= \"logistic\"):\n if regression == \"multiclass\":\n pred_max = np.argmax(pred, axis=1)\n gt_max = np.argmax(test_label, axis=1)\n acc = np.sum(pred_max == gt_max)*100.0/pred.shape[0]\n elif regression == \"logistic\" or regression == \"probit\":\n if pred.ndim == 2:\n pred = pred[:,0]\n pred[pred >= 0.5] = 1.0\n pred[pred < 0.5] = 0.0\n acc = np.sum(pred == test_label)*100.0/pred.shape[0]\n\n return acc","def accuracy_v2(y_true, y_pred):\n tp = true_positive(y_true, y_pred)\n fp = false_positive(y_true, y_pred)\n fn = false_negative(y_true, y_pred)\n tn = true_negative(y_true, y_pred)\n accuracy_score = (tp + tn) / (tp + tn + fp + fn)\n return accuracy_score","def score_prediction(y_true, y_pred):\n return [round(metrics.accuracy_score(y_true, y_pred)*100, 2),\n round(metrics.precision_score(y_true, y_pred)*100, 2),\n round(metrics.recall_score(y_true, y_pred)*100, 2),\n round(metrics.f1_score(y_true, y_pred)*100, 2)]","def accuracy(y_test, y_pred):\n\treturn accuracy_score(y_test, y_pred)","def get_accuracy(self) -> float:\n self.network.load_data()\n self.network.train()\n\n n = len(self.network.y_test)\n correct = 0\n for i in range(n):\n # Predict by running forward pass through the neural network\n pred = self.network.predict(self.network.x_test[i])\n # Sanity check of the prediction\n assert 0 <= pred <= 1, \"The prediction needs to be in [0, 1] range.\"\n # Check if right class is predicted\n correct += self.network.y_test[i] == round(float(pred))\n return round(correct / n, 3)","def accuracy(predicted_logits, reference, argmax=True):\n if argmax:\n labels = torch.argmax(predicted_logits, 1)\n else:\n labels = predicted_logits\n correct_predictions = labels.int().eq(reference.int())\n return correct_predictions.sum().float() / correct_predictions.nelement()","def evaluate_accuracy(self, prediction, reality):\n correct = 0\n for i in range(len(prediction)):\n if prediction[i] == reality[i]:\n correct = correct + 1\n\n return correct / len(prediction)","def accuracy(self, predictions, truth):\n return np.mean(np.argmax(predictions, axis=1) == truth) # <COGLINE>","def getAccuracy(self):\n\t\tcorrect = (self.testing[self.classLabel]==self.bestLabel).sum()\n\t\tself.accuracy = (correct/float(len(self.testing))) * 100.0","def prediction():\r\n\r\n\r\n\tpredictVal = []\r\n\taccuracy = 0.0\r\n\r\n\t# Calculate accuracy for each class in testData\r\n\tfor item in testData:\r\n\t\tclass0Prediction = posProb / 100\r\n\t\tclass1Prediction = negProb / 100\r\n\t\t\r\n\t\t# Multiply the prior probablities for negative and positive reviews by their feature likelihoods \r\n\t\tfor word in item[2]:\r\n\t\t\tclass0Prediction *= class0Dict[word]\r\n\t\t\tclass1Prediction *= class1Dict[word]\r\n\r\n\t\t# Give every item in testData a predicted value\r\n\t\tif(class0Prediction > class1Prediction):\r\n\t\t\tpredictVal.append('0')\r\n\t\telse:\r\n\t\t\tpredictVal.append('1')\r\n\r\n\tfor i in range(len(testData)):\r\n\t\tif(testData[i][1] == predictVal[i]):\r\n\t\t\taccuracy += 1\r\n\r\n\t\t\t\r\n\taccuracy = 100 * (accuracy / len(testData))\r\n\treturn(predictVal, accuracy)","def accuracy_per_class(y_pred, y_test, columns_list):\n accuracy_dict = {}\n correct_index = 0\n incorrect_index = 1\n for row in range(y_pred.shape[0]):\n curr_correct_index = np.argmax(y_test[row])\n curr_col_name = columns_list[curr_correct_index]\n if np.argmax(y_pred[row]) == curr_correct_index:\n if curr_col_name in accuracy_dict:\n accuracy_dict[curr_col_name][correct_index] += 1\n else:\n accuracy_dict[curr_col_name] = [1, 0]\n elif np.argmax(y_pred[row]) != curr_correct_index:\n if curr_col_name in accuracy_dict:\n accuracy_dict[curr_col_name][incorrect_index] += 1\n else:\n accuracy_dict[curr_col_name] = [0, 1]\n for class_name in accuracy_dict:\n lst = accuracy_dict[class_name]\n percentage = lst[correct_index] / (lst[incorrect_index]+lst[correct_index])\n accuracy_dict[class_name].insert(0, percentage)\n return accuracy_dict","def binary_accuracy(preds, y):\n #round predictions to the closest integer\n rounded_preds = torch.round(torch.sigmoid(preds))\n correct = (rounded_preds == y).float() #convert into float for division\n acc = correct.sum() / len(correct)\n return acc","def accuracy_score(y_test, predictions):\n # my implementation\n # correct_prediction = y_test == predictions\n # accuracy_score = (predictions[correct_prediction].shape[0] /\n # (predictions.shape[0] * 1.0))\n\n # better implementation\n if len(y_test) != len(predictions):\n raise ValueError('y_test and predictions are in different shape')\n\n return (y_test == predictions).mean()","def multiclass_accuracy(pr, gt):\n correct_prediction = tf.equal(tf.round(tf.nn.sigmoid(pr)), tf.round(gt))\n accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))\n return accuracy","def get_accuracy_score(labels_true: np.ndarray, labels_pred: np.ndarray) -> float:\n check_vector_format(labels_true, labels_pred)\n mask = (labels_true >= 0) & (labels_pred >= 0)\n if np.sum(mask):\n return np.mean(labels_true[mask] == labels_pred[mask])\n else:\n raise ValueError('No sample with both true non-negative label and predicted non-negative label.')","def accuracy(self):\n total_predictions = self.tp + self.fp + self.tn + self.fn;\n return float(self.tp + self.tn) / total_predictions if total_predictions != 0 else 1","def binary_accuracy(preds, y):\n\n # round predictions to the closest integer\n rounded_preds = torch.round(torch.sigmoid(preds))\n correct = (rounded_preds == y).float() # convert into float for division\n acc = correct.sum() / len(correct)\n return acc","def binary_accuracy(preds, y):\n\n # round predictions to the closest integer\n rounded_preds = torch.round(torch.sigmoid(preds))\n correct = (rounded_preds == y).float() # convert into float for division\n acc = correct.sum() / len(correct)\n return acc","def overall_accuracy(y_true, y_pred):\n pred_flat, true_flat = y_pred.flatten(), y_true.flatten()\n intersection = list(pred_flat == true_flat).count(True)\n sum_ = len(true_flat)\n accuracy = round(intersection/sum_, 4)\n return accuracy","def accuracy_measures(predictions, trues):\n\n tn, fp, fn, tp = confusion_matrix(trues, predictions).ravel()\n print \"\\t(tn, fp, fn, tp) =\", (tn, fp, fn, tp)\n\n # how often is classifier correct?\n print \"\\tAccuracy = {:.2%}\".format(float(tp + tn) / len(trues))\n\n # how often is it wrong?\n print \"\\tMisclassification Rate = {:.2%}\".format(float(fp + fn) / len(trues))\n\n # when actually yes, how often does it predict yes?\n print \"\\tTrue Positive Rate = {:.2%}\".format(float(tp) / trues.count(True))\n\n # when actually no, how often does it predict yes?\n print \"\\tFalse Positive Rate = {:.2%}\".format(float(fp) / trues.count(False))\n\n # when actually no, how often does it predict no?\n print \"\\tSpecificity = {:.2%}\".format(float(tn) / trues.count(False))\n\n # when it predicts yes, how often is it correct?\n print \"\\tPrecision = {:.2%}\".format(float(tp) / predictions.count(True))\n\n # how often does yes condition occur in our sample?\n print \"\\tPrevalence = {:.2%}\\n\".format(float(trues.count(True)) / len(trues))\n\n # return accuracy, precision, and recall score\n return accuracy_score(trues, predictions), precision_score(trues, predictions, average='binary'), recall_score(\n trues, predictions, average='binary')","def binary_accuracy(preds, y):\n\n #round predictions to the closest integer\n rounded_preds = torch.round(torch.sigmoid(preds))\n correct = (rounded_preds == y).float() #convert into float for division\n acc = correct.sum() / len(correct)\n return acc","def categorical_accuracy(preds, y):\n top_pred = preds.argmax(1, keepdim = True)\n correct = top_pred.eq(y.view_as(top_pred)).sum()\n acc = correct.float() / y.shape[0]\n return acc","def binary_classification_metrics(prediction, ground_truth):\n precision = 0\n recall = 0\n accuracy = 0\n f1 = 0\n\n correct = sum(a == b for a, b in zip(prediction, ground_truth))\n\n true_pos = 0\n false_pos = 0\n false_neg = 0\n\n for i in range(len(prediction)):\n if prediction[i]:\n true_pos += (prediction[i] == ground_truth[i])\n false_pos += (prediction[i] != ground_truth[i])\n else:\n false_neg += (prediction[i] != ground_truth[i])\n\n accuracy = correct / len(ground_truth)\n\n if true_pos + false_pos == 0:\n precision = 0\n else:\n precision = true_pos / (true_pos + false_pos)\n if true_pos + false_neg == 0:\n recall = 0\n else:\n recall = true_pos / (true_pos + false_neg)\n if precision + recall == 0:\n f1 = 0\n else:\n f1 = 2 * (precision * recall) / (precision + recall)\n\n return precision, recall, f1, accuracy","def compute_accuracy(self):\n if not self.is_training:\n logits = self.test_logits\n labels = self.data.test_labels\n else:\n logits = self.train_logits\n labels = self.data.labels\n\n predictions = tf.cast(tf.argmax(logits, 1), tf.int32)\n correct = tf.equal(labels, predictions)\n return tf.reduce_mean(tf.cast(correct, tf.float32))","def binary_accuracy(predictions, truth):\n\tcorrect = 0.\n\tfor i in range(len(predictions)):\n\t\tif predictions[i] >= 0.5 and truth[i] == 1:\n\t\t\tcorrect += 1\n\t\telif predictions[i] < 0.5 and truth[i] == 0:\n\t\t\tcorrect += 1\n\tacc = correct/len(predictions)\n\treturn acc","def binary_accuracy(preds, y):\n\n # round predictions to the closest integer\n rounded_predictions = torch.round(torch.sigmoid(preds))\n correct = (rounded_predictions == y).float()\n acc = correct.sum() / len(correct)\n\n return acc","def binary_accuracy(preds, y):\n\n #round predictions to the closest integer\n rounded_preds = torch.round(torch.sigmoid(preds))\n correct = (rounded_preds == y).float() #convert into float for division \n acc = correct.sum() / len(correct)\n return acc","def compute_accuracy(Y_test, Y_pred):\n number_correct_prediction = 0\n for i in range(len(Y_pred)): # They have the same length\n id_pred = np.argmax(Y_pred[i]) # Take the argmax of the prediction\n id_test = np.where(Y_test[i] == 1.)[0][0] # Take the real position of the POS tag\n if id_test == id_pred:\n number_correct_prediction += 1\n\n percentage_correct = number_correct_prediction / len(Y_pred)\n\n return percentage_correct","def evaluate(labels, predictions):\n\n truePositiveCounter = 0\n trueNegativeCounter = 0\n truePositiveCorrect = 0\n trueNegativeCorrect = 0\n \n sensitivity = 0\n specificity = 0\n\n for i in range(len(labels)):\n if labels[i] == 1:\n truePositiveCounter += 1\n if(labels[i] == predictions[i]):\n truePositiveCorrect += 1\n elif labels[i] == 0:\n trueNegativeCounter += 1\n if(labels[i] == predictions[i]):\n trueNegativeCorrect += 1\n\n sensitivity = truePositiveCorrect / truePositiveCounter\n specificity = trueNegativeCorrect / trueNegativeCounter\n\n return sensitivity, specificity","def accuracy(x, y, w):\n p = prob(x, w)\n\n # prediction is class with highest probability\n y_pred = tf.cast(tf.argmax(p, axis=1), tf.float32)\n y = tf.squeeze(y)\n\n # compute accuracy = TP / (TP + FP)\n accuracy_ = tf.reduce_mean(tf.cast(tf.equal(y, y_pred), tf.float32))\n return accuracy_","def binary_accuracy(preds, y, pr=False):\n\n #round predictions to the closest integer\n rounded_preds = torch.round(F.sigmoid(preds))\n ons = torch.where(y == 1)\n ons_correct = (rounded_preds[ons]==y[ons]).float()\n ons_acc = ons_correct.sum() / ons[0].shape[0]\n correct = (rounded_preds == y).float() #convert into float for division\n all_corrects = [1 if torch.all(rounded_preds[:,i] ==y[:,i]) else 0 for i in range(y.size(1))]\n all_correct_acc = sum(all_corrects) / len(all_corrects)\n acc = correct.sum() / (correct.shape[0]*correct.shape[1])\n # if (pr):\n # print(rounded_preds)\n # print(y)\n return acc, ons_acc, all_correct_acc","def accuracy_rate(predictions: torch.Tensor, labels: torch.Tensor) -> float:\n assert len(predictions) == len(labels), \"Predictions and labels must have the same length.\"\n assert len(labels.shape) == 1, \"Labels must be a column vector.\"\n\n return ( # type: ignore\n float((predictions.argmax(1) == labels.to(torch.long)).sum()) / predictions.shape[0]\n )","def get_accuracy(predictions, targets):\n accuracy = (predictions.argmax(1).cpu().numpy() ==\n targets.cpu().numpy()).sum()/(predictions.shape[0])\n return accuracy","def compute_accuracy(self, inputs, true_values):\n predicted_values = self.predict(inputs)\n number_correct = np.sum(predicted_values == true_values)\n accuracy = number_correct / len(predicted_values)\n\n return accuracy","def compute_accuracy(self):\n self.test_predictions = tf.cast(tf.argmax(self.test_logits, 1), tf.int32)\n correct = tf.equal(self.data.test_labels, self.test_predictions)\n return tf.reduce_mean(tf.cast(correct, tf.float32))","def evaluate(labels, predictions):\n\n true_positives = 0\n label_positives = 0\n\n true_negatives = 0\n label_negatives = 0\n\n for i in range(len(predictions)):\n if labels[i] == predictions[i] == 1:\n true_positives += 1\n if labels[i] == 1:\n label_positives += 1\n\n if labels[i] == predictions[i] == 0:\n true_negatives += 1\n if labels[i] == 0:\n label_negatives += 1\n\n return true_positives / label_positives, true_negatives / label_negatives\n\n # raise NotImplementedError","def accuracy(outputs, labels):\n outputs = np.argmax(outputs, axis=1)\n return np.sum(outputs == labels)/float(labels.size)","def accuracy(self):\n # Initialize key variables\n correct = {}\n prediction = 0\n cls_count = {}\n accuracy = {}\n\n # Analyze all the data\n for cls in self.pca_object.classes():\n # Get list of x values to test\n vectors = self.pca_object.xvalues(cls)\n\n # Process each vector\n for vector in vectors:\n # Get the prediction\n prediction = self.classifier(vector)\n\n # Only count definitive predictions\n if prediction is not None:\n # Count the number of correct predictions\n if prediction == cls:\n if cls in correct:\n correct[cls] += 1\n else:\n correct[cls] = 1\n\n # Increment the count\n if cls in cls_count:\n cls_count[cls] += 1\n else:\n cls_count[cls] = 1\n\n # Calculate per class accuracy\n correct[None] = 0\n cls_count[None] = 0\n for cls in cls_count.keys():\n if cls_count[cls] != 0:\n accuracy[cls] = correct[cls] / cls_count[cls]\n\n # Keep a tally for all successes\n correct[None] = correct[None] + correct[cls]\n cls_count[None] = cls_count[None] + cls_count[cls]\n\n # Calulate overall accuracy\n accuracy[None] = correct[None] / cls_count[None]\n\n # Return\n return accuracy","def accuracy(targets: List[int],\n preds: Union[List[float], List[List[float]]],\n threshold: float = 0.5) -> float:\n if type(preds[0]) == list: # multiclass\n hard_preds = [p.index(max(p)) for p in preds]\n else:\n hard_preds = [1 if p > threshold else 0 for p in preds] # binary prediction\n\n return accuracy_score(targets, hard_preds)","def get_prediction(self, data, class_label):\n\t\taccuracy = 0\n\t\thit=0\n\t\tcount=0\n\t\tfor index, row in test.iterrows():\n\t\t\tcount += 1\n\t\t\ttmp = self.get_classLabel(row.tolist(),row[class_label])\n\t\t\t#print (tmp)\n\t\t\tif tmp:\n\t\t\t\thit+=1\n\t\t#print (\"hit \"+ str(hit) )\n\t\taccuracy = hit/count\n\t\t\n\t\treturn accuracy","def evaluate_classifier(self, clf):\n\n clf = clf.fit(self.training_data_train_x, self.training_data_train_y)\n predicted = clf.predict(self.training_data_opt_x)\n\n correct = 0\n for i in range(len(self.training_data_opt_y)):\n if predicted[i] == self.training_data_opt_y[i]:\n correct += 1\n\n accuracy = correct / len(self.training_data_opt_y)\n\n return clf, accuracy","def accuracy(targets: List[int], preds: Union[List[float], List[List[float]]], \n threshold: float = 0.5) -> float:\n if type(preds[0]) == list: # multiclass\n hard_preds = [p.index(max(p)) for p in preds]\n else:\n hard_preds = [1 if p > threshold else 0 for p in preds] # binary prediction\n\n return accuracy_score(targets, hard_preds)","def evaluate(labels, predictions):\n correct_positive = 0\n correct_negative = 0\n total_positive = 0\n total_negative = 0\n\n for i in range(len(labels)):\n if labels[i] == 1:\n total_positive += 1\n if predictions[i] == 1:\n correct_positive += 1\n else:\n total_negative += 1\n if predictions[i] == 0:\n correct_negative += 1\n\n sensitivity = correct_positive / total_positive\n specificity = correct_negative / total_negative\n\n return sensitivity, specificity","def accuracy(outputs, labels):\n outputs = np.argmax(outputs, axis=1)\n return np.sum(outputs==labels)/float(labels.size)","def accuracy(outputs, labels):\n outputs = np.argmax(outputs, axis=1)\n return np.sum(outputs==labels)/float(labels.size)"],"string":"[\n \"def calc_accuracy(true, predicted):\\n return sum([t==p for t,p in zip(true, predicted)]) / float(len(true))\",\n \"def accuracy(preds, labels):\\n correct = preds == labels\\n return correct.sum().float() / correct.shape[0]\",\n \"def accuracy(predicted, ground_truth):\\n predicted_labels_decoded = np.argmax(predicted, axis=1)\\n ground_truth_labels_decoded = np.argmax(ground_truth, axis=1)\\n correct_rate = [1 if pred == truth else 0 for (pred, truth) in\\n zip(predicted_labels_decoded, ground_truth_labels_decoded)]\\n accuracy = sum(correct_rate) / ground_truth_labels_decoded.size\\n return accuracy * 100\",\n \"def accuracy(actual, predicted):\\n return np.sum(predicted == actual) / actual.shape[0]\",\n \"def accuracy(labels, predictions, n_classes):\\n\\t\\tequality = tf.equal(x = predictions, y = labels) # match the type of labels\\n\\t\\treturn tf.reduce_mean(tf.cast(equality, tf.float32))\",\n \"def accuracy_score(truth, predicted):\\n return len(np.where(truth==predicted)[0]) / len(truth)\",\n \"def accuracy_score(truth, predicted):\\n return len(np.where(truth==predicted)[0]) / len(truth)\",\n \"def accuracy(probabilities: np.ndarray, labels: np.ndarray) -> float:\\n # [batch_size]\\n predictions = probabilities.argmax(axis=1)\\n # [batch_size]\\n labels = labels.argmax(axis=1)\\n return (predictions == labels).astype(int).mean()\",\n \"def accuracy(predictions, test_labels):\\n return f1_score(test_labels, predictions, average='micro') * 100\",\n \"def accuracy(labels, preds):\\n\\tassert labels.shape[0]==preds.shape[0]\\n\\treturn np.sum(preds==labels)/float(labels.shape[0])\",\n \"def accuracy(predictions, labels):\\n return (100.0 * np.sum(np.argmax(predictions, 1) == np.argmax(labels, 1)) / predictions.shape[0])\",\n \"def accuracy(labels, predictions):\\n if len(labels) != len(predictions):\\n return -1\\n\\n correct = 0\\n total = 0\\n\\n for i,v in enumerate(predictions):\\n if labels[i] == str(v):\\n correct += 1\\n total += 1\\n\\n return (float(correct) / float(total)) * 100.0\",\n \"def accuracy(pred, target):\\n N = pred.shape[0]\\n return (pred == target).sum() * 1.0 / N\",\n \"def accuracy_score(y_true, y_predict):\\n assert y_true.shape[0] == y_predict.shape[0], \\\\\\n \\\"The size of y_true must be equal to y_predict\\\"\\n\\n return sum(y_true == y_predict) / len(y_true)\",\n \"def accuracy(y_pred, y_true):\\n # Number of correct predictions\\n correct = (y_pred == y_true).sum()\\n # Predictions accuracy\\n acc = correct / (len(y_pred[0]) * y_pred.shape[0]) * 100\\n # Accuracy of non zero pixels predictions\\n non_zero = (y_true > 0).sum()\\n non_zero_correct = (y_pred[y_true > 0] == y_true[y_true > 0]).sum()\\n if non_zero == 0:\\n if non_zero_correct == 0:\\n non_zero_acc = 100.0\\n else:\\n non_zero_acc = 0.0\\n else:\\n\\n non_zero_acc = non_zero_correct / non_zero * 100\\n return acc, non_zero_acc, non_zero_correct\",\n \"def accuracy_score(y_true, y_pred):\\n accuracy = np.sum(y_true == y_pred, axis=0) / len(y_true)\\n return accuracy\",\n \"def accuracy_score(y_true, y_pred):\\n accuracy = np.sum(y_true == y_pred, axis=0) / len(y_true)\\n return accuracy\",\n \"def get_accuracy(test_sets, predictions, class_index):\\n actual_classes = [test_set[class_index] for test_set in test_sets]\\n\\n num_correct = sum(int(actual == prediction) for actual, prediction in zip(actual_classes, predictions))\\n\\n return float(num_correct) / len(test_sets)\",\n \"def evaluate_prediction(classifier, test_data, labels):\\n \\n predictions = classifier.predict(test_data)\\n \\n return accuracy_score(labels, predictions)\",\n \"def multiclass_accuracy(prediction, ground_truth):\\n correct = sum(a == b for a, b in zip(prediction, ground_truth))\\n\\n accuracy = correct / len(ground_truth)\\n\\n return accuracy\",\n \"def accuracy(predictions, targets):\\n return accuracy\",\n \"def accuracy(pred, labels):\\n pred = torch.sigmoid(pred)\\n predicted = (pred > 0.5).int()\\n correct = (predicted == labels).sum().item()\\n return correct / labels.shape[0]\",\n \"def predictionAccuracy(self, predicted, actual):\\n\\t\\taccuracyCount=0\\n\\n\\t\\t###### your implementation below ######\\n\\t\\tfor x in range(len(predicted)):\\n\\t\\t\\tif (predicted[x] == actual[x]):\\n\\t\\t\\t\\taccuracyCount += 1\\n\\t\\taccuracyCount /= len(predicted)\\n\\t\\treturn accuracyCount;\",\n \"def accuracy ( actuals, predictions ):\\n return np.mean ( actuals == predictions )\\n # End accuracy()\",\n \"def accuracy ( actuals, predictions ):\\n return np.mean ( actuals == predictions )\\n # End accuracy()\",\n \"def accuracy_score(Y_true, Y_predict):\\n \\n true = 0\\n\\n for i in range(len(Y_predict)):\\n if Y_true[i] == Y_predict[i]:\\n true+=1\\n acc = true/float(len(Y_true))* 100.0\\n return acc\",\n \"def accuracy_score(y_true, y_pred):\\n\\ttp, fn, fp, tn = confusion_matrix(y_true, y_pred, table_show=False)\\n\\n\\treturn (tp+tn) / (tp+tn+fn+fp)\",\n \"def accuracy_fn(y_true, y_pred):\\n correct = torch.eq(y_true, y_pred).sum().item()\\n acc = (correct / len(y_pred)) * 100\\n return acc\",\n \"def compute_accuracy(labels=None, predictions=None):\\n labels = np.array(labels, dtype=np.int32)\\n if len(labels.shape) == 2:\\n labels = np.argmax(labels, -1)\\n return np.sum(np.equal(labels, predictions)) / np.size(labels)\",\n \"def accuracy(predictions, labels):\\n predictions = list(predictions)\\n labels = list(labels)\\n count = 0\\n for i in range(len(labels)):\\n if labels[i] == predictions[i]:\\n count += 1\\n\\n return count / len(labels)\",\n \"def accuracy_score(preds, y):\\n accuracy = sum([1 for i in range (len(preds)) if preds[i] == y[i]])*1.0/len(preds) \\n return accuracy\",\n \"def accuracy(classifier_output, true_labels):\\n\\n # TODO: finish this.\\n conf_matrix = confusion_matrix(classifier_output, true_labels)\\n return (conf_matrix[0][0]+conf_matrix[1][1])/(conf_matrix[0][0] + conf_matrix[0][1]\\\\\\n + conf_matrix[1][0] + conf_matrix[1][1])\",\n \"def accuracy(predictions, targets):\\n correct_count = 0\\n for prediction, target in zip(predictions, targets):\\n if prediction == target:\\n correct_count += 1\\n return correct_count / len(predictions)\",\n \"def accuracy(predictions, targets):\\n\\n ########################\\n # PUT YOUR CODE HERE #\\n #######################\\n i1 = np.arange(0, len(targets), 1)\\n i2 = np.argmax(predictions, axis = 1)\\n accuracy = targets[i1, i2].sum()/targets.sum()\\n ########################\\n # END OF YOUR CODE #\\n #######################\\n\\n return accuracy\",\n \"def accuracy(predictions, targets):\\n\\n ########################\\n # PUT YOUR CODE HERE #\\n #######################\\n n_samples = targets.shape[0]\\n _, y_pred = predictions.max(dim=1)\\n accuracy = (y_pred == targets).sum().item() / n_samples\\n ########################\\n # END OF YOUR CODE #\\n #######################\\n\\n return accuracy\",\n \"def accuracy(predictions, targets):\\n\\n ########################\\n # PUT YOUR CODE HERE #\\n #######################\\n correct = 0\\n for i in range(len(targets)):\\n if(predictions[i] == targets[i]):\\n correct += 1\\n accuracy = correct/len(targets)\\n #raise NotImplementedError\\n ########################\\n # END OF YOUR CODE #\\n #######################\\n\\n return accuracy\",\n \"def label_accuracy_score(label_true, label_pred, n_class):\\n hist = _fast_hist(label_true.flatten(), label_pred.flatten(), n_class)\\n acc = np.diag(hist).sum() / hist.sum().astype(np.float64)\\n acc_cls = np.diag(hist) / hist.sum(axis=1).astype(np.float64)\\n acc_cls = np.nanmean(acc_cls)\\n iu = np.diag(hist) / (hist.sum(axis=1) + hist.sum(axis=0) - np.diag(hist)).astype(np.float64)\\n mean_iu = np.nanmean(iu)\\n freq = hist.sum(axis=1) / hist.sum().astype(np.float64)\\n fwavacc = (freq[freq > 0] * iu[freq > 0]).sum()\\n return acc, acc_cls, mean_iu, fwavacc\",\n \"def ranked_accuracy(predictions, labels):\\n rank1 = 0\\n rank5 = 0\\n\\n for (pred, lbl) in zip(predictions, labels):\\n pred = np.argsort(pred)[::-1]\\n\\n if lbl in pred[:5]:\\n rank5+=1\\n\\n if lbl == pred[0]:\\n rank1+=1\\n\\n rank1 /= float(len(labels))\\n rank5 /= float(len(labels))\\n\\n return (rank1, rank5)\",\n \"def accuracy(outputs, labels):\\n predicted = outputs.argmax(dim=1)\\n correct = (predicted == labels).sum().item()\\n return correct / labels.size(0)\",\n \"def accuracy(self, probabilities, labels):\\n # TODO: calculate the batch accuracy\\n count = 0\\n for x in range(len(probabilities)):\\n if np.argmax(labels[x]) == np.argmax(probabilities[x]):\\n count += 1\\n return count/len(probabilities)\",\n \"def accuracy(cls, test_labels):\\n N = len(test_labels)\\n\\n # Calculate total correct as precentage\\n total_correct = 100*(N - np.count_nonzero(cls - test_labels))/N\\n\\n # Calculate precentag correct for each class\\n lab = np.unique(test_labels)\\n cls_correct = {}\\n for label in lab:\\n idx = np.where(test_labels == label)[0]\\n N_cls = len(idx)\\n cls_correct[label] = 100*(N_cls - np.count_nonzero(label -\\n cls[idx]))/N_cls\\n\\n print(\\\"Accuracy for:\\\")\\n print(\\\"All classes is %.2f%%\\\" % total_correct)\\n for label in lab:\\n print(\\\"Class %d is %.2f%%\\\" % (label, cls_correct[label]))\\n return(total_correct, cls_correct)\",\n \"def accuracy(self,predicted, original):\\n TP=0\\n TN=0\\n FP=0\\n FN=0\\n for i in range(len(predicted)):\\n if(predicted[i]==1 and original[i]==1):\\n TP+=1\\n elif(predicted[i]==0 and original[i]==1):\\n FN+=1\\n elif(predicted[i]==1 and original[i]==0):\\n FP+=1\\n elif(predicted[i]==0 and original[i]==0):\\n TN+=1\\n\\n acc = (TP+TN)/(TP+TN+FP+FN)\\n return acc\",\n \"def accuracy(predictions, targets):\\n\\n compare = predictions == targets\\n # compare = (predictions.argmax(dim=1)) == (targets)\\n # compare = (predictions.argmax(dim=1)) == (targets.argmax(dim=1))\\n # summed = compare.sum().item()\\n summed = compare.sum()\\n # print(summed, compare.size())\\n # print(compare.size()[0])\\n return summed/compare.size\",\n \"def get_accuracy(actual, predicted):\\n predicted_correct = 0\\n # for each index in the actual result\\n for i in range(len(actual)):\\n # if actual is the same as predicted\\n if actual[i] == predicted[i]:\\n predicted_correct+=1\\n return predicted_correct/len(actual)\",\n \"def accuaracy_score(y_true, y_pred):\\n\\taccuracy = np.sum(y_true == y_pred, axis=0) / len(y_true)\\n\\treturn accuracy\",\n \"def accuracy(y_true, y_pred):\\n assert y_true.shape == y_pred.shape\\n return (y_true == y_pred).mean()\",\n \"def percent_accuracy(self, true_values, predicted_values):\\n\\n correct = 0\\n size = len(true_values)\\n for i in range(len(true_values)):\\n true_labels = true_values[i]\\n predicted_labels = predicted_values[i]\\n predicted_index = np.argmax(predicted_labels)\\n\\n if true_labels[predicted_index] == 1:\\n correct += 1\",\n \"def accuracy(y_true, y_pred):\\r\\n\\r\\n cm = confusion_matrix(y_true=y_true, y_pred=y_pred)\\r\\n cost_m = np.max(cm) - cm\\r\\n indices = linear_sum_assignment(cost_m)\\r\\n indices = np.asarray(indices)\\r\\n indexes = np.transpose(indices)\\r\\n total = 0\\r\\n for row, column in indexes:\\r\\n value = cm[row][column]\\r\\n total += value\\r\\n return total * 1. / np.sum(cm)\",\n \"def accuracy(targets: List[List[float]], predict: List[List[float]]):\\r\\n correct = 0\\r\\n for i in range(len(targets)):\\r\\n if predict[i] == targets[i]:\\r\\n correct += 1\\r\\n return correct / len(targets) * 100\",\n \"def get_accuracy(self, gold, predicted):\\n # Exercise 3: calculate accuracy\\n i = 0\\n j = 0\\n for labels in gold:\\n if labels == predicted[i]:\\n j +=1\\n i +=1\\n return j / i * 100\",\n \"def accuracy(gt, pred):\\n \\n return np.mean(gt == pred)\",\n \"def accuracy(links_true, links_pred=None, total=None):\\n\\n if isinstance(total, pandas.MultiIndex):\\n total = len(total)\\n\\n if _isconfusionmatrix(links_true):\\n confusion_matrix = links_true\\n\\n v = (confusion_matrix[0, 0] + confusion_matrix[1, 1]) / numpy.sum(\\n confusion_matrix\\n )\\n else:\\n tp = true_positives(links_true, links_pred)\\n tn = true_negatives(links_true, links_pred, total)\\n\\n v = (tp + tn) / total\\n\\n return float(v)\",\n \"def accuracy_score(predictions, targets):\\n if len(predictions.shape) > 1:\\n predictions = np.argmax(predictions, axis=1)\\n if len(targets.shape) > 1:\\n targets = np.argmax(targets, axis=1)\\n\\n return np.sum(predictions == targets) * 1 / predictions.shape[0]\",\n \"def discriminator_accuracy(predicted, y_true):\\n total = y_true.size(0)\\n correct = (torch.abs(predicted - y_true) <= 0.5).sum().item()\\n accuracy = 100.0 * correct / total\\n return accuracy\",\n \"def accuracy_score(y_true, y_pred_proba, threshold=0.5):\\n\\n y_pred = predict_with_threshold(y_pred_proba, threshold)\\n\\n acc = pd.concat([y_true.rename('y_true'), y_pred], axis=1)\\n tp = acc.apply(\\n lambda row: 1 if (row.y_true == row.y_pred) else 0,\\n axis=1\\n ).sum()\\n return tp/acc['y_pred'].count()\",\n \"def evaluate(true_labels, predicted_labels):\\n accuracy = np.round(metrics.accuracy_score(true_labels, predicted_labels), \\n 2)\\n precision = np.round(metrics.precision_score(true_labels, predicted_labels, \\n average='weighted'), 2)\\n recall = np.round(metrics.recall_score(true_labels, predicted_labels,\\n average='weighted'), 2)\\n f1 = np.round(metrics.f1_score(true_labels, predicted_labels, \\n average='weighted'), 2)\\n \\n return accuracy, precision, recall, f1\",\n \"def get_accuracy(pred, test_label, regression= \\\"logistic\\\"):\\n if regression == \\\"multiclass\\\":\\n pred_max = np.argmax(pred, axis=1)\\n gt_max = np.argmax(test_label, axis=1)\\n acc = np.sum(pred_max == gt_max)*100.0/pred.shape[0]\\n elif regression == \\\"logistic\\\" or regression == \\\"probit\\\":\\n if pred.ndim == 2:\\n pred = pred[:,0]\\n pred[pred >= 0.5] = 1.0\\n pred[pred < 0.5] = 0.0\\n acc = np.sum(pred == test_label)*100.0/pred.shape[0]\\n\\n return acc\",\n \"def accuracy_v2(y_true, y_pred):\\n tp = true_positive(y_true, y_pred)\\n fp = false_positive(y_true, y_pred)\\n fn = false_negative(y_true, y_pred)\\n tn = true_negative(y_true, y_pred)\\n accuracy_score = (tp + tn) / (tp + tn + fp + fn)\\n return accuracy_score\",\n \"def score_prediction(y_true, y_pred):\\n return [round(metrics.accuracy_score(y_true, y_pred)*100, 2),\\n round(metrics.precision_score(y_true, y_pred)*100, 2),\\n round(metrics.recall_score(y_true, y_pred)*100, 2),\\n round(metrics.f1_score(y_true, y_pred)*100, 2)]\",\n \"def accuracy(y_test, y_pred):\\n\\treturn accuracy_score(y_test, y_pred)\",\n \"def get_accuracy(self) -> float:\\n self.network.load_data()\\n self.network.train()\\n\\n n = len(self.network.y_test)\\n correct = 0\\n for i in range(n):\\n # Predict by running forward pass through the neural network\\n pred = self.network.predict(self.network.x_test[i])\\n # Sanity check of the prediction\\n assert 0 <= pred <= 1, \\\"The prediction needs to be in [0, 1] range.\\\"\\n # Check if right class is predicted\\n correct += self.network.y_test[i] == round(float(pred))\\n return round(correct / n, 3)\",\n \"def accuracy(predicted_logits, reference, argmax=True):\\n if argmax:\\n labels = torch.argmax(predicted_logits, 1)\\n else:\\n labels = predicted_logits\\n correct_predictions = labels.int().eq(reference.int())\\n return correct_predictions.sum().float() / correct_predictions.nelement()\",\n \"def evaluate_accuracy(self, prediction, reality):\\n correct = 0\\n for i in range(len(prediction)):\\n if prediction[i] == reality[i]:\\n correct = correct + 1\\n\\n return correct / len(prediction)\",\n \"def accuracy(self, predictions, truth):\\n return np.mean(np.argmax(predictions, axis=1) == truth) # <COGLINE>\",\n \"def getAccuracy(self):\\n\\t\\tcorrect = (self.testing[self.classLabel]==self.bestLabel).sum()\\n\\t\\tself.accuracy = (correct/float(len(self.testing))) * 100.0\",\n \"def prediction():\\r\\n\\r\\n\\r\\n\\tpredictVal = []\\r\\n\\taccuracy = 0.0\\r\\n\\r\\n\\t# Calculate accuracy for each class in testData\\r\\n\\tfor item in testData:\\r\\n\\t\\tclass0Prediction = posProb / 100\\r\\n\\t\\tclass1Prediction = negProb / 100\\r\\n\\t\\t\\r\\n\\t\\t# Multiply the prior probablities for negative and positive reviews by their feature likelihoods \\r\\n\\t\\tfor word in item[2]:\\r\\n\\t\\t\\tclass0Prediction *= class0Dict[word]\\r\\n\\t\\t\\tclass1Prediction *= class1Dict[word]\\r\\n\\r\\n\\t\\t# Give every item in testData a predicted value\\r\\n\\t\\tif(class0Prediction > class1Prediction):\\r\\n\\t\\t\\tpredictVal.append('0')\\r\\n\\t\\telse:\\r\\n\\t\\t\\tpredictVal.append('1')\\r\\n\\r\\n\\tfor i in range(len(testData)):\\r\\n\\t\\tif(testData[i][1] == predictVal[i]):\\r\\n\\t\\t\\taccuracy += 1\\r\\n\\r\\n\\t\\t\\t\\r\\n\\taccuracy = 100 * (accuracy / len(testData))\\r\\n\\treturn(predictVal, accuracy)\",\n \"def accuracy_per_class(y_pred, y_test, columns_list):\\n accuracy_dict = {}\\n correct_index = 0\\n incorrect_index = 1\\n for row in range(y_pred.shape[0]):\\n curr_correct_index = np.argmax(y_test[row])\\n curr_col_name = columns_list[curr_correct_index]\\n if np.argmax(y_pred[row]) == curr_correct_index:\\n if curr_col_name in accuracy_dict:\\n accuracy_dict[curr_col_name][correct_index] += 1\\n else:\\n accuracy_dict[curr_col_name] = [1, 0]\\n elif np.argmax(y_pred[row]) != curr_correct_index:\\n if curr_col_name in accuracy_dict:\\n accuracy_dict[curr_col_name][incorrect_index] += 1\\n else:\\n accuracy_dict[curr_col_name] = [0, 1]\\n for class_name in accuracy_dict:\\n lst = accuracy_dict[class_name]\\n percentage = lst[correct_index] / (lst[incorrect_index]+lst[correct_index])\\n accuracy_dict[class_name].insert(0, percentage)\\n return accuracy_dict\",\n \"def binary_accuracy(preds, y):\\n #round predictions to the closest integer\\n rounded_preds = torch.round(torch.sigmoid(preds))\\n correct = (rounded_preds == y).float() #convert into float for division\\n acc = correct.sum() / len(correct)\\n return acc\",\n \"def accuracy_score(y_test, predictions):\\n # my implementation\\n # correct_prediction = y_test == predictions\\n # accuracy_score = (predictions[correct_prediction].shape[0] /\\n # (predictions.shape[0] * 1.0))\\n\\n # better implementation\\n if len(y_test) != len(predictions):\\n raise ValueError('y_test and predictions are in different shape')\\n\\n return (y_test == predictions).mean()\",\n \"def multiclass_accuracy(pr, gt):\\n correct_prediction = tf.equal(tf.round(tf.nn.sigmoid(pr)), tf.round(gt))\\n accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))\\n return accuracy\",\n \"def get_accuracy_score(labels_true: np.ndarray, labels_pred: np.ndarray) -> float:\\n check_vector_format(labels_true, labels_pred)\\n mask = (labels_true >= 0) & (labels_pred >= 0)\\n if np.sum(mask):\\n return np.mean(labels_true[mask] == labels_pred[mask])\\n else:\\n raise ValueError('No sample with both true non-negative label and predicted non-negative label.')\",\n \"def accuracy(self):\\n total_predictions = self.tp + self.fp + self.tn + self.fn;\\n return float(self.tp + self.tn) / total_predictions if total_predictions != 0 else 1\",\n \"def binary_accuracy(preds, y):\\n\\n # round predictions to the closest integer\\n rounded_preds = torch.round(torch.sigmoid(preds))\\n correct = (rounded_preds == y).float() # convert into float for division\\n acc = correct.sum() / len(correct)\\n return acc\",\n \"def binary_accuracy(preds, y):\\n\\n # round predictions to the closest integer\\n rounded_preds = torch.round(torch.sigmoid(preds))\\n correct = (rounded_preds == y).float() # convert into float for division\\n acc = correct.sum() / len(correct)\\n return acc\",\n \"def overall_accuracy(y_true, y_pred):\\n pred_flat, true_flat = y_pred.flatten(), y_true.flatten()\\n intersection = list(pred_flat == true_flat).count(True)\\n sum_ = len(true_flat)\\n accuracy = round(intersection/sum_, 4)\\n return accuracy\",\n \"def accuracy_measures(predictions, trues):\\n\\n tn, fp, fn, tp = confusion_matrix(trues, predictions).ravel()\\n print \\\"\\\\t(tn, fp, fn, tp) =\\\", (tn, fp, fn, tp)\\n\\n # how often is classifier correct?\\n print \\\"\\\\tAccuracy = {:.2%}\\\".format(float(tp + tn) / len(trues))\\n\\n # how often is it wrong?\\n print \\\"\\\\tMisclassification Rate = {:.2%}\\\".format(float(fp + fn) / len(trues))\\n\\n # when actually yes, how often does it predict yes?\\n print \\\"\\\\tTrue Positive Rate = {:.2%}\\\".format(float(tp) / trues.count(True))\\n\\n # when actually no, how often does it predict yes?\\n print \\\"\\\\tFalse Positive Rate = {:.2%}\\\".format(float(fp) / trues.count(False))\\n\\n # when actually no, how often does it predict no?\\n print \\\"\\\\tSpecificity = {:.2%}\\\".format(float(tn) / trues.count(False))\\n\\n # when it predicts yes, how often is it correct?\\n print \\\"\\\\tPrecision = {:.2%}\\\".format(float(tp) / predictions.count(True))\\n\\n # how often does yes condition occur in our sample?\\n print \\\"\\\\tPrevalence = {:.2%}\\\\n\\\".format(float(trues.count(True)) / len(trues))\\n\\n # return accuracy, precision, and recall score\\n return accuracy_score(trues, predictions), precision_score(trues, predictions, average='binary'), recall_score(\\n trues, predictions, average='binary')\",\n \"def binary_accuracy(preds, y):\\n\\n #round predictions to the closest integer\\n rounded_preds = torch.round(torch.sigmoid(preds))\\n correct = (rounded_preds == y).float() #convert into float for division\\n acc = correct.sum() / len(correct)\\n return acc\",\n \"def categorical_accuracy(preds, y):\\n top_pred = preds.argmax(1, keepdim = True)\\n correct = top_pred.eq(y.view_as(top_pred)).sum()\\n acc = correct.float() / y.shape[0]\\n return acc\",\n \"def binary_classification_metrics(prediction, ground_truth):\\n precision = 0\\n recall = 0\\n accuracy = 0\\n f1 = 0\\n\\n correct = sum(a == b for a, b in zip(prediction, ground_truth))\\n\\n true_pos = 0\\n false_pos = 0\\n false_neg = 0\\n\\n for i in range(len(prediction)):\\n if prediction[i]:\\n true_pos += (prediction[i] == ground_truth[i])\\n false_pos += (prediction[i] != ground_truth[i])\\n else:\\n false_neg += (prediction[i] != ground_truth[i])\\n\\n accuracy = correct / len(ground_truth)\\n\\n if true_pos + false_pos == 0:\\n precision = 0\\n else:\\n precision = true_pos / (true_pos + false_pos)\\n if true_pos + false_neg == 0:\\n recall = 0\\n else:\\n recall = true_pos / (true_pos + false_neg)\\n if precision + recall == 0:\\n f1 = 0\\n else:\\n f1 = 2 * (precision * recall) / (precision + recall)\\n\\n return precision, recall, f1, accuracy\",\n \"def compute_accuracy(self):\\n if not self.is_training:\\n logits = self.test_logits\\n labels = self.data.test_labels\\n else:\\n logits = self.train_logits\\n labels = self.data.labels\\n\\n predictions = tf.cast(tf.argmax(logits, 1), tf.int32)\\n correct = tf.equal(labels, predictions)\\n return tf.reduce_mean(tf.cast(correct, tf.float32))\",\n \"def binary_accuracy(predictions, truth):\\n\\tcorrect = 0.\\n\\tfor i in range(len(predictions)):\\n\\t\\tif predictions[i] >= 0.5 and truth[i] == 1:\\n\\t\\t\\tcorrect += 1\\n\\t\\telif predictions[i] < 0.5 and truth[i] == 0:\\n\\t\\t\\tcorrect += 1\\n\\tacc = correct/len(predictions)\\n\\treturn acc\",\n \"def binary_accuracy(preds, y):\\n\\n # round predictions to the closest integer\\n rounded_predictions = torch.round(torch.sigmoid(preds))\\n correct = (rounded_predictions == y).float()\\n acc = correct.sum() / len(correct)\\n\\n return acc\",\n \"def binary_accuracy(preds, y):\\n\\n #round predictions to the closest integer\\n rounded_preds = torch.round(torch.sigmoid(preds))\\n correct = (rounded_preds == y).float() #convert into float for division \\n acc = correct.sum() / len(correct)\\n return acc\",\n \"def compute_accuracy(Y_test, Y_pred):\\n number_correct_prediction = 0\\n for i in range(len(Y_pred)): # They have the same length\\n id_pred = np.argmax(Y_pred[i]) # Take the argmax of the prediction\\n id_test = np.where(Y_test[i] == 1.)[0][0] # Take the real position of the POS tag\\n if id_test == id_pred:\\n number_correct_prediction += 1\\n\\n percentage_correct = number_correct_prediction / len(Y_pred)\\n\\n return percentage_correct\",\n \"def evaluate(labels, predictions):\\n\\n truePositiveCounter = 0\\n trueNegativeCounter = 0\\n truePositiveCorrect = 0\\n trueNegativeCorrect = 0\\n \\n sensitivity = 0\\n specificity = 0\\n\\n for i in range(len(labels)):\\n if labels[i] == 1:\\n truePositiveCounter += 1\\n if(labels[i] == predictions[i]):\\n truePositiveCorrect += 1\\n elif labels[i] == 0:\\n trueNegativeCounter += 1\\n if(labels[i] == predictions[i]):\\n trueNegativeCorrect += 1\\n\\n sensitivity = truePositiveCorrect / truePositiveCounter\\n specificity = trueNegativeCorrect / trueNegativeCounter\\n\\n return sensitivity, specificity\",\n \"def accuracy(x, y, w):\\n p = prob(x, w)\\n\\n # prediction is class with highest probability\\n y_pred = tf.cast(tf.argmax(p, axis=1), tf.float32)\\n y = tf.squeeze(y)\\n\\n # compute accuracy = TP / (TP + FP)\\n accuracy_ = tf.reduce_mean(tf.cast(tf.equal(y, y_pred), tf.float32))\\n return accuracy_\",\n \"def binary_accuracy(preds, y, pr=False):\\n\\n #round predictions to the closest integer\\n rounded_preds = torch.round(F.sigmoid(preds))\\n ons = torch.where(y == 1)\\n ons_correct = (rounded_preds[ons]==y[ons]).float()\\n ons_acc = ons_correct.sum() / ons[0].shape[0]\\n correct = (rounded_preds == y).float() #convert into float for division\\n all_corrects = [1 if torch.all(rounded_preds[:,i] ==y[:,i]) else 0 for i in range(y.size(1))]\\n all_correct_acc = sum(all_corrects) / len(all_corrects)\\n acc = correct.sum() / (correct.shape[0]*correct.shape[1])\\n # if (pr):\\n # print(rounded_preds)\\n # print(y)\\n return acc, ons_acc, all_correct_acc\",\n \"def accuracy_rate(predictions: torch.Tensor, labels: torch.Tensor) -> float:\\n assert len(predictions) == len(labels), \\\"Predictions and labels must have the same length.\\\"\\n assert len(labels.shape) == 1, \\\"Labels must be a column vector.\\\"\\n\\n return ( # type: ignore\\n float((predictions.argmax(1) == labels.to(torch.long)).sum()) / predictions.shape[0]\\n )\",\n \"def get_accuracy(predictions, targets):\\n accuracy = (predictions.argmax(1).cpu().numpy() ==\\n targets.cpu().numpy()).sum()/(predictions.shape[0])\\n return accuracy\",\n \"def compute_accuracy(self, inputs, true_values):\\n predicted_values = self.predict(inputs)\\n number_correct = np.sum(predicted_values == true_values)\\n accuracy = number_correct / len(predicted_values)\\n\\n return accuracy\",\n \"def compute_accuracy(self):\\n self.test_predictions = tf.cast(tf.argmax(self.test_logits, 1), tf.int32)\\n correct = tf.equal(self.data.test_labels, self.test_predictions)\\n return tf.reduce_mean(tf.cast(correct, tf.float32))\",\n \"def evaluate(labels, predictions):\\n\\n true_positives = 0\\n label_positives = 0\\n\\n true_negatives = 0\\n label_negatives = 0\\n\\n for i in range(len(predictions)):\\n if labels[i] == predictions[i] == 1:\\n true_positives += 1\\n if labels[i] == 1:\\n label_positives += 1\\n\\n if labels[i] == predictions[i] == 0:\\n true_negatives += 1\\n if labels[i] == 0:\\n label_negatives += 1\\n\\n return true_positives / label_positives, true_negatives / label_negatives\\n\\n # raise NotImplementedError\",\n \"def accuracy(outputs, labels):\\n outputs = np.argmax(outputs, axis=1)\\n return np.sum(outputs == labels)/float(labels.size)\",\n \"def accuracy(self):\\n # Initialize key variables\\n correct = {}\\n prediction = 0\\n cls_count = {}\\n accuracy = {}\\n\\n # Analyze all the data\\n for cls in self.pca_object.classes():\\n # Get list of x values to test\\n vectors = self.pca_object.xvalues(cls)\\n\\n # Process each vector\\n for vector in vectors:\\n # Get the prediction\\n prediction = self.classifier(vector)\\n\\n # Only count definitive predictions\\n if prediction is not None:\\n # Count the number of correct predictions\\n if prediction == cls:\\n if cls in correct:\\n correct[cls] += 1\\n else:\\n correct[cls] = 1\\n\\n # Increment the count\\n if cls in cls_count:\\n cls_count[cls] += 1\\n else:\\n cls_count[cls] = 1\\n\\n # Calculate per class accuracy\\n correct[None] = 0\\n cls_count[None] = 0\\n for cls in cls_count.keys():\\n if cls_count[cls] != 0:\\n accuracy[cls] = correct[cls] / cls_count[cls]\\n\\n # Keep a tally for all successes\\n correct[None] = correct[None] + correct[cls]\\n cls_count[None] = cls_count[None] + cls_count[cls]\\n\\n # Calulate overall accuracy\\n accuracy[None] = correct[None] / cls_count[None]\\n\\n # Return\\n return accuracy\",\n \"def accuracy(targets: List[int],\\n preds: Union[List[float], List[List[float]]],\\n threshold: float = 0.5) -> float:\\n if type(preds[0]) == list: # multiclass\\n hard_preds = [p.index(max(p)) for p in preds]\\n else:\\n hard_preds = [1 if p > threshold else 0 for p in preds] # binary prediction\\n\\n return accuracy_score(targets, hard_preds)\",\n \"def get_prediction(self, data, class_label):\\n\\t\\taccuracy = 0\\n\\t\\thit=0\\n\\t\\tcount=0\\n\\t\\tfor index, row in test.iterrows():\\n\\t\\t\\tcount += 1\\n\\t\\t\\ttmp = self.get_classLabel(row.tolist(),row[class_label])\\n\\t\\t\\t#print (tmp)\\n\\t\\t\\tif tmp:\\n\\t\\t\\t\\thit+=1\\n\\t\\t#print (\\\"hit \\\"+ str(hit) )\\n\\t\\taccuracy = hit/count\\n\\t\\t\\n\\t\\treturn accuracy\",\n \"def evaluate_classifier(self, clf):\\n\\n clf = clf.fit(self.training_data_train_x, self.training_data_train_y)\\n predicted = clf.predict(self.training_data_opt_x)\\n\\n correct = 0\\n for i in range(len(self.training_data_opt_y)):\\n if predicted[i] == self.training_data_opt_y[i]:\\n correct += 1\\n\\n accuracy = correct / len(self.training_data_opt_y)\\n\\n return clf, accuracy\",\n \"def accuracy(targets: List[int], preds: Union[List[float], List[List[float]]], \\n threshold: float = 0.5) -> float:\\n if type(preds[0]) == list: # multiclass\\n hard_preds = [p.index(max(p)) for p in preds]\\n else:\\n hard_preds = [1 if p > threshold else 0 for p in preds] # binary prediction\\n\\n return accuracy_score(targets, hard_preds)\",\n \"def evaluate(labels, predictions):\\n correct_positive = 0\\n correct_negative = 0\\n total_positive = 0\\n total_negative = 0\\n\\n for i in range(len(labels)):\\n if labels[i] == 1:\\n total_positive += 1\\n if predictions[i] == 1:\\n correct_positive += 1\\n else:\\n total_negative += 1\\n if predictions[i] == 0:\\n correct_negative += 1\\n\\n sensitivity = correct_positive / total_positive\\n specificity = correct_negative / total_negative\\n\\n return sensitivity, specificity\",\n \"def accuracy(outputs, labels):\\n outputs = np.argmax(outputs, axis=1)\\n return np.sum(outputs==labels)/float(labels.size)\",\n \"def accuracy(outputs, labels):\\n outputs = np.argmax(outputs, axis=1)\\n return np.sum(outputs==labels)/float(labels.size)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.7954947","0.78648776","0.7796339","0.7776252","0.77718586","0.7771421","0.7771421","0.775524","0.7739714","0.7696608","0.7682014","0.76794153","0.7577913","0.7562003","0.7551231","0.75275767","0.75275767","0.75218564","0.7516644","0.75076306","0.75057065","0.749967","0.7491541","0.7470119","0.7470119","0.74604243","0.74334466","0.7419433","0.74190414","0.74121606","0.7403623","0.7397618","0.73754907","0.7369686","0.736601","0.73488903","0.73366994","0.7335223","0.7333718","0.7331009","0.7307585","0.7297981","0.7293531","0.72740424","0.72490925","0.72467107","0.7237453","0.7236414","0.7213656","0.7211237","0.72017515","0.718998","0.7184347","0.71781886","0.7177474","0.7173944","0.715812","0.7152885","0.7135403","0.7123735","0.71217805","0.7103707","0.70989025","0.70808333","0.7080139","0.7073775","0.70732045","0.70644844","0.70618933","0.70574754","0.7056848","0.7051879","0.7045367","0.7045367","0.70363885","0.7035445","0.70321757","0.7025677","0.70224506","0.7017393","0.7015813","0.70023775","0.70010316","0.6997501","0.6996737","0.69737136","0.697207","0.6969479","0.6966328","0.6964761","0.6960804","0.695892","0.69358987","0.6935407","0.69306964","0.6928749","0.6928282","0.6922567","0.6921953","0.6918243","0.6918243"],"string":"[\n \"0.7954947\",\n \"0.78648776\",\n \"0.7796339\",\n \"0.7776252\",\n \"0.77718586\",\n \"0.7771421\",\n \"0.7771421\",\n \"0.775524\",\n \"0.7739714\",\n \"0.7696608\",\n \"0.7682014\",\n \"0.76794153\",\n \"0.7577913\",\n \"0.7562003\",\n \"0.7551231\",\n \"0.75275767\",\n \"0.75275767\",\n \"0.75218564\",\n \"0.7516644\",\n \"0.75076306\",\n \"0.75057065\",\n \"0.749967\",\n \"0.7491541\",\n \"0.7470119\",\n \"0.7470119\",\n \"0.74604243\",\n \"0.74334466\",\n \"0.7419433\",\n \"0.74190414\",\n \"0.74121606\",\n \"0.7403623\",\n \"0.7397618\",\n \"0.73754907\",\n \"0.7369686\",\n \"0.736601\",\n \"0.73488903\",\n \"0.73366994\",\n \"0.7335223\",\n \"0.7333718\",\n \"0.7331009\",\n \"0.7307585\",\n \"0.7297981\",\n \"0.7293531\",\n \"0.72740424\",\n \"0.72490925\",\n \"0.72467107\",\n \"0.7237453\",\n \"0.7236414\",\n \"0.7213656\",\n \"0.7211237\",\n \"0.72017515\",\n \"0.718998\",\n \"0.7184347\",\n \"0.71781886\",\n \"0.7177474\",\n \"0.7173944\",\n \"0.715812\",\n \"0.7152885\",\n \"0.7135403\",\n \"0.7123735\",\n \"0.71217805\",\n \"0.7103707\",\n \"0.70989025\",\n \"0.70808333\",\n \"0.7080139\",\n \"0.7073775\",\n \"0.70732045\",\n \"0.70644844\",\n \"0.70618933\",\n \"0.70574754\",\n \"0.7056848\",\n \"0.7051879\",\n \"0.7045367\",\n \"0.7045367\",\n \"0.70363885\",\n \"0.7035445\",\n \"0.70321757\",\n \"0.7025677\",\n \"0.70224506\",\n \"0.7017393\",\n \"0.7015813\",\n \"0.70023775\",\n \"0.70010316\",\n \"0.6997501\",\n \"0.6996737\",\n \"0.69737136\",\n \"0.697207\",\n \"0.6969479\",\n \"0.6966328\",\n \"0.6964761\",\n \"0.6960804\",\n \"0.695892\",\n \"0.69358987\",\n \"0.6935407\",\n \"0.69306964\",\n \"0.6928749\",\n \"0.6928282\",\n \"0.6922567\",\n \"0.6921953\",\n \"0.6918243\",\n \"0.6918243\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":89891,"cells":{"query":{"kind":"string","value":"Builds a tree, starting at root, of matching subsequences between sorted_nodes1 and sorted_nodes2. The subsequences match if the order of the nodes is preserved and they satisfy are_equal_nodes."},"document":{"kind":"string","value":"def fill_tree(root, sorted_nodes1, sorted_nodes2):\n for id1 in range(root.id1+1, len(sorted_nodes1)):\n for id2 in range(root.id2+1, len(sorted_nodes2)):\n if are_equal_nodes(sorted_nodes1[id1], sorted_nodes2[id2]):\n child_node = TreeNode(id1, id2)\n fill_tree(child_node, sorted_nodes1, sorted_nodes2)\n root.add_child(child_node)"},"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 find_longest_matches(sorted_nodes1, sorted_nodes2):\n root = TreeNode(-1,-1)\n fill_tree(root, sorted_nodes1, sorted_nodes2)\n match = find_treepaths(root, [])\n\n # Remove (-1, -1) superroot.\n if isinstance(match[0], list): # More than one match of the same length.\n res = []\n for m in match:\n res.append([node.to_tuple() for node in m[1:]])\n return res\n else:\n return [[node.to_tuple() for node in match[1:]]]","def construct_trees(self, nodes):\n trees = {}\n for root in tqdm.tqdm(nodes):\n # note that nodes is an uniquely ordered set\n # tree = {0: {0 : [nb_1, nb_2, ..., nb_k], nb_1: [0, ...]}, 1 : {1: [nb_1,...], nb_1 : [..]},...}\n trees[root] = {}\n trees[root][root] = [root]\n # print('test...', trees[root][root])\n used_nodes = set()\n # queue has the form as following queue([root] for root in tqdm.tqdm(nodes)\n # with each node, we construct the tree rooted at that node, denoted as queue(['root'])\n queue = collections.deque([root]) # deque([0]) -> deque([0,1])\n while len(queue) > 0:\n cur_node = queue.popleft()\n used_nodes.add(cur_node)\n for sub_node in self.graph[cur_node]:\n # sub_node is not ordered\n if sub_node not in used_nodes:\n trees[root][cur_node].append(sub_node)\n trees[root][sub_node] = [cur_node]\n queue.append(sub_node)\n used_nodes.add(sub_node)\n return trees","def test_compare_old_to_new_method_to_create_trees(self):\n nodes = util.generate_sequence_of_points(2, 2)\n tree1 = kdtree.createNewTree(nodes)\n kdtree.visualize(tree1)\n \n sel_axis = (lambda axis: axis)\n tree2 = kdtree.createNewTree([[0.5, 0.5]],axis = 0, sel_axis= sel_axis)\n tree2.split2([0.25, 0.5], axis = 1)\n tree2.split2([0.75, 0.5], axis = 1)\n \n #left\n tree2.split2([0.25, 0.25], axis = 0, sel_axis = sel_axis)\n tree2.split2([0.25, 0.75], axis = 0, sel_axis = sel_axis)\n \n #right\n tree2.split2([0.75, 0.25], axis = 0, sel_axis = sel_axis)\n tree2.split2([0.75, 0.75], axis = 0, sel_axis = sel_axis)\n \n kdtree.visualize(tree2)\n \n for n in zip(kdtree.level_order(tree1), kdtree.level_order(tree2)):\n self.assertEqual(n[0].data, n[1].data, \"elements not equal\")\n \n if n[0].data is not None and n[1].data is not None:\n self.assertEqual(n[0].axis, n[1].axis, \"elements not equal\")","def join_nodes_in_both_trees(tree1, nodeAinT1, cladeA,\n tree2, nodeBinT2, cladeB, test=False):\n cladeA = set(cladeA)\n cladeB = set(cladeB)\n leaves1 = get_leaf_set(tree1)\n leaves2 = get_leaf_set(tree2)\n\n cladeAisT1 = leaves1 == cladeA\n cladeBisT2 = leaves2 == cladeB\n\n # Handle adding all of tree1 into tree 2 and vice versa!!\n if cladeAisT1 and cladeBisT2:\n # Done\n print(\"Nodes are tree1 and tree2...\")\n if test:\n return [None, None]\n root = dendropy.Node()\n root.add_child(nodeAinT1)\n root.add_child(nodeBinT2)\n tree1 = dendropy.Tree(seed_node=root)\n tree1.is_rooted = True\n tree2 = None\n elif cladeAisT1:\n # Add all of tree 1 into tree 2\n print(\"Add all of tree 1 into tree 2\")\n if test:\n return [None, None]\n [tree2, nodeBinT2] = extract_nodes_from_split(tree2, nodeBinT2,\n cladeB)\n root = dendropy.Node()\n root.add_child(nodeAinT1)\n root.add_child(tree2.seed_node)\n tree1 = dendropy.Tree(seed_node=root)\n tree1.is_rooted = True\n tree2 = None\n elif cladeBisT2:\n # Add all of tree 2 into tree 1\n print(\"Add all of tree 2 into tree 1\")\n if test:\n return [None, None]\n [tree1, nodeAinT1] = extract_nodes_from_split(tree1, nodeAinT1,\n cladeA)\n root = dendropy.Node()\n root.add_child(tree1.seed_node)\n root.add_child(nodeBinT2)\n tree1 = dendropy.Tree(seed_node=root)\n tree1.is_rooted = True\n tree2 = None\n else:\n # Make the join!\n print(\"Making join...\")\n [tree1, nodeAinT1] = extract_nodes_from_split(tree1, nodeAinT1,\n cladeA)\n [tree2, nodeBinT2] = extract_nodes_from_split(tree2, nodeBinT2,\n cladeB)\n\n root1 = dendropy.Node()\n root1.add_child(tree1.seed_node)\n root1.add_child(deepcopy(nodeBinT2)) # TODO: Remove deep copies!\n tree1 = dendropy.Tree(seed_node=root1)\n tree1.is_rooted = True\n\n root2 = dendropy.Node()\n root2.add_child(tree2.seed_node)\n root2.add_child(deepcopy(nodeAinT1)) # TODO: Remove deep copies!\n tree2 = dendropy.Tree(seed_node=root2)\n tree2.is_rooted = True\n\n return [tree1, tree2]","def join_nodes_in_one_tree(tree1, nodeAinT1, cladeA, tree2, nodeBinT2,\n cladeB):\n [tree1, nodeAinT1] = extract_nodes_from_split(tree1, nodeAinT1, cladeA)\n [tree2, nodeBinT2] = extract_nodes_from_split(tree2, nodeBinT2, cladeB)\n\n root = dendropy.Node()\n root.add_child(deepcopy(nodeAinT1)) # TODO: Remove deep copies!\n root.add_child(tree2.seed_node)\n tree2 = dendropy.Tree(seed_node=root)\n tree2.is_rooted = True\n\n return [tree1, tree2]","def compare_nodes(G,all_match_pairs,match_pair,traversed,node1,node2, ports_weight):\n logger.debug(f\"comparing {node1},{node2}, traversed {traversed}\")\n nbrs1 = sorted(set(G.neighbors(node1)) - set(traversed))\n #remove dummies\n nbrs1 = sorted(set([nbr for nbr in nbrs1 if G.get_edge_data(node1, nbr)['weight'] !=7]))\n nbrs2 = sorted(set(G.neighbors(node2)) - set(traversed))\n #remove dummies\n nbrs2 = sorted(set([nbr for nbr in nbrs2 if G.get_edge_data(node2, nbr)['weight'] !=7]))\n logger.debug(f\"node1:{node1},property: {G.nodes[node1]},neigbors1: {nbrs1}\")\n logger.debug(f\"node2:{node2},property: {G.nodes[node2]},neigbors2: {nbrs2}\")\n if not nbrs1 or not nbrs2:\n if compare_two_nodes(G, node1, node2, ports_weight):\n match_pair[node1] = node2\n logger.debug(f\"no new neihbours, returning recursion {match_pair}\")\n return\n elif len(nbrs1)> 10:\n if \"start_point\" in match_pair.keys():\n match_pair[\"start_point\"]+=[node1,node2]\n else:\n match_pair[\"start_point\"]=[node1,node2]\n logger.debug(f\"skipping high fanout nets due to large computation, {node1} {nbrs1}\")\n traversed.append(node1)\n return\n elif len(nbrs2)> 10:\n if \"start_point\" in match_pair.keys():\n match_pair[\"start_point\"]+=[node1,node2]\n else:\n match_pair[\"start_point\"]=[node1,node2]\n traversed.append(node2)\n logger.debug(f\"skipping high fanout nets due to large computation, {node2} {nbrs2}\")\n return\n\n if node1 == node2:\n if node1 in match_pair.keys() or node1 in match_pair.values():\n logger.debug(\"avoid existing pair wise symmetry\")\n return\n logger.debug(f\"single node {node1}, nbrs {nbrs1}, nbr_weight {[G.get_edge_data(node1,nbr) for nbr in nbrs1]}\")\n SD_nbrs= [nbr for nbr in nbrs1 if G.get_edge_data(node1, nbr)['weight'] !=2]\n ## TBD: filter based on primitive constraints\n ## Right now will try to figure out S/D paths\n if len(SD_nbrs) ==0:\n logger.debug(f\"No SD paths found to traverse\")\n match_pair[node1]=node1\n elif len(SD_nbrs) ==1:\n logger.debug(f\"traversing single S/D path {SD_nbrs}\")\n match_pair[node1]=node1\n traversed.append(node1)\n compare_nodes(G,all_match_pairs,match_pair,traversed,SD_nbrs[0],SD_nbrs[0],ports_weight)\n else:\n logger.debug(f\" multiple nodes diverging {SD_nbrs}\")\n logger.debug(f\"nbr weights: {SD_nbrs} {[G.get_edge_data(node1, nbr)['weight'] for nbr in SD_nbrs ]}\")\n match_pair[node1]=node1\n traversed.append(node1)\n new_sp=sorted(set(SD_nbrs)-set(traversed))\n all_match_pairs_local={}\n for nbr1,nbr2 in combinations(new_sp, 2):\n logger.debug(f\"recursive pair call from single branch {nbr1} {nbr2}\")\n new_pair={}\n compare_nodes(G,all_match_pairs,new_pair,traversed.copy(),nbr1,nbr2,ports_weight)\n if new_pair:\n #new_pair[nbr1]=nbr2\n all_match_pairs_local[nbr1+'_'+nbr2] = new_pair\n all_match_pairs_local={k: v for k, v in all_match_pairs_local.items() if len(v)>0}\n if len(all_match_pairs_local)==1:\n match_pair.update( all_match_pairs_local[list(all_match_pairs_local.keys())[0]])\n logger.debug(f\"found inline pair: {pprint.pformat(match_pair, indent=4)}\")\n else:\n for nbr1 in new_sp:\n if (nbr1+'_'+nbr1 not in all_match_pairs.keys()):\n logger.debug(f\"recursive single branch call from single branch {nbr1} {nbr1}\")\n new_pair={}\n compare_nodes(G,all_match_pairs,new_pair,traversed.copy(),nbr1,nbr1,ports_weight)\n #filtering multiple axis of symmetries with same block, ideally they should be handled by array generation\n if new_pair:\n all_match_pairs[nbr1+'_'+nbr1] = new_pair\n logger.debug(f\"updating match pairs: {pprint.pformat(all_match_pairs, indent=4)}\")\n\n\n elif nbrs1 == nbrs2:\n logger.debug(f\"traversing converging branch\")\n match_pair[node1]=node2\n traversed+=[node1,node2]\n nbrs1=sorted(set(nbrs1)-set([node1,node2]))\n logger.debug(f\"all non traversed neighbours: {nbrs1}\")\n if len(nbrs1)==1:\n nbr1=nbr2=nbrs1[0]\n logger.debug(f\"keeping single converged branch inline {nbr1} {nbr2}\")\n compare_nodes(G,all_match_pairs,match_pair,traversed.copy(),nbr1,nbr2,ports_weight)\n else:\n for nbr1,nbr2 in combinations_with_replacement(nbrs1,2):\n logger.debug(f\"recursive call from converged branch {nbr1} {nbr2}\")\n if nbr1+'_'+nbr2 not in all_match_pairs.keys():\n new_pair={}\n compare_nodes(G,all_match_pairs,new_pair,traversed.copy(),nbr1,nbr2,ports_weight)\n #filtering multiple axis of symmetries with same block, ideally they should be handled by array generation\n if new_pair:\n all_match_pairs[nbr1+'_'+nbr2] = new_pair\n logger.debug(f\"updating match pairs: {pprint.pformat(all_match_pairs, indent=4)}\")\n\n\n elif compare_two_nodes(G,node1,node2,ports_weight):\n nbrs1 = sorted(set([nbr for nbr in nbrs1 if G.get_edge_data(node1, nbr)['weight'] !=2]))\n nbrs2 = sorted(set([nbr for nbr in nbrs2 if G.get_edge_data(node2, nbr)['weight'] !=2]))\n match_pair[node1]=node2\n traversed+=[node1,node2]\n logger.debug(f\"Traversing parallel branches from {node1},{node2} {nbrs1}, {nbrs2}\")\n nbrs1_wt = [G.get_edge_data(node1, nbr)['weight'] for nbr in nbrs1]\n nbrs2_wt = [G.get_edge_data(node2, nbr)['weight'] for nbr in nbrs2]\n unique_match=find_unique_matching_branches(G,nbrs1,nbrs2,ports_weight)\n if len(nbrs1)==0 or len(nbrs2)==0:\n logger.debug(f\"no new SD neihbours, returning recursion {match_pair}\")\n elif len(nbrs1) ==1 and len(nbrs2)==1:\n logger.debug(f\"traversing binary branch\")\n compare_nodes(G,all_match_pairs,match_pair,traversed,nbrs1.pop(),nbrs2.pop(),ports_weight)\n elif unique_match:\n logger.debug(f'traversing unique matches {unique_match}')\n match_pair[node1]=node2\n traversed+=[node1,node2]\n for nbr1,nbr2 in unique_match.items():\n logger.debug(f\"recursive call from binary {node1}:{node2} to {nbr1}:{nbr2}\")\n compare_nodes(G,all_match_pairs,match_pair,traversed.copy(),nbr1,nbr2,ports_weight)\n elif len(nbrs1_wt)>len(set(nbrs1_wt))>1 and len(nbrs2_wt)>len(set(nbrs2_wt))>1:\n logger.debug(f\"setting new start points {node1} {node2}\")\n match_pair[node1]=node2\n if \"start_point\" in match_pair.keys():\n match_pair[\"start_point\"]+=[node1,node2]\n else:\n match_pair[\"start_point\"]=[node1,node2]\n else:\n match_pair = {}\n logger.debug(f\"end all traversal from binary branch {node1} {node2}\")\n\n else:\n match_pair = {}\n logger.debug(f\"end of recursion branch, matches {match_pair}\")","def graph_generation(nodes: np.ndarray, edges: np.ndarray):\n result_nodes = []\n result_edges = []\n\n last_index = nodes[-1, 0]\n\n done = False\n # print(nodes)\n for p in range(nodes.shape[0]):\n for q in range(nodes.shape[0]):\n if list(nodes[p, 1:-2]) == (list(nodes[q, 1:-2])) and nodes[p, nodes.shape[1] - 2] < \\\n nodes[q, nodes.shape[1] - 2]:\n tmp_node = np.append(nodes[p, 1:], np.append(nodes[q, nodes.shape[1] - 2],\n np.append(nodes[q, nodes.shape[1] - 1],\n np.append(nodes[p, 0],\n nodes[q, 0]))))\n if not done:\n result_nodes = [tmp_node]\n done = True\n else:\n result_nodes = np.concatenate((result_nodes, [tmp_node]))\n\n result_nodes = result_nodes[np.argsort(\n result_nodes[:, [e for e in range(1, result_nodes.shape[1] - 2) if e % 2 != 0]].sum(axis=1)), :]\n\n result_nodes = np.c_[range(last_index + 1, last_index + 1 + result_nodes.shape[0]), result_nodes]\n # print(result_nodes)\n\n done = False\n for e in range(edges.shape[0]):\n for f in range(edges.shape[0]):\n for p in range(result_nodes.shape[0]):\n for q in range(result_nodes.shape[0]):\n if (edges[e, 0] == result_nodes[p, -2] and edges[e, 1] == result_nodes[q, -2] and edges[\n f, 0] == result_nodes[p, -1] and edges[f, 1] == result_nodes[q, -1]) \\\n or (edges[e, 0] == result_nodes[p, -2] and edges[e, 1] == result_nodes[q, -2] and\n result_nodes[p, -1] == result_nodes[q, -1]) \\\n or (edges[e, 0] == result_nodes[p, -1] and edges[e, 1] == result_nodes[q, -1] and\n result_nodes[p, -2] == result_nodes[q, -2]):\n if not done:\n result_edges = [[result_nodes[p, 0], result_nodes[q, 0]]]\n done = True\n else:\n result_edges = np.concatenate(\n (result_edges, [[result_nodes[p, 0], result_nodes[q, 0]]]), axis=0)\n # print(edges)\n\n # print(result_edges)\n unique_result_edges = list(Counter(str(e) for e in result_edges).keys())\n # print(unique_result_edges)\n final_edges = []\n for k in range(len(unique_result_edges)):\n for j in range(result_edges.shape[0]):\n if str(result_edges[j]) == unique_result_edges[k]:\n if k == 0:\n final_edges = result_edges[j]\n break\n else:\n final_edges = np.concatenate((final_edges, result_edges[j]))\n break\n final_edges = np.reshape(final_edges, (int(final_edges.shape[0] / 2), 2))\n # print(final_edges.shape[0])\n done = False\n edge_to_remove = []\n for j in range(final_edges.shape[0]):\n for k in range(j + 1, final_edges.shape[0]):\n if final_edges[j, 1] == final_edges[k, 0]:\n if not done:\n edge_to_remove = [[final_edges[j, 0], final_edges[k, 1]]]\n done = True\n else:\n edge_to_remove = np.concatenate((edge_to_remove, [[final_edges[j, 0], final_edges[k, 1]]]))\n # print(edge_to_remove)\n\n idx_to_remove = []\n done = False\n for j in range(edge_to_remove.shape[0]):\n for k in range(final_edges.shape[0]):\n if list(edge_to_remove[j]) == list(final_edges[k]):\n if not done:\n idx_to_remove = k\n done = True\n else:\n idx_to_remove = np.append(idx_to_remove, k)\n final_edges = np.delete(final_edges, idx_to_remove, axis=0)\n # print(final_edges)\n result_nodes = np.delete(result_nodes, [-1, -2], 1)\n # print(result_nodes)\n return result_nodes, final_edges","def union(node1, node2):\n node1_root = find(node1)\n node2_root = find(node2)\n if node1_root == node2_root:\n return\n if node1_root.rank < node2_root.rank:\n node1_root.parent = node2_root\n elif node2_root.rank > node2_root.rank:\n node2_root.parent = node1_root\n else:\n node2_root.parent = node1_root\n node1_root.rank = node1_root.rank + 1","def compare_balanced_tree(G, node1:str, node2:str, traversed1:list, traversed2:list):\n logger.debug(f\"checking symmtrical connections for nodes: {node1}, {node2}\")\n tree1 = set(get_next_level(G,[node1]))\n tree2 = set(get_next_level(G,[node2]))\n traversed1.append(node1)\n traversed2.append(node2)\n if tree1==tree2:\n return True\n while(len(list(tree1))== len(list(tree2)) > 0):\n logger.debug(f\"tree1 {tree1} tree2 {tree2} traversed1 {traversed1} traversed2 {traversed2}\")\n tree1 = set(tree1) - set(traversed1)\n tree2 = set(tree2) - set(traversed2)\n\n if tree1.intersection(tree2) or len(list(tree1))== len(list(tree2))==0:\n return True\n else:\n traversed1+=list(tree1)\n traversed2+=list(tree2)\n tree1=set(get_next_level(G,tree1))\n tree2=set(get_next_level(G,tree2))\n\n logger.debug(f\"Non symmetrical branches for nets: {node1}, {node2}\")\n return False","def compareTree(t1, t2):\n \n reorderTree(t1)\n reorderTree(t2)\n\n return compareTreeHelper(t1, t2)","def shortest_path(start, end):\n\troot1=node(start)\n\troot2=node(end)\n\tarr1=[[] for wqw in range(8)]\n\tarr2=[[] for qwq in range(8)]\n\tser1=[[] for lp in range(100000)]\n\tser2=[[] for lp in range(100000)]\n\tarr1[0].append(root1)\n\tarr2[0].append(root2)\n\tser1[(hash(start))%100000].append(start)\n\tser2[(hash(end))%100000].append(end)\n\tflag=0\n\tchk=None\n\tfor h in range(0,7):\n\t\tchk=check_match(arr1[h],arr2[h])\n\t\tif not chk is None:\n\t\t\tflag=1\n\t\t\tbreak\n\t\telse:\n\t\t\tfor w in range(len(arr1[h])):\n\t\t\t\tfin=insert_e(arr1[h][w].data,h+1,arr1,ser1)\n\t\t\t\tarr1=fin[0]\n\t\t\t\tser1=fin[1]\n\t\tchk=check_match(arr2[h],arr1[h+1])\n\t\tif not chk is None:\n\t\t\tflag=2\n\t\t\tbreak\n\t\telse:\n\t\t\tfor q in range(len(arr2[h])):\n\t\t\t\tfim=insert_e(arr2[h][w].data,h+1,arr2,ser2)\n\t\t\t\tarr2=fim[0]\n\t\t\t\tser2=fim[1]\n\tif flag==1:\n\t\twhile not chk[0].parent is None:\n\t\t\tres1.append(chk[0].parent.data)\n\t\t\tchk[0]=chk[0].parent\n\t\tres+=res1.reverse()\n\t\tres.append(chk[1])\n\t\twhile not chk[1].parent is None:\n\t\t\tres2.append(chk[1].parent.data)\n\t\t\tchk[1]=chk[1].parent\n\t\treturn res\n\telif flag==2:\n\t\twhile not chk[1].parent is None:\n\t\t\tres1.append(chk[1].parent.data)\n\t\t\tchk[1]=chk[1].parent\n\t\tif not res1 is None:\n\t\t\tres+=res1.reverse()\n\t\tres.append(chk[0])\n\t\twhile not chk[0].parent is None:\n\t\t\tres2.append(chk[0].parent.data)\n\t\t\tchk[0]=chk[0].parent\n\t\treturn res\n\telse:\n\t\tprint \"The given configuration is not solvable/wrong.\"","def add_trees(t1, t2):\n \"*** YOUR CODE HERE ***\"\n # offical solution:\n if not t1:\n return t2\n if not t2:\n return t1\n new_label = label(t1) + label(t2)\n t1_children, t2_children = branches(t1), branches(t2)\n length_t1, length_t2 = len(t1_children), len(t2_children)\n if length_t1 < length_t2:\n t1_children += [None for _ in range(length_t1, length_t2)]\n elif len(t1_children) > len(t2_children):\n t2_children += [None for _ in range(length_t2, length_t1)]\n return tree(new_label, [add_trees(child1, child2) for child1, child2 in zip(t1_children, t2_children)])","def get_matched_nodeids_from_orderids(sorted_small_nodes, sorted_large_nodes, matched_orderids):\n orderid2nodeid_func = lambda order_pair: (sorted_small_nodes[order_pair[0]].nodeid, sorted_large_nodes[order_pair[1]].nodeid)\n return list(map(orderid2nodeid_func, matched_orderids))","def merge_nodes(self, node_ids):\n node_ids = sorted(node_ids)\n\n # Make sure no duplicate node_ids.\n for i in range(len(node_ids) - 1):\n assert node_ids[i] != node_ids[i + 1], \"Duplicate node IDs.\"\n\n # Make sure nodes are the same type.\n for i in range(1, len(node_ids)):\n n1 = self.nodes[node_ids[0]]\n n2 = self.nodes[node_ids[i]]\n assert n1.__class__ == n2.__class__, \"%s %s\" % (\n n1.__class__, n2.__class__)\n\n # Keep the first node, and delete the rest.\n\n # Make transitions to any node_ids point to the first one.\n node_id = node_ids[0]\n prev_ids = []\n for nid in node_ids[1:]:\n x = _get_parents_of(self, nid)\n prev_ids.extend(x)\n transitions = self.transitions.copy()\n for prev_id in prev_ids:\n x = transitions[prev_id]\n if node_id not in x:\n x = x + [node_id]\n transitions[prev_id] = x\n\n # Make the first node point to all the next_nodes of the other\n # node_ids.\n nid0 = node_ids[0]\n for nidi in node_ids[1:]:\n x = transitions.get(nid0, []) + transitions.get(nidi, [])\n x = sorted({}.fromkeys(x))\n transitions[nid0] = x\n\n x = Network(self.nodes, transitions)\n x = x.delete_nodes(node_ids[1:])\n return x","def question4(T,r,n1,n2):\n\n\tif(len(T)<=1):\t\t\t\t\t\t\t\t# Edge case : If the Tree only consists of a root and no children\n\t\treturn -1\n\n\tif(n1==None or n2==None):\t\t\t\t\t# Edge case : If n1 and n2 are not actually numbers\n\t\treturn -1\n\n\tlen_T = len(T)\n\tif(not n1 < len_T or not n2 < len_T):\t\t# Edge case : If the nodes gives in parameters do not actually exist in the tree\n\t\treturn -1\n\n\tn1_list = []\t\t\t\t\t\t\n\tn2_list = []\n\n\tfor i in range(len(T)):\t\t\t\t\t\t# Traverse the list and append all the parents of node1 if found in O(N)\n\t\tif T[i][n1]==1:\n\t\t\tn1_list.append(i)\n\n\tfor i in range(len(T)):\t\t\t\t\t\t# Traverse the list and append all the parents of node2 is found in O(N)\n\t\tif T[i][n2]:\n\t\t\tn2_list.append(i)\n\n\t\t\t\t\t\t\t\t\t\t\t\t# The root is a common ancestor of every node in the tree\n\tif not r in n1_list:\t\t\t\t\t\t# check if the root is in the list, if not, add it\n\t\tn1_list.append(r)\n\n\tif not r in n2_list:\t\t\t\t\t\t# check if the root is in the list, if not, add it\n\t\tn2_list.append(r)\n\n\tn1_list = reversed(n1_list)\t\t\t\t\t# Since we are operating on a binary tree, we sort\n\tfor i in n1_list:\t\t\t\t\t\t\t# in decending order to operate on the latest nodes\n\t\tif i in n2_list:\t\t\t\t\t\t# if a match is found, we know that it is the lowest common ancestor\n\t\t\treturn i \t\t\t\t\t\t\t# If nothing is found, the root node is bound to be returned. And it correct.","def union(self, data1, data2):\n root1 = self.find_set(data1)\n root2 = self.find_set(data2)\n\n if root1 == root2:\n return False\n\n elif root1.rank >= root2.rank:\n if root1.rank == root2.rank:\n root1.rank = root1.rank + 1\n root2.parent = root1\n else:\n root1.parent = root2\n\n return True","def union(self, data1, data2):\n root1 = self.find_set(data1)\n root2 = self.find_set(data2)\n\n if root1 == root2:\n return False\n\n elif root1.rank >= root2.rank:\n if root1.rank == root2.rank:\n root1.rank = root1.rank + 1\n root2.parent = root1\n else:\n root1.parent = root2\n\n return True","def merge_nodes(node_ids, tree):\n # Copy the tree so we keep the original intact\n temp = deepcopy(tree)\n # Don't merge nodes if they are already merged\n if node_ids in temp or tuple(reversed(node_ids)) in temp:\n return temp\n # Get all the children of each node we need to merge (except if that child is the other node)\n children_1 = filter(lambda x: x != node_ids[1], temp[node_ids[0]])\n children_2 = filter(lambda x: x != node_ids[0], temp[node_ids[1]])\n merged_children = children_1 + children_2\n # Remove the original nodes in the tree\n temp.pop(node_ids[0], None)\n temp.pop(node_ids[1], None)\n # Add a new node\n temp[node_ids] = merged_children\n \n # Update references to the old node with references to the new node\n for k, v in temp.iteritems():\n if node_ids[0] in v:\n idx = v.index(node_ids[0])\n v.remove(node_ids[0])\n v.insert(idx, node_ids)\n if node_ids[1] in v:\n idx = v.index(node_ids[1])\n v.remove(node_ids[1])\n v.insert(idx, node_ids)\n temp[k] = dedupe(v)\n return temp","def compare_trees(tree1, tree2):\n \tresponse = {}\n \tstart_time = time.time()\n \ttry:\t\n \t\ttns = dendropy.TaxonNamespace() \t\n \t\n \t\ttree_obj1 = dendropy.Tree.get(data=tree1, schema=\"newick\",taxon_namespace=tns)\n \t\ttree_obj2 = dendropy.Tree.get(data=tree2, schema=\"newick\",taxon_namespace=tns)\n\n \t\ttree_obj1.encode_bipartitions()\n \t\ttree_obj2.encode_bipartitions()\n\n \t\t#-----------------------------------------------------------\n \t\t#This method returns the symmetric distance between two trees. \n \t\t#The symmetric distance between two trees is the sum of the number of splits found in one of the trees but not the other. \n \t\t#It is common to see this statistic called the Robinson-Foulds distance\n\n \t\tareSame = True if treecompare.symmetric_difference(tree_obj1, tree_obj2) == 0 else False\n \t\tstatus = 200\n \t\tmessage = \"Success\"\n \t\tresponse['are_same_tree'] = areSame\n \n \texcept Exception, e:\n \t\tif \"Incomplete or improperly-terminated tree statement\" in str(e): #invalid: \"((A,B),C,D));\" valid: ((A,B),(C,D)); \n \t\t\tmessage = \"NewickReaderIncompleteTreeStatementError: \" + str(e)\n \t \t\tstatus = 400\n \t\telif \"Unbalanced parentheses at tree statement\" in str(e): #invalid: \"((A,B),(C,D);\" valid: ((A,B),(C,D)); \n \t\t\tmessage = \"NewickReaderMalformedStatementError: \"+str(e) \n \t \t\tstatus = 400\n \t\telif \"Multiple occurrences of the same taxa\" in str(e): #invalid: \"((A,B),(C,C));\" valid: ((A,B),(C,D));\n \t\t\tmessage = \"NewickReaderDuplicateTaxonError: \"+str(e)\n \t \t\tstatus = 400\n \t\telif \"Unexpected end of stream\" in str(e): # invalid: \"((A,B),(C,D))\" valid: ((A,B),(C,D));\n \t\t\tmessage = \"UnexpectedEndOfStreamError: \"+str(e)\n \t \t\tstatus = 400\n \t\telse:\n \t\t\tmessage = \"Error: Failed to compare trees. \"+str(e)\n \t \t\tstatus = 500\n \t \t\n \tresponse['status_code'] = status\n \tresponse['message'] = message\n\n \tend_time = time.time()\n \texecution_time = end_time-start_time\n #service result creation time\n \tcreation_time = datetime.datetime.now().isoformat()\n \tmeta_data = {'creation_time': creation_time, 'execution_time': float('{:4.2f}'.format(execution_time)), 'source_urls':[\"http://dendropy.org/library/treecompare.html#module-dendropy.calculate.treecompare\"] }\n\n \tresponse['meta_data'] = meta_data\n \tprint response\n \treturn response","def nocache_create_equal_size_subtrees():\n N = len(self)\n subTrees = [set(range(i, N, numSubTrees)) for i in range(numSubTrees)]\n totalCost = N\n return subTrees, totalCost","def mergeNodes(nodeA,nodeB,branchLenA,branchLenB):\n newNodeA = (nodeA[0], nodeA[1], nodeA[2], branchLenA)\n newNodeB = (nodeB[0], nodeB[1], nodeB[2], branchLenB)\n new = ('anc',newNodeA,newNodeB,0)\n return new","def get_branch_topology_constraint_v2(\n edge_matchings: List[Tuple[int, int]],\n node_matchings: List[Tuple[int, int]],\n tree_degrees: List[int],\n graph_edges: Dict[int, Tuple[int, int]],\n tree_edges: Dict[int, Tuple[int, int]],\n node_match_indices: Dict[Tuple[int, int], int],\n num_node_matchings: int,\n):\n constraints = {}\n\n for i, (g_e, t_e) in enumerate(edge_matchings):\n g_u, g_v = graph_edges[g_e]\n t_u, t_v = tree_edges[t_e]\n\n uu_index = node_match_indices.get((g_u, t_u))\n vv_index = node_match_indices.get((g_v, t_v))\n\n if uu_index is not None:\n uu_constraints = constraints.setdefault((g_u, t_u), {})\n\n uu_ge_constraint = uu_constraints.setdefault(t_e, [(uu_index, 1)])\n\n uu_ge_constraint.append((i + num_node_matchings, -1))\n\n if vv_index is not None:\n vv_constraints = constraints.setdefault((g_v, t_v), {})\n\n vv_ge_constraint = vv_constraints.setdefault(\n t_e, [(node_match_indices[(g_v, t_v)], 1)]\n )\n\n vv_ge_constraint.append((i + num_node_matchings, -1))\n\n for (g_n, t_n) in node_matchings:\n if t_n == len(tree_degrees):\n continue\n node_match_constraints = constraints.setdefault((g_n, t_n), {})\n if len(node_match_constraints) < tree_degrees[t_n]:\n node_match_constraints[None] = [(node_match_indices[(g_n, t_n)], 1)]\n\n return (\n [\n edge_constraint\n for node_match_constraints in constraints.values()\n for edge_constraint in node_match_constraints.values()\n ],\n \"LessEqual\",\n 0,\n )","def from_binary_trees(tree1, tree2):\n initial_forest = TamariIntervalPosets.initial_forest(tree2)\n final_forest = TamariIntervalPosets.final_forest(tree1)\n try:\n return initial_forest.intersection(final_forest)\n except Exception:\n raise ValueError(\"The two binary trees are not comparable on the Tamari lattice.\")","def build_tree(self):\n resolved_nodes = []\n for nodeh in self.unresolved_nodes:\n sibling, left_sibl = self.find_sibling(nodeh)\n\n if nodeh in resolved_nodes:\n continue\n\n if sibling:\n self.nodes[nodeh]['sibling'] = sibling\n self.nodes[nodeh]['left'] = not left_sibl\n self.nodes[sibling]['left'] = left_sibl\n self.nodes[sibling]['sibling'] = nodeh\n\n if left_sibl:\n parent = do_hash(sibling + nodeh, self.algo)\n else:\n parent = do_hash(nodeh + sibling, self.algo)\n self.nodes[sibling]['parent'] = parent\n self.nodes[nodeh]['parent'] = parent\n resolved_nodes.append(nodeh)\n resolved_nodes.append(sibling)\n\n paddress = parent_address(self.nodes[nodeh]['address'])\n self.nodes[parent] = {'address': paddress}\n self.addresses[paddress] = parent\n if paddress != '':\n self.unresolved_nodes.append(parent)\n else:\n self.nodes[nodeh]['address'] = parent_address(\n self.nodes[nodeh]['address'])\n self.unresolved_nodes = list(\n set(self.unresolved_nodes) - set(resolved_nodes))","def union(self, node1, node2):\n\n root1 = self.root(node1)\n root2 = self.root(node2)\n\n if root1 == root2:\n return\n\n if node1 < node2:\n self.set[root2] = root1\n self.root(node2)\n else:\n self.set[root1] = root2\n self.root(node1)","def findSameSubtrees(self):\n\n collapsable = {}\n\n for i in range(0, len(list(self.nodes))):\n for j in range(i + 1, len(list(self.nodes))):\n # Be careful, non-zero based indexing here\n if self.isSameTree(self.nodes[i + 1], self.nodes[j + 1]):\n # Note time complexity of isSameTree\n collapsable[self.nodes[i + 1]] = self.nodes[j + 1]\n\n return collapsable","def test_initial_nodes_to_merge(self):\r\n t = mergeorder(['A', 'B', 'C', 'D', 'E'], 'foo')\r\n exp = set([t.Children[0], t.Children[1].Children[1]])\r\n obs = initial_nodes_to_merge(t)\r\n self.assertEqual(obs, exp)","def wrong_buildTree(self, start, end, cur):\n if start == end:\n self.nodes[cur] = self.nums[start]\n else: \n mid = start+(end-start)/2\n left, right = 2*cur+1, 2*cur+2\n self.nodes[cur] = self.buildTree(start, mid, left) + self.buildTree(mid+1, end, right)\n return self.nodes[cur]","def generate_tree_general(node_lst, root_index):\n\n def generate_huffman(note):\n \"\"\" Return a new tree based on the given ReadNode node.\n\n @param ReadNode note: a given ReadNode\n @rtype: HuffmanNode\n\n >>> t = generate_huffman(ReadNode(0, 5, 0, 7))\n >>> t\n HuffmanNode(None, HuffmanNode(5, None, None), HuffmanNode(7, None, None))\n >>> t = generate_huffman(ReadNode(1, 1, 1, 0))\n >>> t\n HuffmanNode(None, HuffmanNode(None, None, None), HuffmanNode(None, None, None))\n >>> t.left.number\n 1\n >>> t.right.number\n 0\n \"\"\"\n\n if note.l_type == 0 and note.r_type == 0:\n return HuffmanNode(None, HuffmanNode(note.l_data),\n HuffmanNode(note.r_data))\n elif note.l_type == 0 and note.r_type == 1:\n k = HuffmanNode(None, HuffmanNode(note.l_data), HuffmanNode())\n k.right.number = note.r_data\n return k\n elif note.l_type == 1 and note.r_type == 0:\n k = HuffmanNode(None, HuffmanNode(), HuffmanNode(note.r_data))\n k.left.number = note.l_data\n return k\n else:\n k = HuffmanNode(None, HuffmanNode(), HuffmanNode())\n k.left.number, k.right.number = note.l_data, note.r_data\n return k\n\n def combine_trees(trees_, index):\n \"\"\" Return a new tree based on the list of frame trees and take the\n HuffmanNode tree at int index as the root tree.\n\n @param list[HuffmanNode] trees_:\n @param int index:\n @rtype: HuffmanNode\n\n >>> t = [ReadNode(0, 5, 0, 7), ReadNode(0, 10, 0, 12), ReadNode(1, 1, 1, 0)]\n >>> huff_list = [generate_huffman(x) for x in t]\n >>> a = combine_trees(huff_list, 2)\n >>> a == HuffmanNode(None, HuffmanNode(None, HuffmanNode(10, None, None), HuffmanNode(12, None, None)), HuffmanNode(None, HuffmanNode(5, None, None), HuffmanNode(7, None, None)))\n True\n >>> a.left.number\n 1\n >>> a.right.number\n 0\n >>> combine_trees(huff_list, 0)\n HuffmanNode(None, HuffmanNode(5, None, None), HuffmanNode(7, None, None))\n \"\"\"\n\n root = trees_[index]\n if root.left.number is None and root.right.number is None:\n return root\n elif root.left.number is None and root.right.number is not None:\n right = combine_trees(trees_, root.right.number)\n number = root.right.number\n root.right = right\n root.right.number = number\n return root\n elif root.left.number is not None and root.right.number is None:\n left = combine_trees(trees_, root.left.number)\n number = root.left.number\n root.left = left\n root.left.number = number\n return root\n else:\n left = combine_trees(trees_, root.left.number)\n num_l = root.left.number\n right = combine_trees(trees_, root.right.number)\n num_r = root.right.number\n root.left = left\n root.right = right\n root.left.number = num_l\n root.right.number = num_r\n return root\n\n trees = []\n for node in node_lst:\n trees.append(generate_huffman(node))\n root_tree = combine_trees(trees, root_index)\n\n return root_tree","def union(self, node1, node2):\n root1 = self.find(node1)\n root2 = self.find(node2)\n if root1 != root2: # only merge if the connected components differ\n if self.ranks[root1] > self.ranks[root2]:\n self.parents[root2] = root1\n else:\n self.parents[root1] = root2\n if self.ranks[root1] == self.ranks[root2]:\n self.ranks[root2] += 1","def splitNodes(matching):\n outer = set(range(self.n))\n inner = set([])\n for (u, v) in matching:\n if u in outer:\n outer.remove(u)\n if v in outer:\n outer.remove(v)\n inner.add(u)\n inner.add(v)\n return list(inner), list(outer)","def build_matrix(seq_1_trim, seq_2_trim, config):\n nodes = np.empty((len(seq_1_trim) + 1, len(seq_2_trim) + 1), dtype=Node)\n nodes[0, 0] = CornerNode()\n for index in range(len(seq_1_trim)):\n nodes[1 + index, 0] = EdgeNode(nodes[index, 0], Direction.TOP, config)\n for index in range(len(seq_2_trim)):\n nodes[0, 1 + index] = EdgeNode(nodes[0, index], Direction.LEFT, config)\n\n # build actual matrix\n # could be optimized, as we know from trimming that the first and the last elements of both seq's are different\n for row in range(len(seq_1_trim)):\n for column in range(len(seq_2_trim)):\n nodes[row + 1, column + 1] = Node(\n nodes[row + 1, column], nodes[row, column], nodes[row, column + 1], config\n ).compute_value(seq_1_trim[row], seq_2_trim[column])\n\n return nodes","def root_nodes(self, node1, node2, distance):\n if node1 == node2.parent:\n upper_node = node1\n lower_node = node2\n upper_dist, lower_dist = distance, lower_node.branch - distance\n elif node2 == node1.parent:\n upper_node = node2\n lower_node = node1\n upper_dist, lower_dist = lower_node.branch - distance, distance\n else:\n raise PhyloValueError('root_nodes() requires that one of the given nodes is the parent of the other.')\n if len(self.root.children) <= 1:\n raise PhyloValueError('cannot re-root a tree where the existing root has one or no children.')\n elif len(self.root.children) == 2:\n if upper_node == self.root:\n # Just need to adjust branch lengths\n root_child = self.root.children[1] if self.root.children[0] == lower_node else self.root.children[0]\n root_child.branch += upper_dist\n lower_node.branch = lower_dist\n else:\n upper_path = self.find_path_to_root(upper_node)\n # Process the old root child after removing the root:\n root_child = self.root.children[1] if self.root.children[0] == upper_path[1] else self.root.children[0]\n root_child.branch += upper_path[1].branch\n root_child.parent = upper_path[1]\n upper_path[1].children.append(root_child)\n # Process nodes between root and upper_node:\n prev_node = upper_path[1]\n for next_node in upper_path[2:]:\n prev_node.children.remove(next_node)\n prev_node.parent = next_node\n next_node.children.append(prev_node)\n prev_node.branch = next_node.branch\n prev_node = next_node\n # Process upper_node, lower_node, and the new root\n upper_node.parent = lower_node.parent = self.root\n upper_node.children.remove(lower_node)\n self.root.children = [node1, node2] # Keeps the argument order\n upper_node.branch = upper_dist\n lower_node.branch = lower_dist\n else: # If the root has 3 children it means it's an unrooted tree\n new_root = self.new_tree_node()\n new_root.branch = self.root.branch # Transfers any existing root branch\n if upper_node != self.root:\n upper_path = self.find_path_to_root(upper_node)\n prev_node = self.root\n for next_node in upper_path[1:]:\n prev_node.children.remove(next_node)\n prev_node.parent = next_node\n next_node.children.append(prev_node)\n prev_node.branch = next_node.branch\n prev_node = next_node\n upper_node.children.remove(lower_node)\n upper_node.branch = upper_dist\n lower_node.branch = lower_dist\n new_root.children.append(upper_node)\n new_root.children.append(lower_node)\n upper_node.parent = lower_node.parent = new_root\n self.root = new_root\n self.process_tree_nodes()","def _gen_test_tree_2():\n tree = BinaryNode(5)\n tree.left = BinaryNode(3)\n tree.left.left = BinaryNode(2)\n tree.left.left.left = BinaryNode(1)\n tree.left.right = BinaryNode(4)\n tree.right = BinaryNode(7)\n tree.right.left = BinaryNode(6)\n tree.right.right = BinaryNode(8)\n tree.right.right.right = BinaryNode(9)\n return tree","def add_trees(t1, t2):\n \"*** YOUR CODE HERE ***\"\n if not t1:\n return t2 # Could replace with copy_tree(t2)\n if not t2:\n return t1 # Could replace with copy_tree(t1)\n new_entry = t1.root + t2.root\n t1_branches, t2_branches = list(t1.branches), list(t2.branches)\n length_t1, length_t2 = len(t1_branches), len(t2_branches)\n if length_t1 < length_t2:\n t1_branches += [None for _ in range(length_t1, length_t2)]\n elif length_t1 > length_t2:\n t2_branches += [None for _ in range(length_t2, length_t1)]\n return Tree(new_entry, [add_trees(branch1, branch2) for branch1, branch2 in zip(t1_branches, t2_branches)])","def test_join(trees, leaves, maps, nodeA, nodeB):\n cladeA = get_leaf_set(nodeA)\n cladeB = get_leaf_set(nodeB)\n cladeAB = cladeA.union(cladeB)\n\n if len(cladeA.intersection(cladeB)) > 0:\n raise Exception(\"Nodes are not disjoint on their leaf sets!\\n\")\n\n nodeAinTs = []\n nodeBinTs = []\n for i, tree in enumerate(trees):\n leaf = leaves[i]\n\n if cladeA == leaf:\n nodeAinTs.append(nodeA)\n else:\n nodeAinTs.append(get_node_from_clade(tree, maps[i], cladeA))\n\n if cladeB == leaf:\n nodeBinTs.append(nodeB)\n else:\n nodeBinTs.append(get_node_from_clade(tree, maps[i], cladeB))\n\n nAinTs = []\n for nodeAinT in nodeAinTs:\n nAinTs.append(nodeAinT is not None)\n\n if sum(nAinTs) < 1:\n raise Exception(\"Node A was not found in any tree!\\n\")\n\n nBinTs = []\n for nodeBinT in nodeBinTs:\n nBinTs.append(nodeBinT is not None)\n\n if sum(nBinTs) < 1:\n raise Exception(\"Node B was not found in any tree!\\n\")\n\n violates = False\n for i, tree1 in enumerate(trees[:-1]):\n map1 = maps[i]\n nAinT1 = nAinTs[i]\n nBinT1 = nBinTs[i]\n nodeAinT1 = nodeAinTs[i]\n nodeBinT1 = nodeBinTs[i]\n j = i\n for tree2 in trees[i+1:]:\n j = j + 1\n map2 = maps[j]\n nAinT2 = nAinTs[j]\n nBinT2 = nBinTs[j]\n nodeAinT2 = nodeAinTs[j]\n nodeBinT2 = nodeBinTs[j]\n if (sum([nAinT1, nAinT2]) > 0) and (sum([nBinT1, nBinT2]) > 0):\n if nAinT1 and nAinT2:\n # nodeA in *both* T1 and T2\n if nBinT1 and nBinT2:\n # Case 1: nodeB in *both* T1 and T2\n # Valid if nodeA and nodeB are siblings in both T1 & T2\n node1 = get_node_from_clade(tree1, map1, cladeAB)\n node2 = get_node_from_clade(tree2, map2, cladeAB)\n if (node1 is None) or (node2 is None):\n violates = True\n elif nBinT1:\n # Case 2: Node B in T1 only\n # Valid if nodeA and nodeB are siblings in T1\n node = get_node_from_clade(tree1, map1, cladeAB)\n if node is None:\n violates = True\n elif nBinT2:\n # Case 3: Node B in T2 only\n # Valid if nodeA and nodeB are siblings in T2\n node = get_node_from_clade(tree2, map2, cladeAB)\n if node is None:\n violates = True\n else:\n raise Exception(\"Node B not found in either tree!\\n\")\n elif nAinT1:\n # nodeA in T1 only\n if nBinT1 and nBinT2:\n # Case 4: nodeB in *both* T1 and T2\n node = get_node_from_clade(tree1, map1, cladeAB)\n if node is None:\n violates = True\n elif nBinT1:\n # Case 5: Node B in T1 only\n # Valid if nodeA and nodeB are siblings in T1\n node = get_node_from_clade(tree1, map1, cladeAB)\n if node is None:\n violates = True\n elif nBinT2:\n # Case 6: Node B in T2 only\n # Do join in both trees and test for compatibility\n # TODO: Remove deep copies!\n t1 = deepcopy(tree1)\n t2 = deepcopy(tree2)\n nA = deepcopy(nodeAinT1)\n nB = deepcopy(nodeBinT2)\n [t1, t2] = join_nodes_in_both_trees(t1, nA, cladeA,\n t2, nB, cladeB,\n test=True)\n if t1 is not None:\n violates = are_two_trees_incompatible(t1, t2)\n else:\n raise Exception(\"Node B not found in either tree!\\n\")\n elif nAinT2:\n # nodeA in T2 only\n if nBinT1 and nBinT2:\n # Case 7: nodeB in *both* T1 and T2\n node = get_node_from_clade(tree2, map2, cladeAB)\n if node is None:\n violates = True\n elif nBinT1:\n # Case 8 (reverse of Case 6): Node B in T1 only\n # Do join in both trees and test for compatibility\n # TODO: Remove deep copies!\n t1 = deepcopy(tree1)\n t2 = deepcopy(tree2)\n nA = deepcopy(nodeAinT2)\n nB = deepcopy(nodeBinT1)\n [t1, t2] = join_nodes_in_both_trees(t1, nB, cladeB,\n t2, nA, cladeA,\n test=True)\n if t1 is not None:\n violates = are_two_trees_incompatible(t1, t2)\n elif nBinT2:\n # Case 9: Node B in T2 only\n # Only valid if nodeA and nodeB are siblings in T2\n node = get_node_from_clade(tree2, map2, cladeAB)\n if node is None:\n violates = True\n else:\n raise Exception(\"Node B not found in either tree!\\n\")\n else:\n raise Exception(\"Node A not found in either tree!\\n\")\n\n if violates:\n return violates\n\n return violates","def substructure_sim_exact(subtrees_1, subtrees_2):\n assert(len(subtrees_1) == len(subtrees_2))\n n = len(subtrees_1)\n f1 = np.zeros(n)\n for i in range(n):\n f1[i] = subtrees_1[i] == subtrees_2[i] # calculate the number of matching pairs\n\n return float(np.count_nonzero(f1)) / float(len(f1))","def get_subtree_nodes(T1, T2, new):\n # Get subtree of T2 induced by the new node\n T2_ind = trilearn.graph.junction_tree.subtree_induced_by_subset(T2, {new})\n T2_subtree_nodes = None\n # Find the subtree(2) in T1\n if T2_ind.has_node(frozenset([new])):\n # Isolated node. Unique empty subtree\n T2_subtree_nodes = [{frozenset([new]): None}]\n\n elif T2_ind.order() == 1:\n # Look which is its neighbor\n #c = T2_ind.nodes()[0] # nx < 2.x\n c = list(T2_ind.nodes())[0] # nx > 2.x\n\n if T1.has_node(c - {new}):\n # if it was connected to everything in a clique\n T2_subtree_nodes = [{c: c - {new}}]\n else:\n # c always has at lest one neighbor and the separator c\\new\n # for all of them.\n # We have to decide which of them was the emerging clique.\n # 3 cases:\n # 1) 1 neighbor: Trivial.\n # 2) 2 neighbors: Then it could be any of these.\n # 3) >2 neighbors: The emerging clique is the one that has the\n # others as a subset of its neighbors in T1\n #neigs = T2.neighbors(c) # nx < 2.x\n neigs = list(T2.neighbors(c)) # nx > 2.x\n possible_origins = [c1 for c1 in neigs if c1 & c == c - {new}]\n g = len(possible_origins)\n if g == 1:\n # This neighbor has to be the one it came from\n T2_subtree_nodes = [{c: possible_origins[0]}]\n elif g == 2 and len(neigs) == 2:\n # If there are 2 possible neighbors with the same separator\n T2_subtree_nodes = [{c: possible_origins[0]},\n {c: possible_origins[1]}]\n else:\n for neig in possible_origins:\n if set(neigs) - {neig} <= set(T1.neighbors(neig)):\n T2_subtree_nodes = [{c: neig}]\n break\n else:\n tmp = {}\n # In this case the subtree nodes are uniquely defined by T1 and T2\n # Loop through all edges in T2 in order to extract the correct\n # subtree of T1. Note that, by construction we know that it has the same structure as\n # the induced subtree of T2.\n for e in T2_ind.edges():\n # Non-swallowed cliques, get all potential \"emerging\"\n # (cliques from where the new cliques could have have emerged) cliques.\n Ncp1 = [c for c in T2.neighbors(e[0]) if\n c & e[0] == e[0] - {new}]\n Ncp2 = [c for c in T2.neighbors(e[1]) if\n c & e[1] == e[1] - {new}]\n\n # If the clique was swallowed in the new clique,\n # there will be no neighbors, so the clique itself\n # (except from the new node) is the unique emerging clique.\n if Ncp1 == []:\n Ncp1 = [e[0] - {new}]\n if Ncp2 == []:\n Ncp2 = [e[1] - {new}]\n\n # Replicate the structure in T2\n for neig1 in Ncp1:\n for neig2 in Ncp2:\n if T1.has_edge(neig1, neig2): # Know that this edge is unique\n tmp[e[0]] = neig1\n tmp[e[1]] = neig2\n T2_subtree_nodes = [tmp]\n return T2_subtree_nodes","def build(\n word_dict: AsrDictionary,\n subword_dict: AsrDictionary,\n subword_tokenizer: Callable[[str], List[str]] = None,\n ):\n\n root = lexical_prefix_tree(\n word_dict=word_dict,\n subword_dict=subword_dict,\n subword_tokenizer=subword_tokenizer,\n ) # build traditional tree data structure by reusing existing routines\n\n # Performs pre-order traversal of this tree to assign an index for each node\n max_num_children = 0\n nodes = [None] # nodes[0] is a dummy node for OOV\n node_to_id_dict = {}\n stack = [root]\n\n while len(stack) > 0:\n curr = stack.pop()\n node_id = len(nodes)\n nodes.append(curr)\n node_to_id_dict[curr] = node_id\n if len(curr.children) > max_num_children:\n max_num_children = len(curr.children)\n\n # Guarantee that the children are traversed ascendingly according to the subword index\n for _, next_node in sorted(\n curr.children.items(), key=lambda t: t[0], reverse=True\n ):\n stack.append(next_node)\n\n # Construct the tree\n num_nodes = len(nodes)\n children = np.full([num_nodes, max_num_children], 0, dtype=np.int64)\n prev_subword_idx = np.full([num_nodes], subword_dict.pad(), dtype=np.int64)\n word_idx = np.full([num_nodes], -1, dtype=np.int64)\n word_set_idx = np.full([num_nodes, 2], word_dict.pad(), dtype=np.int64)\n\n for node_id in range(1, len(nodes)): # skip 0, which is `None`\n node = nodes[node_id]\n # Guarantee that the children are traversed ascendingly according to the subword index\n for i, (subword_id, child) in enumerate(\n sorted(node.children.items(), key=lambda t: t[0])\n ):\n child_node_id = node_to_id_dict[child]\n children[node_id, i] = child_node_id\n prev_subword_idx[child_node_id] = subword_id\n\n word_idx[node_id] = node.word_idx\n if node.word_set is not None:\n word_set_idx[node_id] = node.word_set\n else:\n word_set_idx[node_id] = [0, len(word_dict) - 1]\n\n return TensorizedPrefixTree(\n children=torch.from_numpy(children),\n prev_subword_idx=torch.from_numpy(prev_subword_idx),\n word_idx=torch.from_numpy(word_idx),\n word_set_idx=torch.from_numpy(word_set_idx),\n )","def generateTreesRecursive(self, start: int, end: int) -> List[Optional[TreeNode]]:\n if start > end:\n return [None] # to set cur_root.left = None\n\n all_trees = []\n\n for val in range(start, end + 1):\n # cur_root = TreeNode(val)\n\n # get left subtrees (less than val)\n left_subtrees = self.generateTreesRecursive(start, val - 1)\n # get right subtrees (greater than val)\n right_subtrees = self.generateTreesRecursive(val + 1, end)\n\n for l_subtree in left_subtrees:\n for r_subtree in right_subtrees:\n cur_root = TreeNode(val)\n cur_root.left = l_subtree\n cur_root.right = r_subtree\n\n # cur_root is now the root of a BST\n all_trees.append(cur_root)\n\n return all_trees","def _build_tree(nodes):\n\n tree = []\n\n for trace_id in nodes:\n node = nodes[trace_id]\n node.setdefault(\"children\", [])\n parent_id = node[\"parent_id\"]\n if parent_id in nodes:\n nodes[parent_id].setdefault(\"children\", [])\n nodes[parent_id][\"children\"].append(node)\n else:\n tree.append(node) # no parent => top-level node\n\n for node in nodes:\n nodes[node][\"children\"].sort(key=lambda x: x[\"info\"][\"started\"])\n\n return sorted(tree, key=lambda x: x[\"info\"][\"started\"])","def compare_topology(tree1, tree2):\n n2p1, n2p2 = ({node.name: node.parent.name\n for node in tree.traverse() if not node.is_root()}\n for tree in (tree1, tree2))\n return n2p1 == n2p2","def greedy_build(nodes, priors=None, cutoff=200, considered=set(), uniq='', targets=[]):\n\n\t# Tracks frequency of states for each character in nodes\n\tcharacter_mutation_mapping = defaultdict(int)\n\n\t# G models the network that is returned recursively\n\tG = nx.DiGraph()\n\n\troot = root_finder(nodes)\n\n\t# Base case check for recursion, returns a graph with one node corresponding to the root of the remaining nodes\n\tif len(nodes) <= cutoff or len(nodes) == 1:\n\t\troot = root_finder(nodes)\n\t\tG.add_node(root)\n\t\treturn G, [[root, nodes]]\n\n\t# Accounting for frequency of mutated states per character, in order to choose the best split\n\tfor node in nodes:\n\t\tnode_list = node.split(\"_\")[0].split('|')\n\t\tfor i in range(0, len(node_list)):\n\t\t\tchar = node_list[i]\n\t\t\tif char != '0' and char != '-':\n\t\t\t\tcharacter_mutation_mapping[(str(i), char)] += 1\n #if char != '0':\n # if char == \"-\":\n # character_mutation_mapping[(str(i), char)] -= 1\n # else:\n # character_mutation_mapping[(str(i), char)] += 1\n\n\t# Choosing the best mutation to split on (ie character and state)\n\tcharacter, state = 0, 0\n\tmax_cost = 0\n\n\tmin_prior = 1\n\tif priors:\n\t\tfor i in priors.keys():\n\t\t\tfor j in priors[i].keys():\n\t\t\t\tmin_prior = min(min_prior, priors[i][j])\n\n\tfor i,j in character_mutation_mapping:\n\t\tif not (i,j) in considered:\n\t\t\tif not priors:\n\t\t\t\tif max_cost < character_mutation_mapping[(i, j)]:\n\t\t\t\t\tmax_cost = character_mutation_mapping[(i, j)]\n\t\t\t\t\tcharacter, state = i, j\n\t\t\telse:\n\t\t\t\tif j not in priors[int(i)]:\n\t\t\t\t\tpriors[int(i)][j] = min_prior\n\t\t\t\tif max_cost < -np.log(priors[int(i)][j]) * character_mutation_mapping[(i, j)]:\n\t\t\t\t\tmax_cost = -np.log(priors[int(i)][j]) * character_mutation_mapping[(i, j)]\n\t\t\t\t\tcharacter, state = i, j\n\tcharacter = int(character)\n\n\n\t# If there is no good split left, stop the process and return a graph with the remainder of nodes\n\tif character == 0 and state == 0:\n\t\tif len(nodes) == 1:\n\t\t\tG.add_node(nodes[0])\n\t\telse:\n\t\t\tfor i in range(0, len(nodes)):\n\t\t\t\tif nodes[i] != root:\n\t\t\t\t\tG.add_edge(root, nodes[i])\n\t\treturn G, []\n\n\t# Splitting nodes based on whether they have the mutation, don't have the mutation, or are NA('-') in that character\n\t# Right split is where nodes with the mutation go, everyone else goes to left split or NA chars\n\tleft_split, right_split, NA_chars = [], [], []\n\tright_split_temp = []\n\tleft_split_temp = []\n\tfor node in nodes:\n\t\tnode_list = node.split('|')\n\t\tif node_list[character] == state:\n\t\t\tright_split.append(node)\n\t\telif node_list[character] == '-':\n\t\t\tNA_chars.append(node)\n\t\telse:\n\t\t\tleft_split.append(node)\n\n\n\t# Seperates all nodes with NA in the character chosen to be split upon\n\t# Puts in right split or left split based on which list shares more mutated characters with this string\n\tfor node in NA_chars:\n\t\tright_split_score = 0\n\t\tleft_split_score = 0\n\t\tnode_list = node.split('|')\n\t\tnum_not_missing = len([n for n in node_list if n != \"-\"])\n\t\tfor i in range(0, len(node_list)):\n\t\t\tif node_list[i] != '0' and node_list[i] != '-':\n\t\t\t\tfor node_2 in left_split:\n\t\t\t\t\tnode2_list = node_2.split('|')\n\t\t\t\t\tif node_list[i] == node2_list[i]:\n\t\t\t\t\t\tleft_split_score += 1\n\t\t\t\tfor node_2 in right_split:\n\t\t\t\t\tnode2_list = node_2.split('|')\n\t\t\t\t\tif node_list[i] == node2_list[i]:\n\t\t\t\t\t\tright_split_score += 1\n\n\t\tavg_left_split_score = left_split_score / float(len(left_split) * num_not_missing + 1)\n\t\tavg_right_split_score = right_split_score / float(len(right_split) * num_not_missing + 1)\n\n\t\tif avg_left_split_score < avg_right_split_score:\n\t\t\tright_split_temp.append(node)\n\t\telse:\n\t\t\tleft_split_temp.append(node)\n\n\tright_split += right_split_temp\n\tleft_split += left_split_temp\n\n\t# Add character, state that split occurred to already considered mutations\n\tconsidered.add((str(character), state))\n\tG = nx.DiGraph()\n\t#splitter = str(character) + \" \" + str(state) + \" (\" + uniq + \")\"\n\tsplitter = root\n\n\t# Recursively build left side of network (ie side that did not mutation at the character with the specific state)\n\tG.add_node(splitter)\n\tleft_subproblems = []\n\tleft_network = None\n\tif len(left_split) != 0:\n\t\tleft_root = root_finder(left_split)\n\t\t# if left_root not in left_split and left_root in targets:\n\t\t# \tleft_root = left_root + \"_unique\"\n\n\t\tleft_network, left_subproblems = greedy_build(left_split, priors, cutoff, considered.copy(), uniq + \"0\", targets=targets)\n\n\t\tleft_nodes = [node for node in left_network.nodes() if left_network.in_degree(node) == 0]\n\t\tdup_dict = {}\n\t\tfor n in left_network:\n\t\t\tif n in list(G.nodes()) and n != left_root:\n\t\t\t\tdup_dict[n] = n + \"_\" + str(hashlib.md5(left_root.encode('utf-8')).hexdigest())\n\t\tleft_network = nx.relabel_nodes(left_network, dup_dict)\n\t\tG = nx.compose(G, left_network)\n\t\tif root != left_root:\n\t\t\tG.add_edge(splitter, left_root, weight=0, label=\"None\")\n\n\t# Recursively build right side of network\n\tright_network, right_subproblems = greedy_build(right_split, priors, cutoff, considered.copy(), uniq + \"1\", targets=targets)\n\tright_nodes = [node for node in right_network.nodes() if right_network.in_degree(node) == 0]\n\tright_root = root_finder(right_split)\n\n\tdup_dict = {}\n\tfor n in right_network:\n\t\tif n in list(G.nodes()) and n != right_root:\n\t\t\tdup_dict[n] = n + \"_\" + str(hashlib.md5(right_root.encode('utf-8')).hexdigest())\n\tfor n in dup_dict:\n\t\trename_dict = {n: dup_dict[n]}\n\t\tif right_network.out_degree(n) != 0:\n\t\t\tright_network = nx.relabel_nodes(right_network, rename_dict)\n\t\telse:\n\t\t\trename_dict = {n: dup_dict[n]}\n\t\t\tG = nx.relabel_nodes(G, rename_dict)\n\n\tG = nx.compose(G, right_network)\n\t# if right_root not in right_split and right_root in targets:\n\t# \tright_root = right_root + \"_unique\"\n\t#for node in right_nodes:\n\tif root != right_root:\n\t\tif not priors:\n\t\t\tG.add_edge(splitter, right_root, weight=1, label = str(character) + \": 0 -> \" + str(state))\n\t\telse:\n\t\t\tG.add_edge(splitter, right_root, weight=-np.log(priors[int(character)][state]), label=str(character) + \": 0 -> \" + str(state))\n\n\n\treturn G, left_subproblems + right_subproblems","def merge_nodes(self):\n\n\t\t\t#obtenemos los dos primeros nodos que equivalen a quienes tienen menor frecuencia\n\t\t\twhile(len(self.heap)>1):\n\t\t\t\tnode1 = heapq.heappop(self.heap)\n\t\t\t\tnode2 = heapq.heappop(self.heap)\n\n\t\t\t\tmerged = self.HeapNode(None, node1.freq + node2.freq)#creamos un nodo padre que va a contener los nodos anteriores a la derecha y izquierda\n\t\t\t\tmerged.left = node1\n\t\t\t\tmerged.right = node2\n\n\t\t\t\theapq.heappush(self.heap, merged)#agregamos este nodo al priority queue","def merge(self):\n collapsable = self.findSameSubtrees()\n\n dummy = GraphiusNode(-1, None)\n for i, node in self.nodes.items():\n dummy.addNeighbor(node)\n\n # Perform the merge\n self.mergeHelper(dummy, collapsable)\n\n # Regenerate trees\n newNodes = self.dfs(dummy)\n assert(-1 not in newNodes)\n self.nodes = newNodes","def test_build_match_tree_with_pairs():\n abbreviation_list = [[\"ELIF\", \"ELI.\"], [\"ELSE\", \"E.\"]]\n expected_tree = {\"E\": {\"L\": {\"I\": {\"F\": \"ELI.\"}, \"S\": {\"E\": \"E.\"}}}}\n tree = build_match_tree(abbreviation_list)\n assert repr(tree) == repr(expected_tree)","def buildTree(self, nums, start, end):\n if start > end: # did not have this stop condition causing error of corner case: nums=[]\n return None\n node = SegmentTreeNode(start, end)\n if start == end:\n node.val = nums[start]\n else:\n mid = start+(end-start)/2\n left = self.buildTree(nums, start, mid)\n right = self.buildTree(nums, mid+1, end)\n node.left, node.right = left, right\n node.val = left.val + right.val \n # node.val = (left.val if left else 0) + (right.val if right else 0) : not necessary because non-leaf node always have two children\n return node","def subtree_cond_pdf(tree1, tree2, tree2_subtree_nodes, new):\n\n # if new is isolated in the underlying graph\n\n #if len(tree2_subtree_nodes) == 1 and tree2_subtree_nodes.values()[0] is None:\n if len(tree2_subtree_nodes) == 1 and list(tree2_subtree_nodes.values())[0] is None:\n sep = frozenset([])\n c = frozenset([new])\n lognu = trilearn.graph.junction_tree.log_nu(tree2, sep)\n return ({c: np.exp(-lognu)}, {c: 1.0})\n\n # Get the subtree induced by the nodes\n #tree1_subtree = tree1.subgraph([c_t1 for c_t2, c_t1 in tree2_subtree_nodes.iteritems()])\n tree1_subtree = tree1.subgraph([c_t1 for c_t2, c_t1 in tree2_subtree_nodes.items()])\n\n\n # Get the separating sets\n # S = sepsets_in_subgraph(tree2_subtree_nodes, tree1_subtree)\n\n # S = {c: set() for c_t2, c in tree2_subtree_nodes.iteritems()}\n S = {c: set() for c_t2, c in tree2_subtree_nodes.items()}\n #for c_tree2, c in tree2_subtree_nodes.iteritems():\n for c_tree2, c in tree2_subtree_nodes.items():\n for neig in tree1_subtree.neighbors(c):\n S[c] = S[c] | (c & neig)\n\n # P, N get_subset_probabilities(tree2_)\n # Get the chosen internal nodes\n M = {}\n # for c_tree2, c in tree2_subtree_nodes.iteritems():\n for c_tree2, c in tree2_subtree_nodes.items():\n M[c] = c_tree2 - {new} - S[c]\n\n # Calculate probabilities corresponding to each clique\n P = {}\n N = {}\n # for c_tree2, c in tree2_subtree_nodes.iteritems():\n for c_tree2, c in tree2_subtree_nodes.items():\n neigs = {neig for neig in tree1.neighbors(c) if\n neig & c <= c_tree2 and neig not in tree1_subtree.nodes()}\n RM = c - S[c]\n gamma = tree1_subtree.order()\n # sepCondition = len({neig for neig in nx.neighbors(tree1_subtree, c) if\n # S[c] == neig & c}) > 0 or gamma == 1\n sepCondition = len({neig for neig in tree1_subtree.neighbors(c) if\n S[c] == neig & c}) > 0 or gamma == 1\n\n N[c] = 1.0\n #N[c] = Fraction(1,1)\n if sepCondition is False:\n # Every internal node in c belongs to a separator\n P[c] = np.power(2.0, - len(RM))\n #P[c] = Fraction(1, 2 ** len(RM))\n if not len(c) + 1 == len(c_tree2):\n N[c] = np.power(2.0, -len(neigs))\n #N[c] = Fraction(1, 2**len(neigs))\n else:\n P[c] = 1.0\n if len(RM) > 1:\n P[c] = (1.0 / len(RM)) * np.power(2.0, -(len(RM) - 1.0)) * len(M[c])\n #P[c] = Fraction(1, len(RM)) * Fraction(len(M[c]), 2 ** (len(RM) - 1.0)) \n if not len(c) + 1 == len(c_tree2):\n N[c] = np.power(2.0, -len(neigs))\n #N[c] = Fraction(1, 2**len(neigs))\n return (P, N)","def match_nodes(source_node, target_node):\n\n node_position = cmds.xform(source_node, q=True, ws=True, t=True)\n node_rotation = cmds.xform(source_node, q=True, ws=True, ro=True)\n cmds.xform(target_node, ws=True, t=node_position)\n cmds.xform(target_node, ws=True, ro=node_rotation)","def iterative_solution(list1, list2):\n pre_root = Node(-1)\n prev = pre_root\n\n while list1 and list2:\n if list1.data <= list2.data:\n prev.next = list1\n list1 = list1.next\n else:\n prev.next = list2\n list2 = list2.next\n prev = prev.next\n\n if not list1:\n prev.next = list2\n else:\n prev.next = list1\n\n return pre_root.next","def compare_trees(tree1, tree2):\n for key in tree1.keys():\n print(key)\n assert key in tree2.keys()\n if isinstance(tree1[key], list):\n print(tree1[key])\n assert tree1[key] == tree2[key]\n else:\n print('Calling compare_trees recursively')\n compare_trees(tree1[key], tree2[key])","def get_subgraph_between_nodes(self, start, end):\n nodes = set()\n nodes.add(start)\n\n to_visit = set()\n to_visit.add(start)\n\n while len(to_visit) > 0:\n current_visit = copy.copy(to_visit)\n for tv in current_visit:\n to_visit.remove(tv)\n if tv is not end:\n for s in self.successors(tv):\n to_visit.add(s)\n nodes.add(s)\n\n nodes.add(end)\n\n return self.subgraph(nodes)","def equals_list_nodes(self, self_list_nodes, other_list_nodes):\n\n #If the two list of nodes have different lengths, they are automatically different\n if len(self_list_nodes) != len(other_list_nodes):\n return False\n else:\n\n #We sort both list of nodes\n self_list_nodes = sorted(self_list_nodes, key=lambda x : x.num)\n other_list_nodes = sorted(other_list_nodes, key=lambda x : x.num)\n\n #For each node in both lists\n for i, node in enumerate(self_list_nodes):\n\n #We check if the length of the list of the nodes they are connected to are the same\n if len(node.connected_to) != len(other_list_nodes[i].connected_to):\n return False\n else:\n #We check if the connection between the nodes in both list is the same\n node_connected_to = sorted(node.connected_to, key=lambda x : x.num)\n other_node_connected_to = sorted(self_list_nodes[i].connected_to, key=lambda x : x.num)\n for j, node_connec in enumerate(node_connected_to):\n if node_connec.num != other_node_connected_to[j].num:\n return False\n return True","def build_tree(preorder, inorder):\n\n # Base case\n if preorder == [] or inorder == []:\n return\n\n root = preorder[0]\n\n # Breaks the lists by root, left side, and right side\n in_index = inorder.index(root)\n in_left = inorder[:in_index]\n in_right = inorder[in_index + 1:]\n pre_left = preorder[1 : len(in_left) + 1]\n pre_right = preorder[len(in_left) + 1 :]\n\n # Recursively creates smaller binary trees to make a big binary tree\n tree = BinaryTree(root)\n tree.set_left(build_tree(pre_left, in_left))\n tree.set_right(build_tree(pre_right, in_right))\n\n return tree","def build_tree(self):\n stack = []\n self._handle_solo_node_case()\n while self.root_hash == None:\n if len(stack) >= 2 and stack[-1].height == stack[-2].height:\n mom = stack.pop()\n dad = stack.pop()\n child_hash = self.sha256Sum(mom.hash + dad.hash)\n child = self.Node(mom, dad, child_hash)\n self.node_table[child_hash] = child\n mom.child = child\n dad.child = child\n\n if child.height == self.max_height:\n self.root_hash = child.hash\n\n stack.append(child)\n elif len(self.leaves) > 0:\n leaf = self.leaves.pop()\n self.node_table[leaf.hash] = leaf\n stack.append(leaf)\n # Handle case where last 2 nodes do not match in height by \"graduating\"\n # last node\n else:\n stack[-1].height += 1\n self.is_built = True","def huffman_tree(left, right):\n return tree(root(left) + root(right), [left, right])","def _sorted_list_to_bst(cls, items=[], start=None, end=None, parent=None):\n if start > end:\n return None\n mid = start + (end - start) // 2\n node = Node(items[mid], parent)\n node.left = cls._sorted_list_to_bst(items, start, mid - 1, node)\n node.right = cls._sorted_list_to_bst(items, mid + 1, end, node)\n return node","def merge_personroots_of_two_nodes(name1: str, value1: str,\n name2: str, value2: str) -> None:\n left_node = read_node(name=name1, value=value1)\n right_node = read_node(name=name2, value=value2)\n if left_node is None or right_node is None:\n return\n\n left_personroot_node = get_or_create_personroot_node(person_node=left_node)\n right_personroot_node = get_or_create_personroot_node(person_node=right_node)\n if left_personroot_node is None or right_personroot_node is None:\n return\n\n if left_personroot_node == right_personroot_node:\n # They are already connected, we are done.\n return\n\n merge_two_personroot_nodes(left_personroot_node=left_personroot_node,\n right_personroot_node=right_personroot_node)\n return","def sort_nodes(center_node, nodes):\n def cmp(n1, n2):\n angle1 = (math.degrees(center_node.angle_to(n1)) + 360.) % 360\n angle2 = (math.degrees(center_node.angle_to(n2)) + 360.) % 360\n\n if angle1 < angle2:\n return -1\n elif angle1 == angle2:\n return 0\n else:\n return 1\n return sorted(nodes, cmp=cmp)","def _match_identical_nodes(self):\n\n for job_name_b in self._topo_b_nodes:\n for job_name_a in self._unresolved_a_nodes:\n if self._is_node_identical(job_name_a, job_name_b):\n self._identical_nodes[job_name_b] = job_name_a\n self._unresolved_a_nodes.remove(job_name_a)\n self._unresolved_b_nodes.remove(job_name_b)\n break","def create_tree(self, tree):\n # print(self)\n if len(self.available_combinations()) > 1:\n comb1 = random.choice(self.available_combinations())\n comb2 = random.choice(self.available_combinations())\n\n if self.last_move == 5:\n next_move = 7\n else:\n next_move = 5\n\n # print(next_move)\n\n board1 = copy.deepcopy(self)\n board2 = copy.deepcopy(self)\n\n board1.board[comb1[0]][comb1[1]] = next_move\n board1.last_move = 7\n tree.insert_left(board1)\n board2.board[comb2[0]][comb2[1]] = next_move\n board2.last_move = 7\n tree.insert_right(board2)\n\n board1.create_tree(tree.get_left_child())\n board2.create_tree(tree.get_left_child())","def all_nodes_dfs(log_T, initial_state, min_score, sub_info, max_depth=1000000000000000000, maxtraversals=1000000000000000000):\n # default argument for sub_info: empty_sub_info = (np.array([], dtype=int), np.array([], dtype=int), 1000000000000000000)\n min_score = float(min_score) # make sure numba knows this is a float (otherwise, sometimes, it doesn't (bug in numba))\n order = np.zeros(log_T.shape, np.int64)\n for i in xrange(order.shape[1]):\n order[i] = (-log_T[i]).argsort()\n n_states = log_T.shape[0]\n node = [order[initial_state, 0]] # most likely first node\n node_idx = [0]\n lengths_dfs = [-1.0]\n nodes_dfs = [[-1, ]]\n for it in xrange(maxtraversals):\n # score and return current node if adequate\n score = log_T[initial_state, node[0]]\n for p in xrange(1, len(node)):\n score += log_T[node[p - 1], node[p]]\n if min_score <= score and syntax_check(np.array(node), sub_info, partial=False):\n lengths_dfs.append(-score)\n nodes_dfs.append(list(node))\n # next node ##\n # try adding a value at the end\n for next_idx, next_state in enumerate(order[node[-1]]):\n if min_score <= score + log_T[node[-1], next_state] and len(node) < max_depth \\\n and syntax_check(np.array(node + [next_state]), sub_info, partial=True):\n node.append(next_state)\n node_idx.append(next_idx)\n break\n # adding a value at the end failed, so we are a leave\n else:\n for p in xrange(len(node) - 1, -1, -1):\n if node_idx[p] != n_states - 1: # find where within the node to increase (and discard all others after)\n old_idx = node_idx[p]\n del node_idx[p:]\n del node[p:]\n node_idx.append(old_idx + 1)\n prev_state = node[p - 1] if p > 0 else initial_state\n node.append(order[prev_state, node_idx[p]])\n break\n else:\n break # end of the generator, can't increase even the root\n else:\n assert False, \"Number of traversals exceeded\"\n\n return lengths_dfs[1:], nodes_dfs[1:]","def _get_sequence_based_sorting_keys(self):\n left_event_defs = self._left_subtree.get_event_definitions()\n right_event_defs = self._right_subtree.get_event_definitions()\n # comparing min and max leaf index of two subtrees\n min_left = min(left_event_defs, key=lambda x: x.index).index # [ { ] } or [ { } ]\n max_left = max(left_event_defs, key=lambda x: x.index).index # { [ } ] or { [ ] }\n min_right = min(right_event_defs, key=lambda x: x.index).index # [ ] { }\n max_right = max(right_event_defs, key=lambda x: x.index).index # { } [ ]\n if max_left < min_right: # 3)\n left_sort, right_sort, rel_op = -1, 0, RelopTypes.SmallerEqual\n elif max_right < min_left: # 4)\n left_sort, right_sort, rel_op = 0, -1, RelopTypes.GreaterEqual\n elif min_left < min_right: # 1)\n left_sort, right_sort, rel_op = 0, 0, RelopTypes.SmallerEqual\n elif min_right < min_left: # 2)\n left_sort, right_sort, rel_op = 0, 0, RelopTypes.GreaterEqual\n if rel_op is None:\n raise Exception(\"rel_op is None, something bad has happened\")\n left_sorting_key = lambda pm: pm.events[left_sort].timestamp\n right_sorting_key = lambda pm: pm.events[right_sort].timestamp\n # left/right_sort == 0 means that left/right subtree will be sorted by first timestamp\n return left_sorting_key, right_sorting_key, rel_op, (left_sort == 0), (right_sort == 0)","def join_nodes(trees, leaves, maps, nodeA, nodeB):\n cladeA = get_leaf_set(nodeA)\n cladeB = get_leaf_set(nodeB)\n\n if len(cladeA.intersection(cladeB)) > 0:\n raise Exception(\"Nodes are not disjoint on their leaf sets!\\n\")\n\n edits = [False] * len(trees)\n for i, edit in enumerate(edits):\n leaf = leaves[i]\n\n if cladeA == leaf:\n nodeAinT = nodeA\n else:\n nodeAinT = get_node_from_clade(trees[i], maps[i], cladeA)\n\n if cladeB == leaf:\n nodeBinT = nodeB\n else:\n nodeBinT = get_node_from_clade(trees[i], maps[i], cladeB)\n\n nAinT = nodeAinT is not None\n nBinT = nodeBinT is not None\n\n if nAinT and nBinT:\n # Node A and node B are both in T, do nothing!\n pass\n elif nAinT:\n # Add node B to T\n edits[i] = True\n root = dendropy.Node()\n root.add_child(deepcopy(nodeB)) # TODO: Remove deep copies!\n if leaves[i] == cladeA:\n nodeAinT.parent_node = None\n root.add_child(nodeAinT)\n else:\n [tree, nodeAinT] = extract_nodes_from_split(trees[i], nodeAinT,\n cladeA)\n root.add_child(tree.seed_node)\n trees[i] = dendropy.Tree(seed_node=root)\n trees[i].is_rooted = True\n elif nBinT:\n # Add node A to T\n edits[i] = True\n root = dendropy.Node()\n root.add_child(deepcopy(nodeA)) # TODO: Remove deep copies!\n if leaves[i] == cladeB:\n nodeBinT.parent_node = None\n root.add_child(nodeBinT)\n else:\n [tree, nodeBinT] = extract_nodes_from_split(trees[i], nodeBinT,\n cladeB)\n root.add_child(tree.seed_node)\n trees[i] = dendropy.Tree(seed_node=root)\n trees[i].is_rooted = True\n else:\n # Neither node A or node B is in T, do nothing!\n pass\n\n return [trees, edits]","def isSameTree(self, node1, node2):\n # print(\"isSameTree call for {} and {}\".format(node1.id, node2.id))\n\n if node1.id == node2.id:\n return True\n if node1.value == node2.value:\n # Compare children, in sorted order based on value\n node1Children = list(\n sorted(\n node1.neighbors,\n key=lambda node:\n node.value))\n node2Children = list(\n sorted(\n node2.neighbors,\n key=lambda node:\n node.value))\n\n if len(node1Children) == len(node2Children):\n # For identical trees, A list of nieghbors\n # in sorted (based on value) order:\n # Should have same length\n # At each position, values are same (verify recursively)\n for i in range(len(node1Children)):\n if not self.isSameTree(node1Children[i], node2Children[i]):\n return False\n # All neighbor pairs verified\n return True","def neighborJoining(distances):\n\n tree = {}\n\n while(len(distances.keys()) > 2):\n\n r = calcRs(distances)\n M = makeMMatrix(distances, r)\n\n smallest = 10000\n smallestKey = (\"\",\"\")\n\n #Find nearest neighbors\n for key in M.keys():\n for subkey in M[key].keys():\n if M[key][subkey] < smallest:\n smallest = M[key][subkey]\n smallestKey = (key, subkey)\n\n #Add new node and update distances to rest of tree\n newname = smallestKey[0] + \"-\" + smallestKey[1]\n distances[newname] = {}\n tree[smallestKey[0]] = {}\n tree[smallestKey[1]] = {}\n dij = distances[smallestKey[0]][smallestKey[1]]\n for key in M.keys():\n if key in smallestKey:\n continue\n distances[newname][key] = .5*(distances[smallestKey[0]][key] \\\n + distances[smallestKey[1]][key] - dij)\n distances[key][newname] = distances[newname][key]\n\n #Update distances to parents of node\n dik = (dij + r[smallestKey[0]] - r[smallestKey[1]])/2\n tree[smallestKey[0]][newname] = dik\n tree[smallestKey[1]][newname] = dij-dik\n detachDict(distances, smallestKey[0], smallestKey[1])\n\n #Connect final two nodes\n tree[distances.keys()[0]] = {}\n tree[distances.keys()[0]][distances[distances.keys()[0]].keys()[0]] =\\\n distances[distances.keys()[0]][distances[distances.keys()[0]].keys()[0]] \n return tree","def merge_nodes(self,n0,n1):\n # -- Sanity checks - does not yet allow for collapsing edges.\n\n # if they share any cells, would update the cells, but for now\n # just signal failure.\n n0_cells=list(self.node_to_cells(n0))\n n1_cells=list(self.node_to_cells(n1))\n cell_to_edge_cache={}\n\n for c in n1_cells:\n if c in n0_cells:\n print(\"cell %d common to both nodes\"%c)\n raise GridException(\"Not ready for merging nodes in the same cell\")\n # otherwise record and fix up below\n\n # while we're looping, cache the edges as they will\n # be mutated along the way.\n cell_to_edge_cache[c]=self.cell_to_edges(c).copy()\n\n # do they share an edge, but not already fixed in the above stanza?\n j=self.nodes_to_edge(n0,n1)\n if j is not None:\n raise GridException(\"Not ready for merging endpoints of an edge\")\n\n edge_map={} # index of superceded edge => superceding edge\n\n # Update edges of n1 to point to n0\n # if that would cause a duplicate edge, then the n1 version is deleted\n n1_edges=list(self.node_to_edges(n1)) # make copy since we'll mutate it\n for j in n1_edges:\n if self.edges['nodes'][j,0]==n1:\n nj=0\n elif self.edges['nodes'][j,1]==n1:\n nj=1\n else:\n assert False # sanity check\n newnodes=self.edges[j]['nodes'].copy()\n newnodes[nj]=n0\n # it's possible that this is an edge which already exists\n jother=self.nodes_to_edge(*newnodes)\n if jother is not None:\n # want to keep jother, delete j. but is there info on\n # cells which should be brought over?\n edge_map[j]=jother\n # wait to delete j until after cells have been moved to jother.\n else:\n self.log.debug(\"Modifying edge j=%d\"%j)\n self.modify_edge(j,nodes=newnodes)\n\n # -- Transition any cells. \n for c in n1_cells:\n # update the node list:\n cnodes=self.cell_to_nodes(c).copy()\n nc=list(cnodes).index(n1)\n cnodes[nc]=n0\n\n # Dangerous to use cell_to_edges, since it may\n # have to consult the edge topology, which is disrupted\n # in the above code. \n # cell_to_edges: first checks cells['edges'], may \n # go to cell_to_nodes(c): that's safe.\n # and nodes_to_edge\n # -> node_to_edges, which in turn may consult self.edges['nodes']\n\n #cedges=self.cell_to_edges(c).copy()\n cedges=cell_to_edge_cache[c]\n\n for ji,j in enumerate(cedges):\n if j in edge_map:\n # is there were edges['cells'] should be updated?\n\n # sever the edge=>cell pointer, to p\n # could just set to [-1,-1], but this keeps things very explicit\n # for debugging\n j_cells=list(self.edges['cells'][j])\n j_cells_side=j_cells.index(c)\n j_cells[ j_cells_side ] = -1\n self.modify_edge(j,cells=j_cells)\n\n # and modify the receiving edge, too\n jo=edge_map[j]\n jo_cells=list(self.edges['cells'][jo])\n # which side of jo? a bit tedious...\n if list(self.edges['nodes'][j]).index(n1) == list(self.edges['nodes'][jo]).index(n0):\n # same orientation\n jo_cells_side=j_cells_side\n elif list( self.edges['nodes'][j]).index(n1) == 1-list(self.edges['nodes'][jo]).index(n0):\n jo_cells_side=1-j_cells_side\n else:\n raise Exception(\"Failed in some tedium\")\n assert jo_cells[jo_cells_side]<0\n jo_cells[jo_cells_side]=c\n self.modify_edge(edge_map[j],cells=jo_cells)\n # yikes. any chance that worked?\n\n cedges[ji]=edge_map[j]\n\n # maybe this is where we'd update cells['edges'] too?\n self.modify_cell(c,nodes=cnodes,edges=cedges)\n\n for dead_edge in edge_map:\n self.delete_edge(dead_edge)\n\n self.delete_node(n1)","def build_nodes(self, tasks, clean_list):\n for name in clean_list:\n # add node itself if not in list of nodes\n self.nodes.setdefault(name, [])\n task = tasks[name]\n # reversing not required\n for dep_name in reversed(task.task_dep):\n if tasks[dep_name].subtask_of == name:\n rev_dep = self.nodes.setdefault(dep_name, [])\n rev_dep.append(name)","def job_tree(self):\n\n # 1. Enforce depth of 1 for steps\n def depth_one(steps):\n depth_one = []\n for step in steps:\n if type(step) is list:\n if type(step[0]) is list:\n depth_one.append(step[0])\n else:\n depth_one.append(step)\n else:\n depth_one.append([step])\n return depth_one\n\n # 2. Convert steps to list of node objects (0,1,2,3...)\n def assign_nodes(steps):\n nodes = [i for i in range(len(steps))]\n objects = list(\n set([elem for sublist in steps for elem in sublist]))\n\n # checks for multiple src and dst objects -- added when looking for\n # mutiples\n split_objects = []\n for obj in objects:\n if len(obj) > 1:\n new_objs = obj.split(\", \")\n split_objects.extend(new_objs)\n else:\n split_objects.append(obj)\n objects = split_objects\n del(split_objects)\n\n # populate with leafless trees (Node objects, no edges)\n for node in nodes:\n nodes[node] = Node(str(node))\n\n # search for leafy trees\n for obj in objects:\n\n # accounts for multiple drc/dst objects\n leaves = []\n for i, sublist in enumerate(steps):\n for string in sublist:\n if string.count(',') > 0:\n if obj in string:\n leaves.append(i)\n else:\n if obj in sublist:\n leaves.append(i)\n leaves = sorted(list(set(leaves)))\n\n if len(leaves) > 1:\n viable_edges = []\n\n # compute cross-product\n for leaf1 in leaves:\n for leaf2 in leaves:\n if str(leaf1) != str(leaf2) and sorted((leaf1, leaf2)) not in viable_edges:\n viable_edges.append(sorted((leaf1, leaf2)))\n\n # form edge networks\n for edge in viable_edges:\n n1, n2 = nodes[edge[0]], nodes[edge[1]]\n n1.add_edge(n2)\n n2.add_edge(n1)\n nodes[int(n1.name)], nodes[int(n2.name)] = n1, n2\n return nodes\n\n # 3. Determine number of trees and regroup by connected nodes\n def connected_nodes(nodes):\n proto_trees = []\n nodes = set(nodes)\n\n while nodes:\n n = nodes.pop()\n group = {n}\n queue = [n]\n while queue:\n n = queue.pop(0)\n neighbors = n.edges\n neighbors.difference_update(group)\n nodes.difference_update(neighbors)\n group.update(neighbors)\n queue.extend(neighbors)\n proto_trees.append(group)\n return proto_trees\n\n # 4. Convert nodes to nested dictionary of parent-children relations\n # i.e. adding depth -- also deals with tree-node sorting and path\n # optimization\n def build_tree_dict(trees, steps):\n # node sorting in trees\n sorted_trees = []\n for tree in trees:\n sorted_trees.append(\n sorted(tree, key=lambda x: int(x.name)))\n\n # retrieve values of the nodes (the protocol's containers)\n # for each tree ... may want to use dictionary eventually\n all_values = []\n for tree in sorted_trees:\n values = [steps[int(node.name)] for node in tree]\n all_values.append(values)\n\n # create relational tuples:\n all_digs = []\n singles = []\n dst_potentials = []\n for tree_idx in range(len(sorted_trees)):\n edge_flag = False\n tree_digs = []\n for node_idx in range(len(sorted_trees[tree_idx])):\n\n # digs: directed graph vectors\n digs = []\n dst_nodes = []\n node_values = all_values[tree_idx][node_idx]\n src_node = str(sorted_trees[tree_idx][node_idx].name)\n\n # ACTION ON MULTIPLE OBJECTS (E.G. TRANSFER FROM SRC -> DST\n # WELLS)\n # Outcome space: {1-1, 1-many, many-1, many-many}\n if len(node_values) == 2:\n # single destination (x-1)\n if node_values[1].count(\",\") == 0:\n dst_nodes = [i for i, sublist in enumerate(\n steps) if node_values[1] == sublist[0]]\n # multiple destinations (x-many)\n elif node_values[1].count(\",\") > 0:\n dst_nodes = []\n for dst in node_values[1].replace(\", \", \"\"):\n for i, sublist in enumerate(steps):\n if i not in dst_nodes and dst == sublist[0]:\n dst_nodes.append(i)\n\n # ACTION ON A SINGLE OBJECT\n elif len(node_values) == 1:\n dst_nodes = [i for i, sublist in enumerate(\n steps) if node_values[0] == sublist[0]]\n\n # Constructing tuples in (child, parent) format\n for dst_node in dst_nodes:\n dig = (int(dst_node), int(src_node))\n digs.append(dig)\n\n # else: an edge-case for dictionaries constructed with no edges\n # initiates tree separation via flag\n if digs != []:\n edge_flag = False\n tree_digs.append(digs)\n else:\n edge_flag = True\n digs = [(int(src_node), int(src_node))]\n tree_digs.append(digs)\n\n # digraph cycle detection: avoids cycles by overlooking set\n # repeats\n true_tree_digs = []\n for digs in tree_digs:\n for dig in digs:\n if tuple(sorted(dig, reverse=True)) not in true_tree_digs:\n true_tree_digs.append(\n tuple(sorted(dig, reverse=True)))\n\n # edge-case for dictionaries constructed with no edges\n if true_tree_digs != [] and edge_flag == False:\n all_digs.append(true_tree_digs)\n elif edge_flag == True:\n all_digs.extend(tree_digs)\n\n # Enforces forest ordering\n all_digs = sorted(all_digs, key=lambda x: x[0])\n\n # job tree traversal to find all paths:\n forest = []\n for digs_set in all_digs:\n\n # pass 1: initialize nodes dictionary\n nodes = OrderedDict()\n for tup in digs_set:\n id, parent_id = tup\n # ensure all nodes accounted for\n nodes[id] = OrderedDict({'id': id})\n nodes[parent_id] = OrderedDict({'id': parent_id})\n\n # pass 2: create trees and parent-child relations\n for tup in digs_set:\n id, parent_id = tup\n node = nodes[id]\n # links node to its parent\n if id != parent_id:\n # add new_node as child to parent\n parent = nodes[parent_id]\n if not 'children' in parent:\n # ensure parent has a 'children' field\n parent['children'] = []\n children = parent['children']\n children.append(node)\n\n desired_tree_idx = sorted(list(nodes.keys()))[0]\n forest.append(nodes[desired_tree_idx])\n return forest\n\n # 5. Convert dictionary-stored nodes to unflattened, nested list of\n # parent-children relations\n def dict_to_list(forest):\n forest_list = []\n for tree in forest:\n tString = str(json.dumps(tree))\n tString = tString.replace('\"id\": ', \"\").replace('\"children\": ', \"\").replace(\n '[{', \"[\").replace('}]', \"]\").replace('{', \"[\").replace('}', \"]\")\n\n # find largest repeated branch (if applicable)\n # maybe think about using prefix trees or SIMD extensions for better\n # efficiency\n x, y, length, match = 0, 0, 0, ''\n for y in range(len(tString)):\n for x in range(len(tString)):\n substring = tString[y:x]\n if len(list(re.finditer(re.escape(substring), tString))) > 1 and len(substring) > length:\n match = substring\n length = len(substring)\n\n # checking for legitimate branch repeat\n if \"[\" in match and \"]\" in match:\n hits = []\n index = 0\n if len(tString) > 3:\n while index < len(tString):\n index = tString.find(str(match), index)\n if index == -1:\n break\n hits.append(index)\n index += len(match)\n\n # find all locations of repeated branch and remove\n if len(hits) > 1:\n for start_loc in hits[1:]:\n tString = tString[:start_loc] + \\\n tString[start_loc:].replace(match, \"]\", 1)\n\n # increment all numbers in string to match the protocol\n newString = \"\"\n numString = \"\"\n for el in tString:\n if el.isdigit(): # build number\n numString += el\n else:\n if numString != \"\": # convert it to int and reinstantaite numString\n numString = str(int(numString) + 1)\n newString += numString\n newString += el\n numString = \"\"\n tString = newString\n del newString\n\n forest_list.append(ast.literal_eval(tString))\n return forest_list\n\n # 6. Print job tree(s)\n def print_tree(lst, level=0):\n print(' ' * (level - 1) + '+---' * (level > 0) + str(lst[0]))\n for l in lst[1:]:\n if type(l) is list:\n print_tree(l, level + 1)\n else:\n print(' ' * level + '+---' + l)\n\n # 1\n steps = depth_one(self.object_list)\n # 2\n nodes = assign_nodes(steps)\n # 3\n proto_forest = connected_nodes(nodes)\n # 4\n forest = build_tree_dict(proto_forest, steps)\n # 5\n self.forest_list = dict_to_list(forest)\n # 6\n print(\"\\n\" + \"A suggested Job Tree based on container dependency: \\n\")\n for tree_list in self.forest_list:\n print_tree(tree_list)","def all_routing_tree_2(G, tors1, tors2, table_file_name):\n \n table = OrderedDict({})\n for s in G.nodes():\n table[s] = OrderedDict({})\n for s in tors1:\n for d in tors2:\n if s != d:\n routing(G, s, d, table)\n for d in tors1:\n for s in tors2:\n if s != d:\n routing(G, s, d, table)\n\n with open(table_file_name, 'w') as file:\n file.write(json.dumps(table))\n return table","def build_tree(elements):\n print(\"Building tree with these elements:\",elements)\n root = BinarySearchTreeNode(elements[0])\n\n for i in range(1, len(elements)):\n root.add_child(elements[i])\n\n return root","def merge(list1, list2):\n holding = list1.to_list()\n [holding.append(i) for i in list2.to_list()]\n # for i in list2.to_list():\n # holding.append(i)\n holding = sorted(holding)\n\n output = LinkedList(Node(holding[0]))\n for i in holding[1:]:\n output.append(i)\n return output","def compare_nodes(n1, n2):\n return n1['g_val'] + n1['h_val'] < n2['g_val'] + n2['h_val']","def depth_node_ordering(start_node, end_nodes):\n ordered_list = []\n ordered_set = set()\n working_list = [start_node]\n while working_list != []:\n node = working_list.pop(0)\n if not node in ordered_set:\n ordered_set.add(node)\n ordered_list.append(node)\n if not is_leaf_node(node) and not node in end_nodes:\n for node_op in node.get_inputs():\n working_list.append(node_op)\n return ordered_list","def compare_nodes(n1, n2):\n if not isinstance(n1, dict):\n raise TypeError(\"Invalid n1! Expected dict, got %s instead\" %\n type(n1).__name__)\n if not isinstance(n2, dict):\n raise TypeError(\"Invalid n2! Expected dict, got %s instead\" %\n type(n2).__name__)\n\n if not Pharmacophore.check_node(n1):\n raise ValueError(\"Invalid n1!\")\n\n if not Pharmacophore.check_node(n2):\n raise ValueError(\"Invalid n2!\")\n\n c = n1[\"freq\"] + n2[\"freq\"]\n d1 = sum(n1[\"type\"].values())\n d2 = sum(n2[\"type\"].values())\n d = d1 + d2\n sim = 0.0\n t = {}\n\n for phar in PHARS:\n if phar in n1[\"type\"] and phar in n2[\"type\"]:\n sim += (n1[\"type\"][phar] + n2[\"type\"][phar]) / d\n t[phar] = n1[\"type\"][phar] + n2[\"type\"][phar]\n elif phar in n1[\"type\"]:\n t[phar] = n1[\"type\"][phar]\n elif phar in n2[\"type\"]:\n t[phar] = n2[\"type\"][phar]\n return sim * c, t","def create_nodes(self, articles, merges):\n # self.all_nodes = [RealNode(a) for a in articles]\n if merges is None:\n for article in articles:\n matching_layer = self.find_layer_by_name(article[\"year\"])\n matching_layer.create_node(article)\n else:\n for merge in merges:\n art1 = next(x for x in articles if x['key'] == merge['art1'])\n art2 = next(x for x in articles if x['key'] == merge['art2'])\n if 'art3' in merge:\n art3 = next(x for x in articles if x['key'] == merge['art3'])\n matching_layer = self.find_layer_by_name(art1['year'])\n merge_key = art1['key'] + art2['key']\n merge_dict = {'key': merge_key, 'year': matching_layer.name, 'art1': art1, 'art2': art2, 'merge': merge}\n if 'art3' in merge:\n merge_key += art3['key']\n merge_dict = {'key': merge_key, 'year': matching_layer.name, 'art1': art1, 'art2': art2, 'art3': art3, 'merge': merge}\n new_node = matching_layer.create_node(merge_dict)\n new_node.kind = \"Merge\"\n for article in articles:\n merge_art = False\n for merge in merges:\n if article['key'] == merge['art1'] or article['key'] == merge['art2'] or \\\n ('art3' in merge and article['key'] == merge['art3']):\n merge_art = True\n break\n if not merge_art:\n matching_layer = self.find_layer_by_name(article[\"year\"])\n matching_layer.create_node(article)","def generate_tree(sp_root=0, num_nodes=7):\n # generate tree\n tree = dict()\n tree_lc = dict()\n tree_rc = dict()\n tree[sp_root] = None\n queue = [sp_root]\n available_id = 0\n\n while True:\n curr_node = queue.pop(0)\n lc = available_id + 1\n if lc == num_nodes:\n break\n rc = available_id + 2\n if rc == num_nodes:\n break\n tree_lc[curr_node] = lc\n tree_rc[curr_node] = rc\n tree[lc] = curr_node\n tree[rc] = curr_node\n available_id += 2\n queue.append(lc)\n queue.append(rc)\n if len(tree) == num_nodes:\n break\n return tree, tree_lc, tree_rc","def Trees__LCA_LowestCommonDenominator():\n # Python2 ported to Python3 via 2to3-3.7\n # URL:# URL:https://www.hackerrank.com/challenges/binary-search-tree-lowest-common-ancestor/problem\n '''\n class Node:\n def __init__(self,info): \n self.info = info \n self.left = None \n self.right = None \n // this is a node of the tree , which contains info as data, left , right\n '''\n def lca(root, v1, v2):\n # Find a and b. Link child nodes to parent to be able to backtrack.\n # (1) Note, we add 'parent' attribute to node dynamically via node.parent = ...\n root.parent = None\n node_stack = []\n node_stack.append(root)\n v1_node, v2_node = None, None\n while node_stack:\n node = node_stack.pop()\n if not v1_node and node.info == v1:\n v1_node = node\n if not v2_node and node.info == v2:\n v2_node = node\n for child_node in [node.left, node.right]:\n if child_node:\n child_node.parent = node # (1)\n node_stack.append(child_node)\n\n # Generate path from A to root.\n curr = v1_node\n a_to_root = set()\n while curr:\n a_to_root.add(curr.info)\n curr = curr.parent\n\n # traverse up b until you come across an element in a's path to parent.\n curr = v2_node\n while curr:\n if curr.info in a_to_root:\n return curr\n else:\n curr = curr.parent\n\n print(\"Shouldn't be here, Something went wrong\")\n\n # # Recursive. (Iterative is better, but did recursive for practice.) ~15 min.\n # # Main idea is that we count the number of v1/v2's found of the subnodes.\n # # If a node has sum of 2, we know it's the lca.\n # def lca(root, v1, v2):\n # def lca_helper(node):\n # ret_node = None\n # if not node:\n # return 0, None\n # v_match_counter = 0\n # if node.info in [v1, v2]:\n # v_match_counter += 1\n # left_count, left_node_ret = lca_helper(node.left)\n # right_count, right_node_ret = lca_helper(node.right)\n # v_match_counter += left_count + right_count\n # if v_match_counter == 2:\n # ret_node = node\n # if left_node_ret:\n # ret_node = left_node_ret\n # if right_node_ret:\n # ret_node = right_node_ret\n # return v_match_counter, ret_node\n\n # _, node = lca_helper(root)\n # return node","def _connect_nodes(self, node_deque):\r\n # Case where there is only 1 node in the test\r\n if len(node_deque) == 1:\r\n child = node_deque.pop()\r\n # create root for only child\r\n root = Node()\r\n root.set_freq_value(1)\r\n root.set_left_child(child)\r\n return root\r\n\r\n while len(node_deque) > 1:\r\n first_tree = node_deque.popleft()\r\n second_tree = node_deque.popleft()\r\n # The first tree is getting to big so start another\r\n if first_tree.get_freq_value() > second_tree.get_freq_value():\r\n node_deque.append(first_tree)\r\n first_tree = node_deque.popleft()\r\n # A parent node for the two children\r\n tree_node = Node()\r\n\r\n tree_node.set_left_child(first_tree)\r\n tree_node.set_right_child(second_tree)\r\n\r\n # Add the two child frequency values to the parent node value\r\n total_freq = tree_node.get_left_child().get_freq_value() + tree_node.get_right_child().get_freq_value()\r\n tree_node.set_freq_value(total_freq)\r\n node_deque.appendleft(tree_node)\r\n\r\n return node_deque.pop()","def test_tree_intersection_on_challenge_example(first_example, second_example):\n expected = [500, 350, 200, 175, 160, 125, 100]\n actual = tree_intersection(first_example, second_example)\n assert expected == actual","def build_match_tree(abbreviation_list):\n match_tree = {}\n for word, abbreviation in abbreviation_list:\n tree_node = match_tree\n for letter in word[:-1]:\n if letter not in tree_node:\n tree_node[letter] = {}\n tree_node = tree_node[letter]\n tree_node[word[-1]] = abbreviation\n return match_tree","def test_1(self):\r\n r1, r2, r5 = MyVariable(1), MyVariable(2), MyVariable(5)\r\n o = MyOp.make_node(r1, r1)\r\n o2 = MyOp.make_node(o.outputs[0], r5)\r\n all = general_toposort(o2.outputs, prenode)\r\n assert all == [r5, r1, o, o.outputs[0], o2, o2.outputs[0]]","def build_tree_from_ordered(input, tree=None):\n\n if len(input) == 0:\n return tree\n if len(input) == 1:\n tree = BSTNode(input[0])\n return tree\n\n middle_pos = int(len(input) / 2)\n right_tree = input[:middle_pos - 1]\n left_tree = input[middle_pos + 1:]\n actual_node = input[middle_pos - 1:middle_pos][0]\n\n # insert tree node\n if tree is None:\n tree = BSTNode(actual_node)\n else:\n tree.value = actual_node\n tree.right = build_tree_from_ordered(right_tree, tree=tree.right)\n tree.left = build_tree_from_ordered(left_tree, tree=tree.left)\n\n return tree","def test_collision(quadtree1, quadtree2, shift1, shift2, stay_away):\r\n\r\n r1, r2 = quadtree1.root, quadtree2.root\r\n\r\n if (not r1) or (not r2):\r\n return False\r\n\r\n stack = [(r1, r2)]\r\n\r\n while stack:\r\n p1, p2 = stack.pop() # the nodes of the 1st and the 2nd trees\r\n\r\n if not rectangles_intersect(p1.value, p2.value, shift1, shift2, stay_away):\r\n # if larger rectangles do not collide, their children will not collide either\r\n # hence no need to go for sub-nodes\r\n continue\r\n\r\n if p1.is_leaf() and p2.is_leaf():\r\n # leaves collide, we're done\r\n return True\r\n\r\n c1, c2 = p1.get_children_list(), p2.get_children_list()\r\n\r\n if not c1:\r\n for x in c2:\r\n stack.append((p1, x))\r\n else:\r\n if not c2:\r\n for x in c1:\r\n stack.append((x, p2))\r\n else:\r\n # none are empty, i.e. the nodes are not leaves\r\n for x in c1:\r\n for y in c2:\r\n stack.append((x, y))\r\n\r\n return False","def test_tree_support(self):\r\n master_tree = parse_newick('((a:2,b:3)ab:2,(c:1,d:2)cd:7)rt;')\r\n \"\"\"\r\n /-------.5 /-a\r\n ---1| \\-b\r\n \\------.5 /-c\r\n \\-d\r\n \"\"\"\r\n t2 = parse_newick('((a:2,b:3,c:33)ho:2,d:7);') # abc are siblings\r\n\r\n tc.tree_support(master_tree, t2)\r\n assert_almost_equal(\r\n master_tree.getNodeMatchingName('rt').bootstrap_support, 1.0)","def recoverTree1(self, root: Optional[TreeNode]) -> None:\n self.traverseTree(root)\n def find_two_swapped(nums: List[int]) -> (int, int):\n length = len(nums)\n for i in range(length - 1, 0, -1):\n if nums[i] < nums[i - 1]:\n j = i - 1\n while j >=0 and nums[j] > nums[i]:\n j -= 1\n return nums[i], nums[j + 1]\n a, b = find_two_swapped(self.arr)\n\n self.nodeMap[a].val = b\n self.nodeMap[b].val = a","def linear_merge(sorted1, sorted2):\n first_pointer = 0\n second_pointer = 0\n sorted_result = []\n\n while second_pointer < len(sorted2) and first_pointer < len(sorted1):\n if sorted1[first_pointer] < sorted2[second_pointer]:\n sorted_result.append(sorted1[first_pointer])\n first_pointer += 1\n else:\n sorted_result.append(sorted2[second_pointer])\n second_pointer += 1\n\n while second_pointer < len(sorted2):\n sorted_result.append(sorted2[second_pointer])\n second_pointer += 1\n\n while first_pointer < len(sorted1):\n sorted_result.append(sorted1[first_pointer])\n first_pointer += 1\n\n\n return sorted_result","def compare_branch_lengths(tree1, tree2):\n stack = [] # stack to store nodes in tree2\n\n for count, node in enumerate(tree1.postorder(include_self=False)):\n if node.is_tip():\n try:\n cur = tree2.find(node.name)\n except MissingNodeError:\n return False\n else:\n if node.id == stack[-1].id:\n cur = stack.pop()\n else:\n return False\n\n if _compare_length(node, cur) is False:\n return False\n if node.parent.id is None and cur.parent.id is None:\n cur.parent.id = node.parent.id = str(count)\n elif (node.parent.id is not None) ^ (cur.parent.id is not None):\n return False\n if cur.parent not in stack:\n stack.append(cur.parent)\n return True","def add_nodes_as_trees(self,\n nodes: Nodes,\n tree_ids: List[int] = None,\n group_ids: List[int] = None,\n names: List[str] = None,\n colors: List[Tuple[float, float, float, float]] = None):\n\n if tree_ids is None:\n tree_id_start = self.max_tree_id() + 1\n tree_id_end = tree_id_start + len(nodes)\n tree_ids = list(range(tree_id_start, tree_id_end))\n\n if group_ids is None:\n group_ids = [None for x in range(len(nodes))]\n\n if names is None:\n names = ['' for x in range(len(nodes))]\n\n if colors is None:\n colors = [(0.0, 0.0, 0.0, 1.0) for x in range(len(nodes))]\n\n for node_idx, _ in nodes.iterrows():\n self.add_tree(\n nodes=nodes[node_idx:node_idx+1],\n tree_id=tree_ids[node_idx],\n group_id=group_ids[node_idx],\n name=names[node_idx],\n color=colors[node_idx]\n )","def test_sort_chain_multiple_reuse():\n data = [-10, 42, 8, 64, -6, 76, 48, 8, -30, 1, 11, 92, 37, 4]\n chain = None\n for item in data:\n chain = N.Node(item, chain)\n\n id_record = {}\n walker = chain\n while walker is not None:\n id_record[id(walker)] = walker.data\n walker = walker.next\n\n result = A8.sort_chain(chain)\n\n walker = result\n while walker is not None:\n assert id(walker) in id_record, \"sort_chain created new node\"\n assert id_record[id(walker)] == walker.data, \"sort_chain moved data value {} to new node\".format(walker.data)\n walker = walker.next","def __align_rings(p1, p2, n1, n2, idx1, idx2, mapping=None, dist1=None,\n dist2=None, dist_tol=0):\n\n assert len(n1) == len(n2), \"wrong n1 or n2\"\n\n if mapping is None:\n mapping = np.zeros((p1.numnodes, p2.numnodes))\n\n for i in range(p1.numnodes):\n for j in range(p2.numnodes):\n weighted_freq, _ = compare_nodes(p1.nodes[i], p2.nodes[j])\n if weighted_freq > 0.0:\n mapping[i][j] = weighted_freq\n\n if dist1 is None:\n dist1 = distances(p1)\n dist1[p1.edges > 0] = p1.edges[p1.edges > 0]\n\n if dist2 is None:\n dist2 = distances(p2)\n dist2[p2.edges > 0] = p2.edges[p2.edges > 0]\n\n # create modular product of graph using alignment as constraints\n nodes = []\n scores = []\n\n assert len(idx1) == len(idx2), \"unequal subgraphs sizes\"\n old_len = len(idx1)\n\n for i in range(old_len):\n weighted_freq = mapping[idx1[i], idx2[i]]\n assert weighted_freq > 0, \"wrong alignment given\"\n nodes.append({\"n1\": idx1[i], \"n2\": idx2[i]})\n scores.append(weighted_freq)\n\n for i in range(len(n1)):\n possible_matches = np.where(mapping[n1[i], :][:, n2[i]] > 0)\n pairs1 = n1[i][possible_matches[0]]\n pairs2 = n2[i][possible_matches[1]]\n if len(idx1) > 0:\n # find pairs compatible with given alignment\n d1 = dist1[pairs1, :][:, idx1]\n d2 = dist2[pairs2, :][:, idx2]\n compatible = np.where(np.all(np.abs(d1 - d2) <= dist_tol,\n axis=1))[0]\n else:\n # empty alignment given, accept everything\n compatible = np.array(list(range(len(pairs1))))\n\n for i in compatible:\n weighted_freq = mapping[pairs1[i], pairs2[i]]\n assert weighted_freq > 0, \"wrong possible matches\"\n nodes.append({\"n1\": pairs1[i], \"n2\": pairs2[i]})\n scores.append(weighted_freq)\n\n scores = np.array(scores)\n\n n = len(nodes)\n edges = np.zeros((n, n))\n costs = np.zeros((n, n))\n\n for i in range(n):\n for j in range(i):\n if nodes[i][\"n1\"] == nodes[j][\"n1\"] or \\\n nodes[i][\"n2\"] == nodes[j][\"n2\"]:\n continue\n\n is_connected = False\n\n if p1.edges[nodes[i][\"n1\"], nodes[j][\"n1\"]] > 0:\n is_connected = True\n d1 = dist1[nodes[i][\"n1\"], nodes[j][\"n1\"]]\n\n if p2.edges[nodes[i][\"n2\"], nodes[j][\"n2\"]] > 0:\n is_connected = True\n d2 = dist2[nodes[i][\"n2\"], nodes[j][\"n2\"]]\n\n if math.fabs(d1 - d2) <= dist_tol:\n if is_connected:\n costs[i, j] = costs[j, i] = math.fabs(d1 - d2)\n edges[i, j] = edges[j, i] = 1.0\n\n alignment = list(range(old_len))\n score = np.sum(scores[alignment])\n cost = np.sum(costs[alignment, :][:, alignment]) / 2\n scorecost = score-cost\n\n for clique in __BronKerbosch(edges):\n clique = list(clique)\n s = np.sum(scores[clique])\n c = np.sum(costs[clique, :][:, clique]) / 2\n\n if (s - c > scorecost) or (s - c == scorecost and s > score):\n idx1 = []\n idx2 = []\n n1 = []\n n2 = []\n score = s\n cost = c\n scorecost = s - c\n\n for pair in clique:\n idx1.append(nodes[pair][\"n1\"])\n idx2.append(nodes[pair][\"n2\"])\n return score, cost, [idx1, idx2]","def make_tree(self, strings):\n # start from tree root\n root = self.tree()\n # mark if letter is the end of string or just its part\n root['end'] = set()\n root['part'] = set(self.s_options_total)\n for idx, string in enumerate(strings):\n node = root\n for letter in string:\n new_node = node[letter]\n new_node.setdefault('end', set())\n new_node.setdefault('part', set()).add(idx)\n node = new_node\n node['end'].add(idx)\n node['part'].remove(idx)\n\n return root","def solve(self):\n self.a_tree = self.make_tree(self.a_strings)\n self.b_tree = self.make_tree(self.b_strings)\n\n # apply prefix filter\n self.s_options_for_beginning = self.prefix_filter()\n if len(self.s_options_for_beginning) == 0:\n self.final_sequence = 'IMPOSSIBLE'\n return\n\n # apply postfix filter\n self.s_options_for_ending = self.postfix_filter()\n if len(self.s_options_for_ending) == 0:\n self.final_sequence = 'IMPOSSIBLE'\n return\n\n # apply length balance filter (on the result after prefix and postfix filter)\n self.s_combinations_by_length = self.length_balance_filter(self.s_options_for_beginning,\n self.s_options_for_ending)\n if len(self.s_combinations_by_length) == 0:\n self.final_sequence = 'IMPOSSIBLE'\n return\n\n # apple elements balance filter (on the result after length balance filter)\n self.s_combinations_by_elements = self.elements_balance_filter(self.s_combinations_by_length)\n if len(self.s_combinations_by_elements) == 0:\n self.final_sequence = 'IMPOSSIBLE'\n return\n\n # sort filtered combinations by its elements length in ascending order\n self.s_combinations_filtered = sorted(self.s_combinations_by_elements.items())\n\n # for each combinations length try to find the lexicographically shortest sequence using depth-first search\n for length, combinations in self.s_combinations_filtered:\n for combination in combinations:\n self.combination = combination\n self.dfs()\n\n # return sequence as soon as we got one\n if self.final_sequence:\n return\n\n # otherwise - return 'IMPOSSIBLE'\n if not self.final_sequence:\n self.final_sequence = 'IMPOSSIBLE'\n return","def substructure_sim_partial(subtrees_1, subtrees_2):\n assert(len(subtrees_1) == len(subtrees_2))\n n = len(subtrees_1)\n f1 = np.zeros(n)\n f2 = np.zeros(n)\n for i in range(n):\n if (subtrees_1[i] == subtrees_2[i]): # exact match, or both are dropped\n f1[i] = 1.0\n f2[i] = 1.0\n else: # partial match\n f1[i] = SubstructureAgreement.save_div( len(subtrees_1[i].intersection(subtrees_2[i])), float(len(subtrees_2[i])))\n f2[i] = SubstructureAgreement.save_div( len(subtrees_2[i].intersection(subtrees_1[i])), float(len(subtrees_1[i])))\n\n return (np.sum(f1) + np.sum(f2)) / (2.0 * float(n)) # average of average recall","def dist_tree(self, other, tol=1e-8):\n if self.ndim == 2:\n from pyparm import d2 as sim\n else:\n from pyparm import d3 as sim\n\n assert self.ndim == other.ndim\n\n if self.shear != 0 or other.shear != 0:\n assert np.abs(self.shear - other.shear) <= tol\n shear = (self.shear + other.shear) / 2.0\n box = sim.LeesEdwardsBox(sim.Vec(1, 1), shear)\n else:\n box = sim.OriginBox(1.0)\n\n sz1 = self.size_indices()\n assert(len(sz1) == 2)\n cutoff1 = int(np.sum(sz1[0]))\n\n sz2 = other.size_indices()\n assert(len(sz2) == 2)\n cutoff2 = int(np.sum(sz2[0]))\n\n vs1 = np.array([xy for idx in sz1 for xy in self.rs[idx]])\n vs2 = np.array([xy for idx in sz2 for xy in other.rs[idx]])\n\n tree = sim.JammingTreeBD(box, vs1, vs2, cutoff1, cutoff2)\n return tree","def PickSeeds(self, leaf1, leaf2):\n d = 0\n t1 = 0\n t2 = 0\n\n # iter all possible children nodes, to find the max difference.\n for i in range(len(self.leaves)):\n for j in range(i + 1, len(self.leaves)):\n MBR_new = merge(self.leaves[i].MBR, self.leaves[j].MBR)\n S_new = 1.0 * (MBR_new['xmax'] - MBR_new['xmin']) * (MBR_new['ymax'] - MBR_new['ymin'])\n S1 = 1.0 * (self.leaves[i].MBR['xmax'] - self.leaves[i].MBR['xmin']) * (\n self.leaves[i].MBR['ymax'] - self.leaves[i].MBR['ymin'])\n S2 = 1.0 * (self.leaves[j].MBR['xmax'] - self.leaves[j].MBR['xmin']) * (\n self.leaves[j].MBR['ymax'] - self.leaves[j].MBR['ymin'])\n if S_new - S1 - S2 > d:\n t1 = i\n t2 = j\n d = S_new - S1 - S2\n n2 = self.leaves.pop(t2)\n n2.father = leaf1\n leaf1.leaves.append(n2)\n leaf1.MBR = leaf1.leaves[0].MBR\n n1 = self.leaves.pop(t1)\n n1.father = leaf2\n leaf2.leaves.append(n1)\n leaf2.MBR = leaf2.leaves[0].MBR","def combine(a, b):\n newnode = None\n # not sure what to do if comes_before is false\n if a.char < b.char:\n newchar = a.char\n else:\n newchar = b.char\n newfreq = a.freq + b.freq\n newnode = HuffmanNode(newchar, newfreq)\n newnode.left = a\n newnode.right = b\n return newnode","def MatchMatrixs (self,Node1,Node2):\n\n T1Native_Node = Node1\n T1Native_Matrix = slicer.util.arrayFromVolume(T1Native_Node)\n DimN = T1Native_Matrix.shape\n T1Enhanced_Node = Node2\n T1Enhanced_Matrix = slicer.util.arrayFromVolume(T1Enhanced_Node)\n DimE = T1Enhanced_Matrix.shape\n\n NMatrix = self.GetIJKToRASnpArray(T1Native_Node)\n NVector = NMatrix[:-1,-1]\n EMatrix = self.GetIJKToRASnpArray(T1Enhanced_Node)\n EVector = EMatrix[:-1,-1]\n NPixelSize = [np.linalg.norm(NMatrix[:-1,0]), np.linalg.norm(NMatrix[:-1,1])]\n EPixelSize = [np.linalg.norm(EMatrix[:-1,0]), np.linalg.norm(EMatrix[:-1,1])]\n\n Niversor = NMatrix[:-1,0]/NPixelSize[0]\n Njversor = NMatrix[:-1,1]/NPixelSize[1]\n Nkversor = np.round(np.cross(Niversor,Njversor),3)\n Nkstep = round(np.linalg.norm(NMatrix[:-1,2]),3)\n\n Eiversor = EMatrix[:-1,0]/EPixelSize[0]\n Ejversor = EMatrix[:-1,1]/EPixelSize[1]\n Ekversor = np.round(np.cross(Eiversor,Ejversor),3)\n Ekstep = round(np.linalg.norm(EMatrix[:-1,2]),3)\n print(Nkversor,Ekversor,Nkstep,Ekstep,NVector,EVector,(NVector-EVector).dot(Ekversor))\n if not ( np.sum(Nkversor==Ekversor) == 3 and Nkstep==Ekstep and ((NVector-EVector).dot(Ekversor)) == 0 ): # it verifies if the slices are oriented in the same direction, with the same step between slices and if the first images are complanar.\n slicer.util.warningDisplay('The geometry of the LL Native and LL Enhanced volume doesn\\'t match. It could deteriorate the ECV map', windowTitle= 'Warning')\n\n if (DimE == DimN):\n T1_ECVMappingLogic.setupNodeFromNode(self,self.ECVMapNode , self.NativeT1_Selector.currentNode()) \n return [T1Native_Matrix,T1Enhanced_Matrix]\n if (DimE[1:3] == DimN[1:3]):\n k = min([DimE[1],DimN[1]])\n T1_ECVMappingLogic.setupNodeFromNode(self,self.ECVMapNode , self.NativeT1_Selector.currentNode())\n return [T1Native_Matrix[:k,:,:],T1Enhanced_Matrix[:k,:,:]]\n\n jN = np.arange(0,DimN[2]*NPixelSize[1],NPixelSize[1])+NPixelSize[1]/2+(NVector-EVector).dot(Njversor)\n iN = np.arange(0,DimN[1]*NPixelSize[0],NPixelSize[0])+NPixelSize[0]/2+(NVector-EVector).dot(Niversor)\n iE = np.arange(0,DimE[1]*EPixelSize[0],EPixelSize[0])+EPixelSize[0]/2\n jE = np.arange(0,DimE[2]*EPixelSize[1],EPixelSize[1])+EPixelSize[1]/2 \n if DimE[1] > DimN[1]: ## I concidered a square image\n T1Nreshaped = np.zeros(DimE)\n for k in range(DimN[0]):\n f = interpolate.interp2d(iN, jN, np.nan_to_num(T1Native_Matrix[k,:,:]), fill_value = 0)\n T1Nreshaped[k,:,:] = f(iE, jE)\n T1Ereshaped = T1Enhanced_Matrix[:k+1,:,:]\n T1_ECVMappingLogic.setupNodeFromNode(self,self.ECVMapNode , self.EnhancedT1_Selector.currentNode())\n return [T1Nreshaped,T1Ereshaped]\n else:\n T1Ereshaped = np.zeros(DimN)\n for k in range(DimE[0]):\n f = interpolate.interp2d(iE, jE, np.nan_to_num(T1Enhanced_Matrix[k,:,:]), fill_value = 0)\n T1Ereshaped[k,:,:] = f(iN, jN) \n T1Nreshaped = T1Native_Matrix[:k+1,:,:]\n T1_ECVMappingLogic.setupNodeFromNode(self,self.ECVMapNode , self.NativeT1_Selector.currentNode()) \n return [T1Nreshaped,T1Ereshaped]","def topologicalSort(self, nodes: List[int], prerequisites: List[List[int]]) -> List[int]:\n # graph\n # prep: x ->requires set(y1, y2, ..), before take x need y1, y2, .., takes count only\n # post: y ->followup set(x1, x2, ..), \n # after take y, it is possible (only possible may not, as x_i might need others) x1, x2, ..\n prep = defaultdict(lambda: 0)\n post = defaultdict(set)\n for x, y in prerequisites:\n prep[x] += 1\n post[y].add(x)\n # schedule\n # start with all nodes requires no prerequisites\n schedule, boundary = [], [x for x in nodes if x not in prep]\n while boundary:\n y = boundary.pop()\n schedule.append(y)\n if y in post:\n xs = post.pop(y)\n for x in xs:\n prep[x] -= 1\n # all prerequisites of x are cleared \n if prep[x] == 0:\n prep.pop(x)\n boundary.append(x)\n # some nodes are impossible to complete?\n if prep:\n return []\n return schedule","def build_tree(tree_list, nums):\n\n if len(nums) == 0:\n return tree_list\n next_list = []\n j = 0\n for i in tree_list:\n for _ in range(2):\n if i is not None and j < len(nums):\n if nums[j] is None:\n next_list.append(None)\n else:\n next_list.append(TreeNode(nums[j]))\n j += 1\n res_list = build_tree(next_list, nums[j:])\n j = 0\n for i in tree_list:\n if i is None:\n continue\n if j < len(res_list):\n if next_list[j] is not None:\n next_list[j].parent = i\n i.left = next_list[j]\n j += 1\n if j < len(res_list):\n if next_list[j] is not None:\n next_list[j].parent = i\n i.right = next_list[j]\n j += 1\n return tree_list"],"string":"[\n \"def find_longest_matches(sorted_nodes1, sorted_nodes2):\\n root = TreeNode(-1,-1)\\n fill_tree(root, sorted_nodes1, sorted_nodes2)\\n match = find_treepaths(root, [])\\n\\n # Remove (-1, -1) superroot.\\n if isinstance(match[0], list): # More than one match of the same length.\\n res = []\\n for m in match:\\n res.append([node.to_tuple() for node in m[1:]])\\n return res\\n else:\\n return [[node.to_tuple() for node in match[1:]]]\",\n \"def construct_trees(self, nodes):\\n trees = {}\\n for root in tqdm.tqdm(nodes):\\n # note that nodes is an uniquely ordered set\\n # tree = {0: {0 : [nb_1, nb_2, ..., nb_k], nb_1: [0, ...]}, 1 : {1: [nb_1,...], nb_1 : [..]},...}\\n trees[root] = {}\\n trees[root][root] = [root]\\n # print('test...', trees[root][root])\\n used_nodes = set()\\n # queue has the form as following queue([root] for root in tqdm.tqdm(nodes)\\n # with each node, we construct the tree rooted at that node, denoted as queue(['root'])\\n queue = collections.deque([root]) # deque([0]) -> deque([0,1])\\n while len(queue) > 0:\\n cur_node = queue.popleft()\\n used_nodes.add(cur_node)\\n for sub_node in self.graph[cur_node]:\\n # sub_node is not ordered\\n if sub_node not in used_nodes:\\n trees[root][cur_node].append(sub_node)\\n trees[root][sub_node] = [cur_node]\\n queue.append(sub_node)\\n used_nodes.add(sub_node)\\n return trees\",\n \"def test_compare_old_to_new_method_to_create_trees(self):\\n nodes = util.generate_sequence_of_points(2, 2)\\n tree1 = kdtree.createNewTree(nodes)\\n kdtree.visualize(tree1)\\n \\n sel_axis = (lambda axis: axis)\\n tree2 = kdtree.createNewTree([[0.5, 0.5]],axis = 0, sel_axis= sel_axis)\\n tree2.split2([0.25, 0.5], axis = 1)\\n tree2.split2([0.75, 0.5], axis = 1)\\n \\n #left\\n tree2.split2([0.25, 0.25], axis = 0, sel_axis = sel_axis)\\n tree2.split2([0.25, 0.75], axis = 0, sel_axis = sel_axis)\\n \\n #right\\n tree2.split2([0.75, 0.25], axis = 0, sel_axis = sel_axis)\\n tree2.split2([0.75, 0.75], axis = 0, sel_axis = sel_axis)\\n \\n kdtree.visualize(tree2)\\n \\n for n in zip(kdtree.level_order(tree1), kdtree.level_order(tree2)):\\n self.assertEqual(n[0].data, n[1].data, \\\"elements not equal\\\")\\n \\n if n[0].data is not None and n[1].data is not None:\\n self.assertEqual(n[0].axis, n[1].axis, \\\"elements not equal\\\")\",\n \"def join_nodes_in_both_trees(tree1, nodeAinT1, cladeA,\\n tree2, nodeBinT2, cladeB, test=False):\\n cladeA = set(cladeA)\\n cladeB = set(cladeB)\\n leaves1 = get_leaf_set(tree1)\\n leaves2 = get_leaf_set(tree2)\\n\\n cladeAisT1 = leaves1 == cladeA\\n cladeBisT2 = leaves2 == cladeB\\n\\n # Handle adding all of tree1 into tree 2 and vice versa!!\\n if cladeAisT1 and cladeBisT2:\\n # Done\\n print(\\\"Nodes are tree1 and tree2...\\\")\\n if test:\\n return [None, None]\\n root = dendropy.Node()\\n root.add_child(nodeAinT1)\\n root.add_child(nodeBinT2)\\n tree1 = dendropy.Tree(seed_node=root)\\n tree1.is_rooted = True\\n tree2 = None\\n elif cladeAisT1:\\n # Add all of tree 1 into tree 2\\n print(\\\"Add all of tree 1 into tree 2\\\")\\n if test:\\n return [None, None]\\n [tree2, nodeBinT2] = extract_nodes_from_split(tree2, nodeBinT2,\\n cladeB)\\n root = dendropy.Node()\\n root.add_child(nodeAinT1)\\n root.add_child(tree2.seed_node)\\n tree1 = dendropy.Tree(seed_node=root)\\n tree1.is_rooted = True\\n tree2 = None\\n elif cladeBisT2:\\n # Add all of tree 2 into tree 1\\n print(\\\"Add all of tree 2 into tree 1\\\")\\n if test:\\n return [None, None]\\n [tree1, nodeAinT1] = extract_nodes_from_split(tree1, nodeAinT1,\\n cladeA)\\n root = dendropy.Node()\\n root.add_child(tree1.seed_node)\\n root.add_child(nodeBinT2)\\n tree1 = dendropy.Tree(seed_node=root)\\n tree1.is_rooted = True\\n tree2 = None\\n else:\\n # Make the join!\\n print(\\\"Making join...\\\")\\n [tree1, nodeAinT1] = extract_nodes_from_split(tree1, nodeAinT1,\\n cladeA)\\n [tree2, nodeBinT2] = extract_nodes_from_split(tree2, nodeBinT2,\\n cladeB)\\n\\n root1 = dendropy.Node()\\n root1.add_child(tree1.seed_node)\\n root1.add_child(deepcopy(nodeBinT2)) # TODO: Remove deep copies!\\n tree1 = dendropy.Tree(seed_node=root1)\\n tree1.is_rooted = True\\n\\n root2 = dendropy.Node()\\n root2.add_child(tree2.seed_node)\\n root2.add_child(deepcopy(nodeAinT1)) # TODO: Remove deep copies!\\n tree2 = dendropy.Tree(seed_node=root2)\\n tree2.is_rooted = True\\n\\n return [tree1, tree2]\",\n \"def join_nodes_in_one_tree(tree1, nodeAinT1, cladeA, tree2, nodeBinT2,\\n cladeB):\\n [tree1, nodeAinT1] = extract_nodes_from_split(tree1, nodeAinT1, cladeA)\\n [tree2, nodeBinT2] = extract_nodes_from_split(tree2, nodeBinT2, cladeB)\\n\\n root = dendropy.Node()\\n root.add_child(deepcopy(nodeAinT1)) # TODO: Remove deep copies!\\n root.add_child(tree2.seed_node)\\n tree2 = dendropy.Tree(seed_node=root)\\n tree2.is_rooted = True\\n\\n return [tree1, tree2]\",\n \"def compare_nodes(G,all_match_pairs,match_pair,traversed,node1,node2, ports_weight):\\n logger.debug(f\\\"comparing {node1},{node2}, traversed {traversed}\\\")\\n nbrs1 = sorted(set(G.neighbors(node1)) - set(traversed))\\n #remove dummies\\n nbrs1 = sorted(set([nbr for nbr in nbrs1 if G.get_edge_data(node1, nbr)['weight'] !=7]))\\n nbrs2 = sorted(set(G.neighbors(node2)) - set(traversed))\\n #remove dummies\\n nbrs2 = sorted(set([nbr for nbr in nbrs2 if G.get_edge_data(node2, nbr)['weight'] !=7]))\\n logger.debug(f\\\"node1:{node1},property: {G.nodes[node1]},neigbors1: {nbrs1}\\\")\\n logger.debug(f\\\"node2:{node2},property: {G.nodes[node2]},neigbors2: {nbrs2}\\\")\\n if not nbrs1 or not nbrs2:\\n if compare_two_nodes(G, node1, node2, ports_weight):\\n match_pair[node1] = node2\\n logger.debug(f\\\"no new neihbours, returning recursion {match_pair}\\\")\\n return\\n elif len(nbrs1)> 10:\\n if \\\"start_point\\\" in match_pair.keys():\\n match_pair[\\\"start_point\\\"]+=[node1,node2]\\n else:\\n match_pair[\\\"start_point\\\"]=[node1,node2]\\n logger.debug(f\\\"skipping high fanout nets due to large computation, {node1} {nbrs1}\\\")\\n traversed.append(node1)\\n return\\n elif len(nbrs2)> 10:\\n if \\\"start_point\\\" in match_pair.keys():\\n match_pair[\\\"start_point\\\"]+=[node1,node2]\\n else:\\n match_pair[\\\"start_point\\\"]=[node1,node2]\\n traversed.append(node2)\\n logger.debug(f\\\"skipping high fanout nets due to large computation, {node2} {nbrs2}\\\")\\n return\\n\\n if node1 == node2:\\n if node1 in match_pair.keys() or node1 in match_pair.values():\\n logger.debug(\\\"avoid existing pair wise symmetry\\\")\\n return\\n logger.debug(f\\\"single node {node1}, nbrs {nbrs1}, nbr_weight {[G.get_edge_data(node1,nbr) for nbr in nbrs1]}\\\")\\n SD_nbrs= [nbr for nbr in nbrs1 if G.get_edge_data(node1, nbr)['weight'] !=2]\\n ## TBD: filter based on primitive constraints\\n ## Right now will try to figure out S/D paths\\n if len(SD_nbrs) ==0:\\n logger.debug(f\\\"No SD paths found to traverse\\\")\\n match_pair[node1]=node1\\n elif len(SD_nbrs) ==1:\\n logger.debug(f\\\"traversing single S/D path {SD_nbrs}\\\")\\n match_pair[node1]=node1\\n traversed.append(node1)\\n compare_nodes(G,all_match_pairs,match_pair,traversed,SD_nbrs[0],SD_nbrs[0],ports_weight)\\n else:\\n logger.debug(f\\\" multiple nodes diverging {SD_nbrs}\\\")\\n logger.debug(f\\\"nbr weights: {SD_nbrs} {[G.get_edge_data(node1, nbr)['weight'] for nbr in SD_nbrs ]}\\\")\\n match_pair[node1]=node1\\n traversed.append(node1)\\n new_sp=sorted(set(SD_nbrs)-set(traversed))\\n all_match_pairs_local={}\\n for nbr1,nbr2 in combinations(new_sp, 2):\\n logger.debug(f\\\"recursive pair call from single branch {nbr1} {nbr2}\\\")\\n new_pair={}\\n compare_nodes(G,all_match_pairs,new_pair,traversed.copy(),nbr1,nbr2,ports_weight)\\n if new_pair:\\n #new_pair[nbr1]=nbr2\\n all_match_pairs_local[nbr1+'_'+nbr2] = new_pair\\n all_match_pairs_local={k: v for k, v in all_match_pairs_local.items() if len(v)>0}\\n if len(all_match_pairs_local)==1:\\n match_pair.update( all_match_pairs_local[list(all_match_pairs_local.keys())[0]])\\n logger.debug(f\\\"found inline pair: {pprint.pformat(match_pair, indent=4)}\\\")\\n else:\\n for nbr1 in new_sp:\\n if (nbr1+'_'+nbr1 not in all_match_pairs.keys()):\\n logger.debug(f\\\"recursive single branch call from single branch {nbr1} {nbr1}\\\")\\n new_pair={}\\n compare_nodes(G,all_match_pairs,new_pair,traversed.copy(),nbr1,nbr1,ports_weight)\\n #filtering multiple axis of symmetries with same block, ideally they should be handled by array generation\\n if new_pair:\\n all_match_pairs[nbr1+'_'+nbr1] = new_pair\\n logger.debug(f\\\"updating match pairs: {pprint.pformat(all_match_pairs, indent=4)}\\\")\\n\\n\\n elif nbrs1 == nbrs2:\\n logger.debug(f\\\"traversing converging branch\\\")\\n match_pair[node1]=node2\\n traversed+=[node1,node2]\\n nbrs1=sorted(set(nbrs1)-set([node1,node2]))\\n logger.debug(f\\\"all non traversed neighbours: {nbrs1}\\\")\\n if len(nbrs1)==1:\\n nbr1=nbr2=nbrs1[0]\\n logger.debug(f\\\"keeping single converged branch inline {nbr1} {nbr2}\\\")\\n compare_nodes(G,all_match_pairs,match_pair,traversed.copy(),nbr1,nbr2,ports_weight)\\n else:\\n for nbr1,nbr2 in combinations_with_replacement(nbrs1,2):\\n logger.debug(f\\\"recursive call from converged branch {nbr1} {nbr2}\\\")\\n if nbr1+'_'+nbr2 not in all_match_pairs.keys():\\n new_pair={}\\n compare_nodes(G,all_match_pairs,new_pair,traversed.copy(),nbr1,nbr2,ports_weight)\\n #filtering multiple axis of symmetries with same block, ideally they should be handled by array generation\\n if new_pair:\\n all_match_pairs[nbr1+'_'+nbr2] = new_pair\\n logger.debug(f\\\"updating match pairs: {pprint.pformat(all_match_pairs, indent=4)}\\\")\\n\\n\\n elif compare_two_nodes(G,node1,node2,ports_weight):\\n nbrs1 = sorted(set([nbr for nbr in nbrs1 if G.get_edge_data(node1, nbr)['weight'] !=2]))\\n nbrs2 = sorted(set([nbr for nbr in nbrs2 if G.get_edge_data(node2, nbr)['weight'] !=2]))\\n match_pair[node1]=node2\\n traversed+=[node1,node2]\\n logger.debug(f\\\"Traversing parallel branches from {node1},{node2} {nbrs1}, {nbrs2}\\\")\\n nbrs1_wt = [G.get_edge_data(node1, nbr)['weight'] for nbr in nbrs1]\\n nbrs2_wt = [G.get_edge_data(node2, nbr)['weight'] for nbr in nbrs2]\\n unique_match=find_unique_matching_branches(G,nbrs1,nbrs2,ports_weight)\\n if len(nbrs1)==0 or len(nbrs2)==0:\\n logger.debug(f\\\"no new SD neihbours, returning recursion {match_pair}\\\")\\n elif len(nbrs1) ==1 and len(nbrs2)==1:\\n logger.debug(f\\\"traversing binary branch\\\")\\n compare_nodes(G,all_match_pairs,match_pair,traversed,nbrs1.pop(),nbrs2.pop(),ports_weight)\\n elif unique_match:\\n logger.debug(f'traversing unique matches {unique_match}')\\n match_pair[node1]=node2\\n traversed+=[node1,node2]\\n for nbr1,nbr2 in unique_match.items():\\n logger.debug(f\\\"recursive call from binary {node1}:{node2} to {nbr1}:{nbr2}\\\")\\n compare_nodes(G,all_match_pairs,match_pair,traversed.copy(),nbr1,nbr2,ports_weight)\\n elif len(nbrs1_wt)>len(set(nbrs1_wt))>1 and len(nbrs2_wt)>len(set(nbrs2_wt))>1:\\n logger.debug(f\\\"setting new start points {node1} {node2}\\\")\\n match_pair[node1]=node2\\n if \\\"start_point\\\" in match_pair.keys():\\n match_pair[\\\"start_point\\\"]+=[node1,node2]\\n else:\\n match_pair[\\\"start_point\\\"]=[node1,node2]\\n else:\\n match_pair = {}\\n logger.debug(f\\\"end all traversal from binary branch {node1} {node2}\\\")\\n\\n else:\\n match_pair = {}\\n logger.debug(f\\\"end of recursion branch, matches {match_pair}\\\")\",\n \"def graph_generation(nodes: np.ndarray, edges: np.ndarray):\\n result_nodes = []\\n result_edges = []\\n\\n last_index = nodes[-1, 0]\\n\\n done = False\\n # print(nodes)\\n for p in range(nodes.shape[0]):\\n for q in range(nodes.shape[0]):\\n if list(nodes[p, 1:-2]) == (list(nodes[q, 1:-2])) and nodes[p, nodes.shape[1] - 2] < \\\\\\n nodes[q, nodes.shape[1] - 2]:\\n tmp_node = np.append(nodes[p, 1:], np.append(nodes[q, nodes.shape[1] - 2],\\n np.append(nodes[q, nodes.shape[1] - 1],\\n np.append(nodes[p, 0],\\n nodes[q, 0]))))\\n if not done:\\n result_nodes = [tmp_node]\\n done = True\\n else:\\n result_nodes = np.concatenate((result_nodes, [tmp_node]))\\n\\n result_nodes = result_nodes[np.argsort(\\n result_nodes[:, [e for e in range(1, result_nodes.shape[1] - 2) if e % 2 != 0]].sum(axis=1)), :]\\n\\n result_nodes = np.c_[range(last_index + 1, last_index + 1 + result_nodes.shape[0]), result_nodes]\\n # print(result_nodes)\\n\\n done = False\\n for e in range(edges.shape[0]):\\n for f in range(edges.shape[0]):\\n for p in range(result_nodes.shape[0]):\\n for q in range(result_nodes.shape[0]):\\n if (edges[e, 0] == result_nodes[p, -2] and edges[e, 1] == result_nodes[q, -2] and edges[\\n f, 0] == result_nodes[p, -1] and edges[f, 1] == result_nodes[q, -1]) \\\\\\n or (edges[e, 0] == result_nodes[p, -2] and edges[e, 1] == result_nodes[q, -2] and\\n result_nodes[p, -1] == result_nodes[q, -1]) \\\\\\n or (edges[e, 0] == result_nodes[p, -1] and edges[e, 1] == result_nodes[q, -1] and\\n result_nodes[p, -2] == result_nodes[q, -2]):\\n if not done:\\n result_edges = [[result_nodes[p, 0], result_nodes[q, 0]]]\\n done = True\\n else:\\n result_edges = np.concatenate(\\n (result_edges, [[result_nodes[p, 0], result_nodes[q, 0]]]), axis=0)\\n # print(edges)\\n\\n # print(result_edges)\\n unique_result_edges = list(Counter(str(e) for e in result_edges).keys())\\n # print(unique_result_edges)\\n final_edges = []\\n for k in range(len(unique_result_edges)):\\n for j in range(result_edges.shape[0]):\\n if str(result_edges[j]) == unique_result_edges[k]:\\n if k == 0:\\n final_edges = result_edges[j]\\n break\\n else:\\n final_edges = np.concatenate((final_edges, result_edges[j]))\\n break\\n final_edges = np.reshape(final_edges, (int(final_edges.shape[0] / 2), 2))\\n # print(final_edges.shape[0])\\n done = False\\n edge_to_remove = []\\n for j in range(final_edges.shape[0]):\\n for k in range(j + 1, final_edges.shape[0]):\\n if final_edges[j, 1] == final_edges[k, 0]:\\n if not done:\\n edge_to_remove = [[final_edges[j, 0], final_edges[k, 1]]]\\n done = True\\n else:\\n edge_to_remove = np.concatenate((edge_to_remove, [[final_edges[j, 0], final_edges[k, 1]]]))\\n # print(edge_to_remove)\\n\\n idx_to_remove = []\\n done = False\\n for j in range(edge_to_remove.shape[0]):\\n for k in range(final_edges.shape[0]):\\n if list(edge_to_remove[j]) == list(final_edges[k]):\\n if not done:\\n idx_to_remove = k\\n done = True\\n else:\\n idx_to_remove = np.append(idx_to_remove, k)\\n final_edges = np.delete(final_edges, idx_to_remove, axis=0)\\n # print(final_edges)\\n result_nodes = np.delete(result_nodes, [-1, -2], 1)\\n # print(result_nodes)\\n return result_nodes, final_edges\",\n \"def union(node1, node2):\\n node1_root = find(node1)\\n node2_root = find(node2)\\n if node1_root == node2_root:\\n return\\n if node1_root.rank < node2_root.rank:\\n node1_root.parent = node2_root\\n elif node2_root.rank > node2_root.rank:\\n node2_root.parent = node1_root\\n else:\\n node2_root.parent = node1_root\\n node1_root.rank = node1_root.rank + 1\",\n \"def compare_balanced_tree(G, node1:str, node2:str, traversed1:list, traversed2:list):\\n logger.debug(f\\\"checking symmtrical connections for nodes: {node1}, {node2}\\\")\\n tree1 = set(get_next_level(G,[node1]))\\n tree2 = set(get_next_level(G,[node2]))\\n traversed1.append(node1)\\n traversed2.append(node2)\\n if tree1==tree2:\\n return True\\n while(len(list(tree1))== len(list(tree2)) > 0):\\n logger.debug(f\\\"tree1 {tree1} tree2 {tree2} traversed1 {traversed1} traversed2 {traversed2}\\\")\\n tree1 = set(tree1) - set(traversed1)\\n tree2 = set(tree2) - set(traversed2)\\n\\n if tree1.intersection(tree2) or len(list(tree1))== len(list(tree2))==0:\\n return True\\n else:\\n traversed1+=list(tree1)\\n traversed2+=list(tree2)\\n tree1=set(get_next_level(G,tree1))\\n tree2=set(get_next_level(G,tree2))\\n\\n logger.debug(f\\\"Non symmetrical branches for nets: {node1}, {node2}\\\")\\n return False\",\n \"def compareTree(t1, t2):\\n \\n reorderTree(t1)\\n reorderTree(t2)\\n\\n return compareTreeHelper(t1, t2)\",\n \"def shortest_path(start, end):\\n\\troot1=node(start)\\n\\troot2=node(end)\\n\\tarr1=[[] for wqw in range(8)]\\n\\tarr2=[[] for qwq in range(8)]\\n\\tser1=[[] for lp in range(100000)]\\n\\tser2=[[] for lp in range(100000)]\\n\\tarr1[0].append(root1)\\n\\tarr2[0].append(root2)\\n\\tser1[(hash(start))%100000].append(start)\\n\\tser2[(hash(end))%100000].append(end)\\n\\tflag=0\\n\\tchk=None\\n\\tfor h in range(0,7):\\n\\t\\tchk=check_match(arr1[h],arr2[h])\\n\\t\\tif not chk is None:\\n\\t\\t\\tflag=1\\n\\t\\t\\tbreak\\n\\t\\telse:\\n\\t\\t\\tfor w in range(len(arr1[h])):\\n\\t\\t\\t\\tfin=insert_e(arr1[h][w].data,h+1,arr1,ser1)\\n\\t\\t\\t\\tarr1=fin[0]\\n\\t\\t\\t\\tser1=fin[1]\\n\\t\\tchk=check_match(arr2[h],arr1[h+1])\\n\\t\\tif not chk is None:\\n\\t\\t\\tflag=2\\n\\t\\t\\tbreak\\n\\t\\telse:\\n\\t\\t\\tfor q in range(len(arr2[h])):\\n\\t\\t\\t\\tfim=insert_e(arr2[h][w].data,h+1,arr2,ser2)\\n\\t\\t\\t\\tarr2=fim[0]\\n\\t\\t\\t\\tser2=fim[1]\\n\\tif flag==1:\\n\\t\\twhile not chk[0].parent is None:\\n\\t\\t\\tres1.append(chk[0].parent.data)\\n\\t\\t\\tchk[0]=chk[0].parent\\n\\t\\tres+=res1.reverse()\\n\\t\\tres.append(chk[1])\\n\\t\\twhile not chk[1].parent is None:\\n\\t\\t\\tres2.append(chk[1].parent.data)\\n\\t\\t\\tchk[1]=chk[1].parent\\n\\t\\treturn res\\n\\telif flag==2:\\n\\t\\twhile not chk[1].parent is None:\\n\\t\\t\\tres1.append(chk[1].parent.data)\\n\\t\\t\\tchk[1]=chk[1].parent\\n\\t\\tif not res1 is None:\\n\\t\\t\\tres+=res1.reverse()\\n\\t\\tres.append(chk[0])\\n\\t\\twhile not chk[0].parent is None:\\n\\t\\t\\tres2.append(chk[0].parent.data)\\n\\t\\t\\tchk[0]=chk[0].parent\\n\\t\\treturn res\\n\\telse:\\n\\t\\tprint \\\"The given configuration is not solvable/wrong.\\\"\",\n \"def add_trees(t1, t2):\\n \\\"*** YOUR CODE HERE ***\\\"\\n # offical solution:\\n if not t1:\\n return t2\\n if not t2:\\n return t1\\n new_label = label(t1) + label(t2)\\n t1_children, t2_children = branches(t1), branches(t2)\\n length_t1, length_t2 = len(t1_children), len(t2_children)\\n if length_t1 < length_t2:\\n t1_children += [None for _ in range(length_t1, length_t2)]\\n elif len(t1_children) > len(t2_children):\\n t2_children += [None for _ in range(length_t2, length_t1)]\\n return tree(new_label, [add_trees(child1, child2) for child1, child2 in zip(t1_children, t2_children)])\",\n \"def get_matched_nodeids_from_orderids(sorted_small_nodes, sorted_large_nodes, matched_orderids):\\n orderid2nodeid_func = lambda order_pair: (sorted_small_nodes[order_pair[0]].nodeid, sorted_large_nodes[order_pair[1]].nodeid)\\n return list(map(orderid2nodeid_func, matched_orderids))\",\n \"def merge_nodes(self, node_ids):\\n node_ids = sorted(node_ids)\\n\\n # Make sure no duplicate node_ids.\\n for i in range(len(node_ids) - 1):\\n assert node_ids[i] != node_ids[i + 1], \\\"Duplicate node IDs.\\\"\\n\\n # Make sure nodes are the same type.\\n for i in range(1, len(node_ids)):\\n n1 = self.nodes[node_ids[0]]\\n n2 = self.nodes[node_ids[i]]\\n assert n1.__class__ == n2.__class__, \\\"%s %s\\\" % (\\n n1.__class__, n2.__class__)\\n\\n # Keep the first node, and delete the rest.\\n\\n # Make transitions to any node_ids point to the first one.\\n node_id = node_ids[0]\\n prev_ids = []\\n for nid in node_ids[1:]:\\n x = _get_parents_of(self, nid)\\n prev_ids.extend(x)\\n transitions = self.transitions.copy()\\n for prev_id in prev_ids:\\n x = transitions[prev_id]\\n if node_id not in x:\\n x = x + [node_id]\\n transitions[prev_id] = x\\n\\n # Make the first node point to all the next_nodes of the other\\n # node_ids.\\n nid0 = node_ids[0]\\n for nidi in node_ids[1:]:\\n x = transitions.get(nid0, []) + transitions.get(nidi, [])\\n x = sorted({}.fromkeys(x))\\n transitions[nid0] = x\\n\\n x = Network(self.nodes, transitions)\\n x = x.delete_nodes(node_ids[1:])\\n return x\",\n \"def question4(T,r,n1,n2):\\n\\n\\tif(len(T)<=1):\\t\\t\\t\\t\\t\\t\\t\\t# Edge case : If the Tree only consists of a root and no children\\n\\t\\treturn -1\\n\\n\\tif(n1==None or n2==None):\\t\\t\\t\\t\\t# Edge case : If n1 and n2 are not actually numbers\\n\\t\\treturn -1\\n\\n\\tlen_T = len(T)\\n\\tif(not n1 < len_T or not n2 < len_T):\\t\\t# Edge case : If the nodes gives in parameters do not actually exist in the tree\\n\\t\\treturn -1\\n\\n\\tn1_list = []\\t\\t\\t\\t\\t\\t\\n\\tn2_list = []\\n\\n\\tfor i in range(len(T)):\\t\\t\\t\\t\\t\\t# Traverse the list and append all the parents of node1 if found in O(N)\\n\\t\\tif T[i][n1]==1:\\n\\t\\t\\tn1_list.append(i)\\n\\n\\tfor i in range(len(T)):\\t\\t\\t\\t\\t\\t# Traverse the list and append all the parents of node2 is found in O(N)\\n\\t\\tif T[i][n2]:\\n\\t\\t\\tn2_list.append(i)\\n\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t# The root is a common ancestor of every node in the tree\\n\\tif not r in n1_list:\\t\\t\\t\\t\\t\\t# check if the root is in the list, if not, add it\\n\\t\\tn1_list.append(r)\\n\\n\\tif not r in n2_list:\\t\\t\\t\\t\\t\\t# check if the root is in the list, if not, add it\\n\\t\\tn2_list.append(r)\\n\\n\\tn1_list = reversed(n1_list)\\t\\t\\t\\t\\t# Since we are operating on a binary tree, we sort\\n\\tfor i in n1_list:\\t\\t\\t\\t\\t\\t\\t# in decending order to operate on the latest nodes\\n\\t\\tif i in n2_list:\\t\\t\\t\\t\\t\\t# if a match is found, we know that it is the lowest common ancestor\\n\\t\\t\\treturn i \\t\\t\\t\\t\\t\\t\\t# If nothing is found, the root node is bound to be returned. And it correct.\",\n \"def union(self, data1, data2):\\n root1 = self.find_set(data1)\\n root2 = self.find_set(data2)\\n\\n if root1 == root2:\\n return False\\n\\n elif root1.rank >= root2.rank:\\n if root1.rank == root2.rank:\\n root1.rank = root1.rank + 1\\n root2.parent = root1\\n else:\\n root1.parent = root2\\n\\n return True\",\n \"def union(self, data1, data2):\\n root1 = self.find_set(data1)\\n root2 = self.find_set(data2)\\n\\n if root1 == root2:\\n return False\\n\\n elif root1.rank >= root2.rank:\\n if root1.rank == root2.rank:\\n root1.rank = root1.rank + 1\\n root2.parent = root1\\n else:\\n root1.parent = root2\\n\\n return True\",\n \"def merge_nodes(node_ids, tree):\\n # Copy the tree so we keep the original intact\\n temp = deepcopy(tree)\\n # Don't merge nodes if they are already merged\\n if node_ids in temp or tuple(reversed(node_ids)) in temp:\\n return temp\\n # Get all the children of each node we need to merge (except if that child is the other node)\\n children_1 = filter(lambda x: x != node_ids[1], temp[node_ids[0]])\\n children_2 = filter(lambda x: x != node_ids[0], temp[node_ids[1]])\\n merged_children = children_1 + children_2\\n # Remove the original nodes in the tree\\n temp.pop(node_ids[0], None)\\n temp.pop(node_ids[1], None)\\n # Add a new node\\n temp[node_ids] = merged_children\\n \\n # Update references to the old node with references to the new node\\n for k, v in temp.iteritems():\\n if node_ids[0] in v:\\n idx = v.index(node_ids[0])\\n v.remove(node_ids[0])\\n v.insert(idx, node_ids)\\n if node_ids[1] in v:\\n idx = v.index(node_ids[1])\\n v.remove(node_ids[1])\\n v.insert(idx, node_ids)\\n temp[k] = dedupe(v)\\n return temp\",\n \"def compare_trees(tree1, tree2):\\n \\tresponse = {}\\n \\tstart_time = time.time()\\n \\ttry:\\t\\n \\t\\ttns = dendropy.TaxonNamespace() \\t\\n \\t\\n \\t\\ttree_obj1 = dendropy.Tree.get(data=tree1, schema=\\\"newick\\\",taxon_namespace=tns)\\n \\t\\ttree_obj2 = dendropy.Tree.get(data=tree2, schema=\\\"newick\\\",taxon_namespace=tns)\\n\\n \\t\\ttree_obj1.encode_bipartitions()\\n \\t\\ttree_obj2.encode_bipartitions()\\n\\n \\t\\t#-----------------------------------------------------------\\n \\t\\t#This method returns the symmetric distance between two trees. \\n \\t\\t#The symmetric distance between two trees is the sum of the number of splits found in one of the trees but not the other. \\n \\t\\t#It is common to see this statistic called the Robinson-Foulds distance\\n\\n \\t\\tareSame = True if treecompare.symmetric_difference(tree_obj1, tree_obj2) == 0 else False\\n \\t\\tstatus = 200\\n \\t\\tmessage = \\\"Success\\\"\\n \\t\\tresponse['are_same_tree'] = areSame\\n \\n \\texcept Exception, e:\\n \\t\\tif \\\"Incomplete or improperly-terminated tree statement\\\" in str(e): #invalid: \\\"((A,B),C,D));\\\" valid: ((A,B),(C,D)); \\n \\t\\t\\tmessage = \\\"NewickReaderIncompleteTreeStatementError: \\\" + str(e)\\n \\t \\t\\tstatus = 400\\n \\t\\telif \\\"Unbalanced parentheses at tree statement\\\" in str(e): #invalid: \\\"((A,B),(C,D);\\\" valid: ((A,B),(C,D)); \\n \\t\\t\\tmessage = \\\"NewickReaderMalformedStatementError: \\\"+str(e) \\n \\t \\t\\tstatus = 400\\n \\t\\telif \\\"Multiple occurrences of the same taxa\\\" in str(e): #invalid: \\\"((A,B),(C,C));\\\" valid: ((A,B),(C,D));\\n \\t\\t\\tmessage = \\\"NewickReaderDuplicateTaxonError: \\\"+str(e)\\n \\t \\t\\tstatus = 400\\n \\t\\telif \\\"Unexpected end of stream\\\" in str(e): # invalid: \\\"((A,B),(C,D))\\\" valid: ((A,B),(C,D));\\n \\t\\t\\tmessage = \\\"UnexpectedEndOfStreamError: \\\"+str(e)\\n \\t \\t\\tstatus = 400\\n \\t\\telse:\\n \\t\\t\\tmessage = \\\"Error: Failed to compare trees. \\\"+str(e)\\n \\t \\t\\tstatus = 500\\n \\t \\t\\n \\tresponse['status_code'] = status\\n \\tresponse['message'] = message\\n\\n \\tend_time = time.time()\\n \\texecution_time = end_time-start_time\\n #service result creation time\\n \\tcreation_time = datetime.datetime.now().isoformat()\\n \\tmeta_data = {'creation_time': creation_time, 'execution_time': float('{:4.2f}'.format(execution_time)), 'source_urls':[\\\"http://dendropy.org/library/treecompare.html#module-dendropy.calculate.treecompare\\\"] }\\n\\n \\tresponse['meta_data'] = meta_data\\n \\tprint response\\n \\treturn response\",\n \"def nocache_create_equal_size_subtrees():\\n N = len(self)\\n subTrees = [set(range(i, N, numSubTrees)) for i in range(numSubTrees)]\\n totalCost = N\\n return subTrees, totalCost\",\n \"def mergeNodes(nodeA,nodeB,branchLenA,branchLenB):\\n newNodeA = (nodeA[0], nodeA[1], nodeA[2], branchLenA)\\n newNodeB = (nodeB[0], nodeB[1], nodeB[2], branchLenB)\\n new = ('anc',newNodeA,newNodeB,0)\\n return new\",\n \"def get_branch_topology_constraint_v2(\\n edge_matchings: List[Tuple[int, int]],\\n node_matchings: List[Tuple[int, int]],\\n tree_degrees: List[int],\\n graph_edges: Dict[int, Tuple[int, int]],\\n tree_edges: Dict[int, Tuple[int, int]],\\n node_match_indices: Dict[Tuple[int, int], int],\\n num_node_matchings: int,\\n):\\n constraints = {}\\n\\n for i, (g_e, t_e) in enumerate(edge_matchings):\\n g_u, g_v = graph_edges[g_e]\\n t_u, t_v = tree_edges[t_e]\\n\\n uu_index = node_match_indices.get((g_u, t_u))\\n vv_index = node_match_indices.get((g_v, t_v))\\n\\n if uu_index is not None:\\n uu_constraints = constraints.setdefault((g_u, t_u), {})\\n\\n uu_ge_constraint = uu_constraints.setdefault(t_e, [(uu_index, 1)])\\n\\n uu_ge_constraint.append((i + num_node_matchings, -1))\\n\\n if vv_index is not None:\\n vv_constraints = constraints.setdefault((g_v, t_v), {})\\n\\n vv_ge_constraint = vv_constraints.setdefault(\\n t_e, [(node_match_indices[(g_v, t_v)], 1)]\\n )\\n\\n vv_ge_constraint.append((i + num_node_matchings, -1))\\n\\n for (g_n, t_n) in node_matchings:\\n if t_n == len(tree_degrees):\\n continue\\n node_match_constraints = constraints.setdefault((g_n, t_n), {})\\n if len(node_match_constraints) < tree_degrees[t_n]:\\n node_match_constraints[None] = [(node_match_indices[(g_n, t_n)], 1)]\\n\\n return (\\n [\\n edge_constraint\\n for node_match_constraints in constraints.values()\\n for edge_constraint in node_match_constraints.values()\\n ],\\n \\\"LessEqual\\\",\\n 0,\\n )\",\n \"def from_binary_trees(tree1, tree2):\\n initial_forest = TamariIntervalPosets.initial_forest(tree2)\\n final_forest = TamariIntervalPosets.final_forest(tree1)\\n try:\\n return initial_forest.intersection(final_forest)\\n except Exception:\\n raise ValueError(\\\"The two binary trees are not comparable on the Tamari lattice.\\\")\",\n \"def build_tree(self):\\n resolved_nodes = []\\n for nodeh in self.unresolved_nodes:\\n sibling, left_sibl = self.find_sibling(nodeh)\\n\\n if nodeh in resolved_nodes:\\n continue\\n\\n if sibling:\\n self.nodes[nodeh]['sibling'] = sibling\\n self.nodes[nodeh]['left'] = not left_sibl\\n self.nodes[sibling]['left'] = left_sibl\\n self.nodes[sibling]['sibling'] = nodeh\\n\\n if left_sibl:\\n parent = do_hash(sibling + nodeh, self.algo)\\n else:\\n parent = do_hash(nodeh + sibling, self.algo)\\n self.nodes[sibling]['parent'] = parent\\n self.nodes[nodeh]['parent'] = parent\\n resolved_nodes.append(nodeh)\\n resolved_nodes.append(sibling)\\n\\n paddress = parent_address(self.nodes[nodeh]['address'])\\n self.nodes[parent] = {'address': paddress}\\n self.addresses[paddress] = parent\\n if paddress != '':\\n self.unresolved_nodes.append(parent)\\n else:\\n self.nodes[nodeh]['address'] = parent_address(\\n self.nodes[nodeh]['address'])\\n self.unresolved_nodes = list(\\n set(self.unresolved_nodes) - set(resolved_nodes))\",\n \"def union(self, node1, node2):\\n\\n root1 = self.root(node1)\\n root2 = self.root(node2)\\n\\n if root1 == root2:\\n return\\n\\n if node1 < node2:\\n self.set[root2] = root1\\n self.root(node2)\\n else:\\n self.set[root1] = root2\\n self.root(node1)\",\n \"def findSameSubtrees(self):\\n\\n collapsable = {}\\n\\n for i in range(0, len(list(self.nodes))):\\n for j in range(i + 1, len(list(self.nodes))):\\n # Be careful, non-zero based indexing here\\n if self.isSameTree(self.nodes[i + 1], self.nodes[j + 1]):\\n # Note time complexity of isSameTree\\n collapsable[self.nodes[i + 1]] = self.nodes[j + 1]\\n\\n return collapsable\",\n \"def test_initial_nodes_to_merge(self):\\r\\n t = mergeorder(['A', 'B', 'C', 'D', 'E'], 'foo')\\r\\n exp = set([t.Children[0], t.Children[1].Children[1]])\\r\\n obs = initial_nodes_to_merge(t)\\r\\n self.assertEqual(obs, exp)\",\n \"def wrong_buildTree(self, start, end, cur):\\n if start == end:\\n self.nodes[cur] = self.nums[start]\\n else: \\n mid = start+(end-start)/2\\n left, right = 2*cur+1, 2*cur+2\\n self.nodes[cur] = self.buildTree(start, mid, left) + self.buildTree(mid+1, end, right)\\n return self.nodes[cur]\",\n \"def generate_tree_general(node_lst, root_index):\\n\\n def generate_huffman(note):\\n \\\"\\\"\\\" Return a new tree based on the given ReadNode node.\\n\\n @param ReadNode note: a given ReadNode\\n @rtype: HuffmanNode\\n\\n >>> t = generate_huffman(ReadNode(0, 5, 0, 7))\\n >>> t\\n HuffmanNode(None, HuffmanNode(5, None, None), HuffmanNode(7, None, None))\\n >>> t = generate_huffman(ReadNode(1, 1, 1, 0))\\n >>> t\\n HuffmanNode(None, HuffmanNode(None, None, None), HuffmanNode(None, None, None))\\n >>> t.left.number\\n 1\\n >>> t.right.number\\n 0\\n \\\"\\\"\\\"\\n\\n if note.l_type == 0 and note.r_type == 0:\\n return HuffmanNode(None, HuffmanNode(note.l_data),\\n HuffmanNode(note.r_data))\\n elif note.l_type == 0 and note.r_type == 1:\\n k = HuffmanNode(None, HuffmanNode(note.l_data), HuffmanNode())\\n k.right.number = note.r_data\\n return k\\n elif note.l_type == 1 and note.r_type == 0:\\n k = HuffmanNode(None, HuffmanNode(), HuffmanNode(note.r_data))\\n k.left.number = note.l_data\\n return k\\n else:\\n k = HuffmanNode(None, HuffmanNode(), HuffmanNode())\\n k.left.number, k.right.number = note.l_data, note.r_data\\n return k\\n\\n def combine_trees(trees_, index):\\n \\\"\\\"\\\" Return a new tree based on the list of frame trees and take the\\n HuffmanNode tree at int index as the root tree.\\n\\n @param list[HuffmanNode] trees_:\\n @param int index:\\n @rtype: HuffmanNode\\n\\n >>> t = [ReadNode(0, 5, 0, 7), ReadNode(0, 10, 0, 12), ReadNode(1, 1, 1, 0)]\\n >>> huff_list = [generate_huffman(x) for x in t]\\n >>> a = combine_trees(huff_list, 2)\\n >>> a == HuffmanNode(None, HuffmanNode(None, HuffmanNode(10, None, None), HuffmanNode(12, None, None)), HuffmanNode(None, HuffmanNode(5, None, None), HuffmanNode(7, None, None)))\\n True\\n >>> a.left.number\\n 1\\n >>> a.right.number\\n 0\\n >>> combine_trees(huff_list, 0)\\n HuffmanNode(None, HuffmanNode(5, None, None), HuffmanNode(7, None, None))\\n \\\"\\\"\\\"\\n\\n root = trees_[index]\\n if root.left.number is None and root.right.number is None:\\n return root\\n elif root.left.number is None and root.right.number is not None:\\n right = combine_trees(trees_, root.right.number)\\n number = root.right.number\\n root.right = right\\n root.right.number = number\\n return root\\n elif root.left.number is not None and root.right.number is None:\\n left = combine_trees(trees_, root.left.number)\\n number = root.left.number\\n root.left = left\\n root.left.number = number\\n return root\\n else:\\n left = combine_trees(trees_, root.left.number)\\n num_l = root.left.number\\n right = combine_trees(trees_, root.right.number)\\n num_r = root.right.number\\n root.left = left\\n root.right = right\\n root.left.number = num_l\\n root.right.number = num_r\\n return root\\n\\n trees = []\\n for node in node_lst:\\n trees.append(generate_huffman(node))\\n root_tree = combine_trees(trees, root_index)\\n\\n return root_tree\",\n \"def union(self, node1, node2):\\n root1 = self.find(node1)\\n root2 = self.find(node2)\\n if root1 != root2: # only merge if the connected components differ\\n if self.ranks[root1] > self.ranks[root2]:\\n self.parents[root2] = root1\\n else:\\n self.parents[root1] = root2\\n if self.ranks[root1] == self.ranks[root2]:\\n self.ranks[root2] += 1\",\n \"def splitNodes(matching):\\n outer = set(range(self.n))\\n inner = set([])\\n for (u, v) in matching:\\n if u in outer:\\n outer.remove(u)\\n if v in outer:\\n outer.remove(v)\\n inner.add(u)\\n inner.add(v)\\n return list(inner), list(outer)\",\n \"def build_matrix(seq_1_trim, seq_2_trim, config):\\n nodes = np.empty((len(seq_1_trim) + 1, len(seq_2_trim) + 1), dtype=Node)\\n nodes[0, 0] = CornerNode()\\n for index in range(len(seq_1_trim)):\\n nodes[1 + index, 0] = EdgeNode(nodes[index, 0], Direction.TOP, config)\\n for index in range(len(seq_2_trim)):\\n nodes[0, 1 + index] = EdgeNode(nodes[0, index], Direction.LEFT, config)\\n\\n # build actual matrix\\n # could be optimized, as we know from trimming that the first and the last elements of both seq's are different\\n for row in range(len(seq_1_trim)):\\n for column in range(len(seq_2_trim)):\\n nodes[row + 1, column + 1] = Node(\\n nodes[row + 1, column], nodes[row, column], nodes[row, column + 1], config\\n ).compute_value(seq_1_trim[row], seq_2_trim[column])\\n\\n return nodes\",\n \"def root_nodes(self, node1, node2, distance):\\n if node1 == node2.parent:\\n upper_node = node1\\n lower_node = node2\\n upper_dist, lower_dist = distance, lower_node.branch - distance\\n elif node2 == node1.parent:\\n upper_node = node2\\n lower_node = node1\\n upper_dist, lower_dist = lower_node.branch - distance, distance\\n else:\\n raise PhyloValueError('root_nodes() requires that one of the given nodes is the parent of the other.')\\n if len(self.root.children) <= 1:\\n raise PhyloValueError('cannot re-root a tree where the existing root has one or no children.')\\n elif len(self.root.children) == 2:\\n if upper_node == self.root:\\n # Just need to adjust branch lengths\\n root_child = self.root.children[1] if self.root.children[0] == lower_node else self.root.children[0]\\n root_child.branch += upper_dist\\n lower_node.branch = lower_dist\\n else:\\n upper_path = self.find_path_to_root(upper_node)\\n # Process the old root child after removing the root:\\n root_child = self.root.children[1] if self.root.children[0] == upper_path[1] else self.root.children[0]\\n root_child.branch += upper_path[1].branch\\n root_child.parent = upper_path[1]\\n upper_path[1].children.append(root_child)\\n # Process nodes between root and upper_node:\\n prev_node = upper_path[1]\\n for next_node in upper_path[2:]:\\n prev_node.children.remove(next_node)\\n prev_node.parent = next_node\\n next_node.children.append(prev_node)\\n prev_node.branch = next_node.branch\\n prev_node = next_node\\n # Process upper_node, lower_node, and the new root\\n upper_node.parent = lower_node.parent = self.root\\n upper_node.children.remove(lower_node)\\n self.root.children = [node1, node2] # Keeps the argument order\\n upper_node.branch = upper_dist\\n lower_node.branch = lower_dist\\n else: # If the root has 3 children it means it's an unrooted tree\\n new_root = self.new_tree_node()\\n new_root.branch = self.root.branch # Transfers any existing root branch\\n if upper_node != self.root:\\n upper_path = self.find_path_to_root(upper_node)\\n prev_node = self.root\\n for next_node in upper_path[1:]:\\n prev_node.children.remove(next_node)\\n prev_node.parent = next_node\\n next_node.children.append(prev_node)\\n prev_node.branch = next_node.branch\\n prev_node = next_node\\n upper_node.children.remove(lower_node)\\n upper_node.branch = upper_dist\\n lower_node.branch = lower_dist\\n new_root.children.append(upper_node)\\n new_root.children.append(lower_node)\\n upper_node.parent = lower_node.parent = new_root\\n self.root = new_root\\n self.process_tree_nodes()\",\n \"def _gen_test_tree_2():\\n tree = BinaryNode(5)\\n tree.left = BinaryNode(3)\\n tree.left.left = BinaryNode(2)\\n tree.left.left.left = BinaryNode(1)\\n tree.left.right = BinaryNode(4)\\n tree.right = BinaryNode(7)\\n tree.right.left = BinaryNode(6)\\n tree.right.right = BinaryNode(8)\\n tree.right.right.right = BinaryNode(9)\\n return tree\",\n \"def add_trees(t1, t2):\\n \\\"*** YOUR CODE HERE ***\\\"\\n if not t1:\\n return t2 # Could replace with copy_tree(t2)\\n if not t2:\\n return t1 # Could replace with copy_tree(t1)\\n new_entry = t1.root + t2.root\\n t1_branches, t2_branches = list(t1.branches), list(t2.branches)\\n length_t1, length_t2 = len(t1_branches), len(t2_branches)\\n if length_t1 < length_t2:\\n t1_branches += [None for _ in range(length_t1, length_t2)]\\n elif length_t1 > length_t2:\\n t2_branches += [None for _ in range(length_t2, length_t1)]\\n return Tree(new_entry, [add_trees(branch1, branch2) for branch1, branch2 in zip(t1_branches, t2_branches)])\",\n \"def test_join(trees, leaves, maps, nodeA, nodeB):\\n cladeA = get_leaf_set(nodeA)\\n cladeB = get_leaf_set(nodeB)\\n cladeAB = cladeA.union(cladeB)\\n\\n if len(cladeA.intersection(cladeB)) > 0:\\n raise Exception(\\\"Nodes are not disjoint on their leaf sets!\\\\n\\\")\\n\\n nodeAinTs = []\\n nodeBinTs = []\\n for i, tree in enumerate(trees):\\n leaf = leaves[i]\\n\\n if cladeA == leaf:\\n nodeAinTs.append(nodeA)\\n else:\\n nodeAinTs.append(get_node_from_clade(tree, maps[i], cladeA))\\n\\n if cladeB == leaf:\\n nodeBinTs.append(nodeB)\\n else:\\n nodeBinTs.append(get_node_from_clade(tree, maps[i], cladeB))\\n\\n nAinTs = []\\n for nodeAinT in nodeAinTs:\\n nAinTs.append(nodeAinT is not None)\\n\\n if sum(nAinTs) < 1:\\n raise Exception(\\\"Node A was not found in any tree!\\\\n\\\")\\n\\n nBinTs = []\\n for nodeBinT in nodeBinTs:\\n nBinTs.append(nodeBinT is not None)\\n\\n if sum(nBinTs) < 1:\\n raise Exception(\\\"Node B was not found in any tree!\\\\n\\\")\\n\\n violates = False\\n for i, tree1 in enumerate(trees[:-1]):\\n map1 = maps[i]\\n nAinT1 = nAinTs[i]\\n nBinT1 = nBinTs[i]\\n nodeAinT1 = nodeAinTs[i]\\n nodeBinT1 = nodeBinTs[i]\\n j = i\\n for tree2 in trees[i+1:]:\\n j = j + 1\\n map2 = maps[j]\\n nAinT2 = nAinTs[j]\\n nBinT2 = nBinTs[j]\\n nodeAinT2 = nodeAinTs[j]\\n nodeBinT2 = nodeBinTs[j]\\n if (sum([nAinT1, nAinT2]) > 0) and (sum([nBinT1, nBinT2]) > 0):\\n if nAinT1 and nAinT2:\\n # nodeA in *both* T1 and T2\\n if nBinT1 and nBinT2:\\n # Case 1: nodeB in *both* T1 and T2\\n # Valid if nodeA and nodeB are siblings in both T1 & T2\\n node1 = get_node_from_clade(tree1, map1, cladeAB)\\n node2 = get_node_from_clade(tree2, map2, cladeAB)\\n if (node1 is None) or (node2 is None):\\n violates = True\\n elif nBinT1:\\n # Case 2: Node B in T1 only\\n # Valid if nodeA and nodeB are siblings in T1\\n node = get_node_from_clade(tree1, map1, cladeAB)\\n if node is None:\\n violates = True\\n elif nBinT2:\\n # Case 3: Node B in T2 only\\n # Valid if nodeA and nodeB are siblings in T2\\n node = get_node_from_clade(tree2, map2, cladeAB)\\n if node is None:\\n violates = True\\n else:\\n raise Exception(\\\"Node B not found in either tree!\\\\n\\\")\\n elif nAinT1:\\n # nodeA in T1 only\\n if nBinT1 and nBinT2:\\n # Case 4: nodeB in *both* T1 and T2\\n node = get_node_from_clade(tree1, map1, cladeAB)\\n if node is None:\\n violates = True\\n elif nBinT1:\\n # Case 5: Node B in T1 only\\n # Valid if nodeA and nodeB are siblings in T1\\n node = get_node_from_clade(tree1, map1, cladeAB)\\n if node is None:\\n violates = True\\n elif nBinT2:\\n # Case 6: Node B in T2 only\\n # Do join in both trees and test for compatibility\\n # TODO: Remove deep copies!\\n t1 = deepcopy(tree1)\\n t2 = deepcopy(tree2)\\n nA = deepcopy(nodeAinT1)\\n nB = deepcopy(nodeBinT2)\\n [t1, t2] = join_nodes_in_both_trees(t1, nA, cladeA,\\n t2, nB, cladeB,\\n test=True)\\n if t1 is not None:\\n violates = are_two_trees_incompatible(t1, t2)\\n else:\\n raise Exception(\\\"Node B not found in either tree!\\\\n\\\")\\n elif nAinT2:\\n # nodeA in T2 only\\n if nBinT1 and nBinT2:\\n # Case 7: nodeB in *both* T1 and T2\\n node = get_node_from_clade(tree2, map2, cladeAB)\\n if node is None:\\n violates = True\\n elif nBinT1:\\n # Case 8 (reverse of Case 6): Node B in T1 only\\n # Do join in both trees and test for compatibility\\n # TODO: Remove deep copies!\\n t1 = deepcopy(tree1)\\n t2 = deepcopy(tree2)\\n nA = deepcopy(nodeAinT2)\\n nB = deepcopy(nodeBinT1)\\n [t1, t2] = join_nodes_in_both_trees(t1, nB, cladeB,\\n t2, nA, cladeA,\\n test=True)\\n if t1 is not None:\\n violates = are_two_trees_incompatible(t1, t2)\\n elif nBinT2:\\n # Case 9: Node B in T2 only\\n # Only valid if nodeA and nodeB are siblings in T2\\n node = get_node_from_clade(tree2, map2, cladeAB)\\n if node is None:\\n violates = True\\n else:\\n raise Exception(\\\"Node B not found in either tree!\\\\n\\\")\\n else:\\n raise Exception(\\\"Node A not found in either tree!\\\\n\\\")\\n\\n if violates:\\n return violates\\n\\n return violates\",\n \"def substructure_sim_exact(subtrees_1, subtrees_2):\\n assert(len(subtrees_1) == len(subtrees_2))\\n n = len(subtrees_1)\\n f1 = np.zeros(n)\\n for i in range(n):\\n f1[i] = subtrees_1[i] == subtrees_2[i] # calculate the number of matching pairs\\n\\n return float(np.count_nonzero(f1)) / float(len(f1))\",\n \"def get_subtree_nodes(T1, T2, new):\\n # Get subtree of T2 induced by the new node\\n T2_ind = trilearn.graph.junction_tree.subtree_induced_by_subset(T2, {new})\\n T2_subtree_nodes = None\\n # Find the subtree(2) in T1\\n if T2_ind.has_node(frozenset([new])):\\n # Isolated node. Unique empty subtree\\n T2_subtree_nodes = [{frozenset([new]): None}]\\n\\n elif T2_ind.order() == 1:\\n # Look which is its neighbor\\n #c = T2_ind.nodes()[0] # nx < 2.x\\n c = list(T2_ind.nodes())[0] # nx > 2.x\\n\\n if T1.has_node(c - {new}):\\n # if it was connected to everything in a clique\\n T2_subtree_nodes = [{c: c - {new}}]\\n else:\\n # c always has at lest one neighbor and the separator c\\\\new\\n # for all of them.\\n # We have to decide which of them was the emerging clique.\\n # 3 cases:\\n # 1) 1 neighbor: Trivial.\\n # 2) 2 neighbors: Then it could be any of these.\\n # 3) >2 neighbors: The emerging clique is the one that has the\\n # others as a subset of its neighbors in T1\\n #neigs = T2.neighbors(c) # nx < 2.x\\n neigs = list(T2.neighbors(c)) # nx > 2.x\\n possible_origins = [c1 for c1 in neigs if c1 & c == c - {new}]\\n g = len(possible_origins)\\n if g == 1:\\n # This neighbor has to be the one it came from\\n T2_subtree_nodes = [{c: possible_origins[0]}]\\n elif g == 2 and len(neigs) == 2:\\n # If there are 2 possible neighbors with the same separator\\n T2_subtree_nodes = [{c: possible_origins[0]},\\n {c: possible_origins[1]}]\\n else:\\n for neig in possible_origins:\\n if set(neigs) - {neig} <= set(T1.neighbors(neig)):\\n T2_subtree_nodes = [{c: neig}]\\n break\\n else:\\n tmp = {}\\n # In this case the subtree nodes are uniquely defined by T1 and T2\\n # Loop through all edges in T2 in order to extract the correct\\n # subtree of T1. Note that, by construction we know that it has the same structure as\\n # the induced subtree of T2.\\n for e in T2_ind.edges():\\n # Non-swallowed cliques, get all potential \\\"emerging\\\"\\n # (cliques from where the new cliques could have have emerged) cliques.\\n Ncp1 = [c for c in T2.neighbors(e[0]) if\\n c & e[0] == e[0] - {new}]\\n Ncp2 = [c for c in T2.neighbors(e[1]) if\\n c & e[1] == e[1] - {new}]\\n\\n # If the clique was swallowed in the new clique,\\n # there will be no neighbors, so the clique itself\\n # (except from the new node) is the unique emerging clique.\\n if Ncp1 == []:\\n Ncp1 = [e[0] - {new}]\\n if Ncp2 == []:\\n Ncp2 = [e[1] - {new}]\\n\\n # Replicate the structure in T2\\n for neig1 in Ncp1:\\n for neig2 in Ncp2:\\n if T1.has_edge(neig1, neig2): # Know that this edge is unique\\n tmp[e[0]] = neig1\\n tmp[e[1]] = neig2\\n T2_subtree_nodes = [tmp]\\n return T2_subtree_nodes\",\n \"def build(\\n word_dict: AsrDictionary,\\n subword_dict: AsrDictionary,\\n subword_tokenizer: Callable[[str], List[str]] = None,\\n ):\\n\\n root = lexical_prefix_tree(\\n word_dict=word_dict,\\n subword_dict=subword_dict,\\n subword_tokenizer=subword_tokenizer,\\n ) # build traditional tree data structure by reusing existing routines\\n\\n # Performs pre-order traversal of this tree to assign an index for each node\\n max_num_children = 0\\n nodes = [None] # nodes[0] is a dummy node for OOV\\n node_to_id_dict = {}\\n stack = [root]\\n\\n while len(stack) > 0:\\n curr = stack.pop()\\n node_id = len(nodes)\\n nodes.append(curr)\\n node_to_id_dict[curr] = node_id\\n if len(curr.children) > max_num_children:\\n max_num_children = len(curr.children)\\n\\n # Guarantee that the children are traversed ascendingly according to the subword index\\n for _, next_node in sorted(\\n curr.children.items(), key=lambda t: t[0], reverse=True\\n ):\\n stack.append(next_node)\\n\\n # Construct the tree\\n num_nodes = len(nodes)\\n children = np.full([num_nodes, max_num_children], 0, dtype=np.int64)\\n prev_subword_idx = np.full([num_nodes], subword_dict.pad(), dtype=np.int64)\\n word_idx = np.full([num_nodes], -1, dtype=np.int64)\\n word_set_idx = np.full([num_nodes, 2], word_dict.pad(), dtype=np.int64)\\n\\n for node_id in range(1, len(nodes)): # skip 0, which is `None`\\n node = nodes[node_id]\\n # Guarantee that the children are traversed ascendingly according to the subword index\\n for i, (subword_id, child) in enumerate(\\n sorted(node.children.items(), key=lambda t: t[0])\\n ):\\n child_node_id = node_to_id_dict[child]\\n children[node_id, i] = child_node_id\\n prev_subword_idx[child_node_id] = subword_id\\n\\n word_idx[node_id] = node.word_idx\\n if node.word_set is not None:\\n word_set_idx[node_id] = node.word_set\\n else:\\n word_set_idx[node_id] = [0, len(word_dict) - 1]\\n\\n return TensorizedPrefixTree(\\n children=torch.from_numpy(children),\\n prev_subword_idx=torch.from_numpy(prev_subword_idx),\\n word_idx=torch.from_numpy(word_idx),\\n word_set_idx=torch.from_numpy(word_set_idx),\\n )\",\n \"def generateTreesRecursive(self, start: int, end: int) -> List[Optional[TreeNode]]:\\n if start > end:\\n return [None] # to set cur_root.left = None\\n\\n all_trees = []\\n\\n for val in range(start, end + 1):\\n # cur_root = TreeNode(val)\\n\\n # get left subtrees (less than val)\\n left_subtrees = self.generateTreesRecursive(start, val - 1)\\n # get right subtrees (greater than val)\\n right_subtrees = self.generateTreesRecursive(val + 1, end)\\n\\n for l_subtree in left_subtrees:\\n for r_subtree in right_subtrees:\\n cur_root = TreeNode(val)\\n cur_root.left = l_subtree\\n cur_root.right = r_subtree\\n\\n # cur_root is now the root of a BST\\n all_trees.append(cur_root)\\n\\n return all_trees\",\n \"def _build_tree(nodes):\\n\\n tree = []\\n\\n for trace_id in nodes:\\n node = nodes[trace_id]\\n node.setdefault(\\\"children\\\", [])\\n parent_id = node[\\\"parent_id\\\"]\\n if parent_id in nodes:\\n nodes[parent_id].setdefault(\\\"children\\\", [])\\n nodes[parent_id][\\\"children\\\"].append(node)\\n else:\\n tree.append(node) # no parent => top-level node\\n\\n for node in nodes:\\n nodes[node][\\\"children\\\"].sort(key=lambda x: x[\\\"info\\\"][\\\"started\\\"])\\n\\n return sorted(tree, key=lambda x: x[\\\"info\\\"][\\\"started\\\"])\",\n \"def compare_topology(tree1, tree2):\\n n2p1, n2p2 = ({node.name: node.parent.name\\n for node in tree.traverse() if not node.is_root()}\\n for tree in (tree1, tree2))\\n return n2p1 == n2p2\",\n \"def greedy_build(nodes, priors=None, cutoff=200, considered=set(), uniq='', targets=[]):\\n\\n\\t# Tracks frequency of states for each character in nodes\\n\\tcharacter_mutation_mapping = defaultdict(int)\\n\\n\\t# G models the network that is returned recursively\\n\\tG = nx.DiGraph()\\n\\n\\troot = root_finder(nodes)\\n\\n\\t# Base case check for recursion, returns a graph with one node corresponding to the root of the remaining nodes\\n\\tif len(nodes) <= cutoff or len(nodes) == 1:\\n\\t\\troot = root_finder(nodes)\\n\\t\\tG.add_node(root)\\n\\t\\treturn G, [[root, nodes]]\\n\\n\\t# Accounting for frequency of mutated states per character, in order to choose the best split\\n\\tfor node in nodes:\\n\\t\\tnode_list = node.split(\\\"_\\\")[0].split('|')\\n\\t\\tfor i in range(0, len(node_list)):\\n\\t\\t\\tchar = node_list[i]\\n\\t\\t\\tif char != '0' and char != '-':\\n\\t\\t\\t\\tcharacter_mutation_mapping[(str(i), char)] += 1\\n #if char != '0':\\n # if char == \\\"-\\\":\\n # character_mutation_mapping[(str(i), char)] -= 1\\n # else:\\n # character_mutation_mapping[(str(i), char)] += 1\\n\\n\\t# Choosing the best mutation to split on (ie character and state)\\n\\tcharacter, state = 0, 0\\n\\tmax_cost = 0\\n\\n\\tmin_prior = 1\\n\\tif priors:\\n\\t\\tfor i in priors.keys():\\n\\t\\t\\tfor j in priors[i].keys():\\n\\t\\t\\t\\tmin_prior = min(min_prior, priors[i][j])\\n\\n\\tfor i,j in character_mutation_mapping:\\n\\t\\tif not (i,j) in considered:\\n\\t\\t\\tif not priors:\\n\\t\\t\\t\\tif max_cost < character_mutation_mapping[(i, j)]:\\n\\t\\t\\t\\t\\tmax_cost = character_mutation_mapping[(i, j)]\\n\\t\\t\\t\\t\\tcharacter, state = i, j\\n\\t\\t\\telse:\\n\\t\\t\\t\\tif j not in priors[int(i)]:\\n\\t\\t\\t\\t\\tpriors[int(i)][j] = min_prior\\n\\t\\t\\t\\tif max_cost < -np.log(priors[int(i)][j]) * character_mutation_mapping[(i, j)]:\\n\\t\\t\\t\\t\\tmax_cost = -np.log(priors[int(i)][j]) * character_mutation_mapping[(i, j)]\\n\\t\\t\\t\\t\\tcharacter, state = i, j\\n\\tcharacter = int(character)\\n\\n\\n\\t# If there is no good split left, stop the process and return a graph with the remainder of nodes\\n\\tif character == 0 and state == 0:\\n\\t\\tif len(nodes) == 1:\\n\\t\\t\\tG.add_node(nodes[0])\\n\\t\\telse:\\n\\t\\t\\tfor i in range(0, len(nodes)):\\n\\t\\t\\t\\tif nodes[i] != root:\\n\\t\\t\\t\\t\\tG.add_edge(root, nodes[i])\\n\\t\\treturn G, []\\n\\n\\t# Splitting nodes based on whether they have the mutation, don't have the mutation, or are NA('-') in that character\\n\\t# Right split is where nodes with the mutation go, everyone else goes to left split or NA chars\\n\\tleft_split, right_split, NA_chars = [], [], []\\n\\tright_split_temp = []\\n\\tleft_split_temp = []\\n\\tfor node in nodes:\\n\\t\\tnode_list = node.split('|')\\n\\t\\tif node_list[character] == state:\\n\\t\\t\\tright_split.append(node)\\n\\t\\telif node_list[character] == '-':\\n\\t\\t\\tNA_chars.append(node)\\n\\t\\telse:\\n\\t\\t\\tleft_split.append(node)\\n\\n\\n\\t# Seperates all nodes with NA in the character chosen to be split upon\\n\\t# Puts in right split or left split based on which list shares more mutated characters with this string\\n\\tfor node in NA_chars:\\n\\t\\tright_split_score = 0\\n\\t\\tleft_split_score = 0\\n\\t\\tnode_list = node.split('|')\\n\\t\\tnum_not_missing = len([n for n in node_list if n != \\\"-\\\"])\\n\\t\\tfor i in range(0, len(node_list)):\\n\\t\\t\\tif node_list[i] != '0' and node_list[i] != '-':\\n\\t\\t\\t\\tfor node_2 in left_split:\\n\\t\\t\\t\\t\\tnode2_list = node_2.split('|')\\n\\t\\t\\t\\t\\tif node_list[i] == node2_list[i]:\\n\\t\\t\\t\\t\\t\\tleft_split_score += 1\\n\\t\\t\\t\\tfor node_2 in right_split:\\n\\t\\t\\t\\t\\tnode2_list = node_2.split('|')\\n\\t\\t\\t\\t\\tif node_list[i] == node2_list[i]:\\n\\t\\t\\t\\t\\t\\tright_split_score += 1\\n\\n\\t\\tavg_left_split_score = left_split_score / float(len(left_split) * num_not_missing + 1)\\n\\t\\tavg_right_split_score = right_split_score / float(len(right_split) * num_not_missing + 1)\\n\\n\\t\\tif avg_left_split_score < avg_right_split_score:\\n\\t\\t\\tright_split_temp.append(node)\\n\\t\\telse:\\n\\t\\t\\tleft_split_temp.append(node)\\n\\n\\tright_split += right_split_temp\\n\\tleft_split += left_split_temp\\n\\n\\t# Add character, state that split occurred to already considered mutations\\n\\tconsidered.add((str(character), state))\\n\\tG = nx.DiGraph()\\n\\t#splitter = str(character) + \\\" \\\" + str(state) + \\\" (\\\" + uniq + \\\")\\\"\\n\\tsplitter = root\\n\\n\\t# Recursively build left side of network (ie side that did not mutation at the character with the specific state)\\n\\tG.add_node(splitter)\\n\\tleft_subproblems = []\\n\\tleft_network = None\\n\\tif len(left_split) != 0:\\n\\t\\tleft_root = root_finder(left_split)\\n\\t\\t# if left_root not in left_split and left_root in targets:\\n\\t\\t# \\tleft_root = left_root + \\\"_unique\\\"\\n\\n\\t\\tleft_network, left_subproblems = greedy_build(left_split, priors, cutoff, considered.copy(), uniq + \\\"0\\\", targets=targets)\\n\\n\\t\\tleft_nodes = [node for node in left_network.nodes() if left_network.in_degree(node) == 0]\\n\\t\\tdup_dict = {}\\n\\t\\tfor n in left_network:\\n\\t\\t\\tif n in list(G.nodes()) and n != left_root:\\n\\t\\t\\t\\tdup_dict[n] = n + \\\"_\\\" + str(hashlib.md5(left_root.encode('utf-8')).hexdigest())\\n\\t\\tleft_network = nx.relabel_nodes(left_network, dup_dict)\\n\\t\\tG = nx.compose(G, left_network)\\n\\t\\tif root != left_root:\\n\\t\\t\\tG.add_edge(splitter, left_root, weight=0, label=\\\"None\\\")\\n\\n\\t# Recursively build right side of network\\n\\tright_network, right_subproblems = greedy_build(right_split, priors, cutoff, considered.copy(), uniq + \\\"1\\\", targets=targets)\\n\\tright_nodes = [node for node in right_network.nodes() if right_network.in_degree(node) == 0]\\n\\tright_root = root_finder(right_split)\\n\\n\\tdup_dict = {}\\n\\tfor n in right_network:\\n\\t\\tif n in list(G.nodes()) and n != right_root:\\n\\t\\t\\tdup_dict[n] = n + \\\"_\\\" + str(hashlib.md5(right_root.encode('utf-8')).hexdigest())\\n\\tfor n in dup_dict:\\n\\t\\trename_dict = {n: dup_dict[n]}\\n\\t\\tif right_network.out_degree(n) != 0:\\n\\t\\t\\tright_network = nx.relabel_nodes(right_network, rename_dict)\\n\\t\\telse:\\n\\t\\t\\trename_dict = {n: dup_dict[n]}\\n\\t\\t\\tG = nx.relabel_nodes(G, rename_dict)\\n\\n\\tG = nx.compose(G, right_network)\\n\\t# if right_root not in right_split and right_root in targets:\\n\\t# \\tright_root = right_root + \\\"_unique\\\"\\n\\t#for node in right_nodes:\\n\\tif root != right_root:\\n\\t\\tif not priors:\\n\\t\\t\\tG.add_edge(splitter, right_root, weight=1, label = str(character) + \\\": 0 -> \\\" + str(state))\\n\\t\\telse:\\n\\t\\t\\tG.add_edge(splitter, right_root, weight=-np.log(priors[int(character)][state]), label=str(character) + \\\": 0 -> \\\" + str(state))\\n\\n\\n\\treturn G, left_subproblems + right_subproblems\",\n \"def merge_nodes(self):\\n\\n\\t\\t\\t#obtenemos los dos primeros nodos que equivalen a quienes tienen menor frecuencia\\n\\t\\t\\twhile(len(self.heap)>1):\\n\\t\\t\\t\\tnode1 = heapq.heappop(self.heap)\\n\\t\\t\\t\\tnode2 = heapq.heappop(self.heap)\\n\\n\\t\\t\\t\\tmerged = self.HeapNode(None, node1.freq + node2.freq)#creamos un nodo padre que va a contener los nodos anteriores a la derecha y izquierda\\n\\t\\t\\t\\tmerged.left = node1\\n\\t\\t\\t\\tmerged.right = node2\\n\\n\\t\\t\\t\\theapq.heappush(self.heap, merged)#agregamos este nodo al priority queue\",\n \"def merge(self):\\n collapsable = self.findSameSubtrees()\\n\\n dummy = GraphiusNode(-1, None)\\n for i, node in self.nodes.items():\\n dummy.addNeighbor(node)\\n\\n # Perform the merge\\n self.mergeHelper(dummy, collapsable)\\n\\n # Regenerate trees\\n newNodes = self.dfs(dummy)\\n assert(-1 not in newNodes)\\n self.nodes = newNodes\",\n \"def test_build_match_tree_with_pairs():\\n abbreviation_list = [[\\\"ELIF\\\", \\\"ELI.\\\"], [\\\"ELSE\\\", \\\"E.\\\"]]\\n expected_tree = {\\\"E\\\": {\\\"L\\\": {\\\"I\\\": {\\\"F\\\": \\\"ELI.\\\"}, \\\"S\\\": {\\\"E\\\": \\\"E.\\\"}}}}\\n tree = build_match_tree(abbreviation_list)\\n assert repr(tree) == repr(expected_tree)\",\n \"def buildTree(self, nums, start, end):\\n if start > end: # did not have this stop condition causing error of corner case: nums=[]\\n return None\\n node = SegmentTreeNode(start, end)\\n if start == end:\\n node.val = nums[start]\\n else:\\n mid = start+(end-start)/2\\n left = self.buildTree(nums, start, mid)\\n right = self.buildTree(nums, mid+1, end)\\n node.left, node.right = left, right\\n node.val = left.val + right.val \\n # node.val = (left.val if left else 0) + (right.val if right else 0) : not necessary because non-leaf node always have two children\\n return node\",\n \"def subtree_cond_pdf(tree1, tree2, tree2_subtree_nodes, new):\\n\\n # if new is isolated in the underlying graph\\n\\n #if len(tree2_subtree_nodes) == 1 and tree2_subtree_nodes.values()[0] is None:\\n if len(tree2_subtree_nodes) == 1 and list(tree2_subtree_nodes.values())[0] is None:\\n sep = frozenset([])\\n c = frozenset([new])\\n lognu = trilearn.graph.junction_tree.log_nu(tree2, sep)\\n return ({c: np.exp(-lognu)}, {c: 1.0})\\n\\n # Get the subtree induced by the nodes\\n #tree1_subtree = tree1.subgraph([c_t1 for c_t2, c_t1 in tree2_subtree_nodes.iteritems()])\\n tree1_subtree = tree1.subgraph([c_t1 for c_t2, c_t1 in tree2_subtree_nodes.items()])\\n\\n\\n # Get the separating sets\\n # S = sepsets_in_subgraph(tree2_subtree_nodes, tree1_subtree)\\n\\n # S = {c: set() for c_t2, c in tree2_subtree_nodes.iteritems()}\\n S = {c: set() for c_t2, c in tree2_subtree_nodes.items()}\\n #for c_tree2, c in tree2_subtree_nodes.iteritems():\\n for c_tree2, c in tree2_subtree_nodes.items():\\n for neig in tree1_subtree.neighbors(c):\\n S[c] = S[c] | (c & neig)\\n\\n # P, N get_subset_probabilities(tree2_)\\n # Get the chosen internal nodes\\n M = {}\\n # for c_tree2, c in tree2_subtree_nodes.iteritems():\\n for c_tree2, c in tree2_subtree_nodes.items():\\n M[c] = c_tree2 - {new} - S[c]\\n\\n # Calculate probabilities corresponding to each clique\\n P = {}\\n N = {}\\n # for c_tree2, c in tree2_subtree_nodes.iteritems():\\n for c_tree2, c in tree2_subtree_nodes.items():\\n neigs = {neig for neig in tree1.neighbors(c) if\\n neig & c <= c_tree2 and neig not in tree1_subtree.nodes()}\\n RM = c - S[c]\\n gamma = tree1_subtree.order()\\n # sepCondition = len({neig for neig in nx.neighbors(tree1_subtree, c) if\\n # S[c] == neig & c}) > 0 or gamma == 1\\n sepCondition = len({neig for neig in tree1_subtree.neighbors(c) if\\n S[c] == neig & c}) > 0 or gamma == 1\\n\\n N[c] = 1.0\\n #N[c] = Fraction(1,1)\\n if sepCondition is False:\\n # Every internal node in c belongs to a separator\\n P[c] = np.power(2.0, - len(RM))\\n #P[c] = Fraction(1, 2 ** len(RM))\\n if not len(c) + 1 == len(c_tree2):\\n N[c] = np.power(2.0, -len(neigs))\\n #N[c] = Fraction(1, 2**len(neigs))\\n else:\\n P[c] = 1.0\\n if len(RM) > 1:\\n P[c] = (1.0 / len(RM)) * np.power(2.0, -(len(RM) - 1.0)) * len(M[c])\\n #P[c] = Fraction(1, len(RM)) * Fraction(len(M[c]), 2 ** (len(RM) - 1.0)) \\n if not len(c) + 1 == len(c_tree2):\\n N[c] = np.power(2.0, -len(neigs))\\n #N[c] = Fraction(1, 2**len(neigs))\\n return (P, N)\",\n \"def match_nodes(source_node, target_node):\\n\\n node_position = cmds.xform(source_node, q=True, ws=True, t=True)\\n node_rotation = cmds.xform(source_node, q=True, ws=True, ro=True)\\n cmds.xform(target_node, ws=True, t=node_position)\\n cmds.xform(target_node, ws=True, ro=node_rotation)\",\n \"def iterative_solution(list1, list2):\\n pre_root = Node(-1)\\n prev = pre_root\\n\\n while list1 and list2:\\n if list1.data <= list2.data:\\n prev.next = list1\\n list1 = list1.next\\n else:\\n prev.next = list2\\n list2 = list2.next\\n prev = prev.next\\n\\n if not list1:\\n prev.next = list2\\n else:\\n prev.next = list1\\n\\n return pre_root.next\",\n \"def compare_trees(tree1, tree2):\\n for key in tree1.keys():\\n print(key)\\n assert key in tree2.keys()\\n if isinstance(tree1[key], list):\\n print(tree1[key])\\n assert tree1[key] == tree2[key]\\n else:\\n print('Calling compare_trees recursively')\\n compare_trees(tree1[key], tree2[key])\",\n \"def get_subgraph_between_nodes(self, start, end):\\n nodes = set()\\n nodes.add(start)\\n\\n to_visit = set()\\n to_visit.add(start)\\n\\n while len(to_visit) > 0:\\n current_visit = copy.copy(to_visit)\\n for tv in current_visit:\\n to_visit.remove(tv)\\n if tv is not end:\\n for s in self.successors(tv):\\n to_visit.add(s)\\n nodes.add(s)\\n\\n nodes.add(end)\\n\\n return self.subgraph(nodes)\",\n \"def equals_list_nodes(self, self_list_nodes, other_list_nodes):\\n\\n #If the two list of nodes have different lengths, they are automatically different\\n if len(self_list_nodes) != len(other_list_nodes):\\n return False\\n else:\\n\\n #We sort both list of nodes\\n self_list_nodes = sorted(self_list_nodes, key=lambda x : x.num)\\n other_list_nodes = sorted(other_list_nodes, key=lambda x : x.num)\\n\\n #For each node in both lists\\n for i, node in enumerate(self_list_nodes):\\n\\n #We check if the length of the list of the nodes they are connected to are the same\\n if len(node.connected_to) != len(other_list_nodes[i].connected_to):\\n return False\\n else:\\n #We check if the connection between the nodes in both list is the same\\n node_connected_to = sorted(node.connected_to, key=lambda x : x.num)\\n other_node_connected_to = sorted(self_list_nodes[i].connected_to, key=lambda x : x.num)\\n for j, node_connec in enumerate(node_connected_to):\\n if node_connec.num != other_node_connected_to[j].num:\\n return False\\n return True\",\n \"def build_tree(preorder, inorder):\\n\\n # Base case\\n if preorder == [] or inorder == []:\\n return\\n\\n root = preorder[0]\\n\\n # Breaks the lists by root, left side, and right side\\n in_index = inorder.index(root)\\n in_left = inorder[:in_index]\\n in_right = inorder[in_index + 1:]\\n pre_left = preorder[1 : len(in_left) + 1]\\n pre_right = preorder[len(in_left) + 1 :]\\n\\n # Recursively creates smaller binary trees to make a big binary tree\\n tree = BinaryTree(root)\\n tree.set_left(build_tree(pre_left, in_left))\\n tree.set_right(build_tree(pre_right, in_right))\\n\\n return tree\",\n \"def build_tree(self):\\n stack = []\\n self._handle_solo_node_case()\\n while self.root_hash == None:\\n if len(stack) >= 2 and stack[-1].height == stack[-2].height:\\n mom = stack.pop()\\n dad = stack.pop()\\n child_hash = self.sha256Sum(mom.hash + dad.hash)\\n child = self.Node(mom, dad, child_hash)\\n self.node_table[child_hash] = child\\n mom.child = child\\n dad.child = child\\n\\n if child.height == self.max_height:\\n self.root_hash = child.hash\\n\\n stack.append(child)\\n elif len(self.leaves) > 0:\\n leaf = self.leaves.pop()\\n self.node_table[leaf.hash] = leaf\\n stack.append(leaf)\\n # Handle case where last 2 nodes do not match in height by \\\"graduating\\\"\\n # last node\\n else:\\n stack[-1].height += 1\\n self.is_built = True\",\n \"def huffman_tree(left, right):\\n return tree(root(left) + root(right), [left, right])\",\n \"def _sorted_list_to_bst(cls, items=[], start=None, end=None, parent=None):\\n if start > end:\\n return None\\n mid = start + (end - start) // 2\\n node = Node(items[mid], parent)\\n node.left = cls._sorted_list_to_bst(items, start, mid - 1, node)\\n node.right = cls._sorted_list_to_bst(items, mid + 1, end, node)\\n return node\",\n \"def merge_personroots_of_two_nodes(name1: str, value1: str,\\n name2: str, value2: str) -> None:\\n left_node = read_node(name=name1, value=value1)\\n right_node = read_node(name=name2, value=value2)\\n if left_node is None or right_node is None:\\n return\\n\\n left_personroot_node = get_or_create_personroot_node(person_node=left_node)\\n right_personroot_node = get_or_create_personroot_node(person_node=right_node)\\n if left_personroot_node is None or right_personroot_node is None:\\n return\\n\\n if left_personroot_node == right_personroot_node:\\n # They are already connected, we are done.\\n return\\n\\n merge_two_personroot_nodes(left_personroot_node=left_personroot_node,\\n right_personroot_node=right_personroot_node)\\n return\",\n \"def sort_nodes(center_node, nodes):\\n def cmp(n1, n2):\\n angle1 = (math.degrees(center_node.angle_to(n1)) + 360.) % 360\\n angle2 = (math.degrees(center_node.angle_to(n2)) + 360.) % 360\\n\\n if angle1 < angle2:\\n return -1\\n elif angle1 == angle2:\\n return 0\\n else:\\n return 1\\n return sorted(nodes, cmp=cmp)\",\n \"def _match_identical_nodes(self):\\n\\n for job_name_b in self._topo_b_nodes:\\n for job_name_a in self._unresolved_a_nodes:\\n if self._is_node_identical(job_name_a, job_name_b):\\n self._identical_nodes[job_name_b] = job_name_a\\n self._unresolved_a_nodes.remove(job_name_a)\\n self._unresolved_b_nodes.remove(job_name_b)\\n break\",\n \"def create_tree(self, tree):\\n # print(self)\\n if len(self.available_combinations()) > 1:\\n comb1 = random.choice(self.available_combinations())\\n comb2 = random.choice(self.available_combinations())\\n\\n if self.last_move == 5:\\n next_move = 7\\n else:\\n next_move = 5\\n\\n # print(next_move)\\n\\n board1 = copy.deepcopy(self)\\n board2 = copy.deepcopy(self)\\n\\n board1.board[comb1[0]][comb1[1]] = next_move\\n board1.last_move = 7\\n tree.insert_left(board1)\\n board2.board[comb2[0]][comb2[1]] = next_move\\n board2.last_move = 7\\n tree.insert_right(board2)\\n\\n board1.create_tree(tree.get_left_child())\\n board2.create_tree(tree.get_left_child())\",\n \"def all_nodes_dfs(log_T, initial_state, min_score, sub_info, max_depth=1000000000000000000, maxtraversals=1000000000000000000):\\n # default argument for sub_info: empty_sub_info = (np.array([], dtype=int), np.array([], dtype=int), 1000000000000000000)\\n min_score = float(min_score) # make sure numba knows this is a float (otherwise, sometimes, it doesn't (bug in numba))\\n order = np.zeros(log_T.shape, np.int64)\\n for i in xrange(order.shape[1]):\\n order[i] = (-log_T[i]).argsort()\\n n_states = log_T.shape[0]\\n node = [order[initial_state, 0]] # most likely first node\\n node_idx = [0]\\n lengths_dfs = [-1.0]\\n nodes_dfs = [[-1, ]]\\n for it in xrange(maxtraversals):\\n # score and return current node if adequate\\n score = log_T[initial_state, node[0]]\\n for p in xrange(1, len(node)):\\n score += log_T[node[p - 1], node[p]]\\n if min_score <= score and syntax_check(np.array(node), sub_info, partial=False):\\n lengths_dfs.append(-score)\\n nodes_dfs.append(list(node))\\n # next node ##\\n # try adding a value at the end\\n for next_idx, next_state in enumerate(order[node[-1]]):\\n if min_score <= score + log_T[node[-1], next_state] and len(node) < max_depth \\\\\\n and syntax_check(np.array(node + [next_state]), sub_info, partial=True):\\n node.append(next_state)\\n node_idx.append(next_idx)\\n break\\n # adding a value at the end failed, so we are a leave\\n else:\\n for p in xrange(len(node) - 1, -1, -1):\\n if node_idx[p] != n_states - 1: # find where within the node to increase (and discard all others after)\\n old_idx = node_idx[p]\\n del node_idx[p:]\\n del node[p:]\\n node_idx.append(old_idx + 1)\\n prev_state = node[p - 1] if p > 0 else initial_state\\n node.append(order[prev_state, node_idx[p]])\\n break\\n else:\\n break # end of the generator, can't increase even the root\\n else:\\n assert False, \\\"Number of traversals exceeded\\\"\\n\\n return lengths_dfs[1:], nodes_dfs[1:]\",\n \"def _get_sequence_based_sorting_keys(self):\\n left_event_defs = self._left_subtree.get_event_definitions()\\n right_event_defs = self._right_subtree.get_event_definitions()\\n # comparing min and max leaf index of two subtrees\\n min_left = min(left_event_defs, key=lambda x: x.index).index # [ { ] } or [ { } ]\\n max_left = max(left_event_defs, key=lambda x: x.index).index # { [ } ] or { [ ] }\\n min_right = min(right_event_defs, key=lambda x: x.index).index # [ ] { }\\n max_right = max(right_event_defs, key=lambda x: x.index).index # { } [ ]\\n if max_left < min_right: # 3)\\n left_sort, right_sort, rel_op = -1, 0, RelopTypes.SmallerEqual\\n elif max_right < min_left: # 4)\\n left_sort, right_sort, rel_op = 0, -1, RelopTypes.GreaterEqual\\n elif min_left < min_right: # 1)\\n left_sort, right_sort, rel_op = 0, 0, RelopTypes.SmallerEqual\\n elif min_right < min_left: # 2)\\n left_sort, right_sort, rel_op = 0, 0, RelopTypes.GreaterEqual\\n if rel_op is None:\\n raise Exception(\\\"rel_op is None, something bad has happened\\\")\\n left_sorting_key = lambda pm: pm.events[left_sort].timestamp\\n right_sorting_key = lambda pm: pm.events[right_sort].timestamp\\n # left/right_sort == 0 means that left/right subtree will be sorted by first timestamp\\n return left_sorting_key, right_sorting_key, rel_op, (left_sort == 0), (right_sort == 0)\",\n \"def join_nodes(trees, leaves, maps, nodeA, nodeB):\\n cladeA = get_leaf_set(nodeA)\\n cladeB = get_leaf_set(nodeB)\\n\\n if len(cladeA.intersection(cladeB)) > 0:\\n raise Exception(\\\"Nodes are not disjoint on their leaf sets!\\\\n\\\")\\n\\n edits = [False] * len(trees)\\n for i, edit in enumerate(edits):\\n leaf = leaves[i]\\n\\n if cladeA == leaf:\\n nodeAinT = nodeA\\n else:\\n nodeAinT = get_node_from_clade(trees[i], maps[i], cladeA)\\n\\n if cladeB == leaf:\\n nodeBinT = nodeB\\n else:\\n nodeBinT = get_node_from_clade(trees[i], maps[i], cladeB)\\n\\n nAinT = nodeAinT is not None\\n nBinT = nodeBinT is not None\\n\\n if nAinT and nBinT:\\n # Node A and node B are both in T, do nothing!\\n pass\\n elif nAinT:\\n # Add node B to T\\n edits[i] = True\\n root = dendropy.Node()\\n root.add_child(deepcopy(nodeB)) # TODO: Remove deep copies!\\n if leaves[i] == cladeA:\\n nodeAinT.parent_node = None\\n root.add_child(nodeAinT)\\n else:\\n [tree, nodeAinT] = extract_nodes_from_split(trees[i], nodeAinT,\\n cladeA)\\n root.add_child(tree.seed_node)\\n trees[i] = dendropy.Tree(seed_node=root)\\n trees[i].is_rooted = True\\n elif nBinT:\\n # Add node A to T\\n edits[i] = True\\n root = dendropy.Node()\\n root.add_child(deepcopy(nodeA)) # TODO: Remove deep copies!\\n if leaves[i] == cladeB:\\n nodeBinT.parent_node = None\\n root.add_child(nodeBinT)\\n else:\\n [tree, nodeBinT] = extract_nodes_from_split(trees[i], nodeBinT,\\n cladeB)\\n root.add_child(tree.seed_node)\\n trees[i] = dendropy.Tree(seed_node=root)\\n trees[i].is_rooted = True\\n else:\\n # Neither node A or node B is in T, do nothing!\\n pass\\n\\n return [trees, edits]\",\n \"def isSameTree(self, node1, node2):\\n # print(\\\"isSameTree call for {} and {}\\\".format(node1.id, node2.id))\\n\\n if node1.id == node2.id:\\n return True\\n if node1.value == node2.value:\\n # Compare children, in sorted order based on value\\n node1Children = list(\\n sorted(\\n node1.neighbors,\\n key=lambda node:\\n node.value))\\n node2Children = list(\\n sorted(\\n node2.neighbors,\\n key=lambda node:\\n node.value))\\n\\n if len(node1Children) == len(node2Children):\\n # For identical trees, A list of nieghbors\\n # in sorted (based on value) order:\\n # Should have same length\\n # At each position, values are same (verify recursively)\\n for i in range(len(node1Children)):\\n if not self.isSameTree(node1Children[i], node2Children[i]):\\n return False\\n # All neighbor pairs verified\\n return True\",\n \"def neighborJoining(distances):\\n\\n tree = {}\\n\\n while(len(distances.keys()) > 2):\\n\\n r = calcRs(distances)\\n M = makeMMatrix(distances, r)\\n\\n smallest = 10000\\n smallestKey = (\\\"\\\",\\\"\\\")\\n\\n #Find nearest neighbors\\n for key in M.keys():\\n for subkey in M[key].keys():\\n if M[key][subkey] < smallest:\\n smallest = M[key][subkey]\\n smallestKey = (key, subkey)\\n\\n #Add new node and update distances to rest of tree\\n newname = smallestKey[0] + \\\"-\\\" + smallestKey[1]\\n distances[newname] = {}\\n tree[smallestKey[0]] = {}\\n tree[smallestKey[1]] = {}\\n dij = distances[smallestKey[0]][smallestKey[1]]\\n for key in M.keys():\\n if key in smallestKey:\\n continue\\n distances[newname][key] = .5*(distances[smallestKey[0]][key] \\\\\\n + distances[smallestKey[1]][key] - dij)\\n distances[key][newname] = distances[newname][key]\\n\\n #Update distances to parents of node\\n dik = (dij + r[smallestKey[0]] - r[smallestKey[1]])/2\\n tree[smallestKey[0]][newname] = dik\\n tree[smallestKey[1]][newname] = dij-dik\\n detachDict(distances, smallestKey[0], smallestKey[1])\\n\\n #Connect final two nodes\\n tree[distances.keys()[0]] = {}\\n tree[distances.keys()[0]][distances[distances.keys()[0]].keys()[0]] =\\\\\\n distances[distances.keys()[0]][distances[distances.keys()[0]].keys()[0]] \\n return tree\",\n \"def merge_nodes(self,n0,n1):\\n # -- Sanity checks - does not yet allow for collapsing edges.\\n\\n # if they share any cells, would update the cells, but for now\\n # just signal failure.\\n n0_cells=list(self.node_to_cells(n0))\\n n1_cells=list(self.node_to_cells(n1))\\n cell_to_edge_cache={}\\n\\n for c in n1_cells:\\n if c in n0_cells:\\n print(\\\"cell %d common to both nodes\\\"%c)\\n raise GridException(\\\"Not ready for merging nodes in the same cell\\\")\\n # otherwise record and fix up below\\n\\n # while we're looping, cache the edges as they will\\n # be mutated along the way.\\n cell_to_edge_cache[c]=self.cell_to_edges(c).copy()\\n\\n # do they share an edge, but not already fixed in the above stanza?\\n j=self.nodes_to_edge(n0,n1)\\n if j is not None:\\n raise GridException(\\\"Not ready for merging endpoints of an edge\\\")\\n\\n edge_map={} # index of superceded edge => superceding edge\\n\\n # Update edges of n1 to point to n0\\n # if that would cause a duplicate edge, then the n1 version is deleted\\n n1_edges=list(self.node_to_edges(n1)) # make copy since we'll mutate it\\n for j in n1_edges:\\n if self.edges['nodes'][j,0]==n1:\\n nj=0\\n elif self.edges['nodes'][j,1]==n1:\\n nj=1\\n else:\\n assert False # sanity check\\n newnodes=self.edges[j]['nodes'].copy()\\n newnodes[nj]=n0\\n # it's possible that this is an edge which already exists\\n jother=self.nodes_to_edge(*newnodes)\\n if jother is not None:\\n # want to keep jother, delete j. but is there info on\\n # cells which should be brought over?\\n edge_map[j]=jother\\n # wait to delete j until after cells have been moved to jother.\\n else:\\n self.log.debug(\\\"Modifying edge j=%d\\\"%j)\\n self.modify_edge(j,nodes=newnodes)\\n\\n # -- Transition any cells. \\n for c in n1_cells:\\n # update the node list:\\n cnodes=self.cell_to_nodes(c).copy()\\n nc=list(cnodes).index(n1)\\n cnodes[nc]=n0\\n\\n # Dangerous to use cell_to_edges, since it may\\n # have to consult the edge topology, which is disrupted\\n # in the above code. \\n # cell_to_edges: first checks cells['edges'], may \\n # go to cell_to_nodes(c): that's safe.\\n # and nodes_to_edge\\n # -> node_to_edges, which in turn may consult self.edges['nodes']\\n\\n #cedges=self.cell_to_edges(c).copy()\\n cedges=cell_to_edge_cache[c]\\n\\n for ji,j in enumerate(cedges):\\n if j in edge_map:\\n # is there were edges['cells'] should be updated?\\n\\n # sever the edge=>cell pointer, to p\\n # could just set to [-1,-1], but this keeps things very explicit\\n # for debugging\\n j_cells=list(self.edges['cells'][j])\\n j_cells_side=j_cells.index(c)\\n j_cells[ j_cells_side ] = -1\\n self.modify_edge(j,cells=j_cells)\\n\\n # and modify the receiving edge, too\\n jo=edge_map[j]\\n jo_cells=list(self.edges['cells'][jo])\\n # which side of jo? a bit tedious...\\n if list(self.edges['nodes'][j]).index(n1) == list(self.edges['nodes'][jo]).index(n0):\\n # same orientation\\n jo_cells_side=j_cells_side\\n elif list( self.edges['nodes'][j]).index(n1) == 1-list(self.edges['nodes'][jo]).index(n0):\\n jo_cells_side=1-j_cells_side\\n else:\\n raise Exception(\\\"Failed in some tedium\\\")\\n assert jo_cells[jo_cells_side]<0\\n jo_cells[jo_cells_side]=c\\n self.modify_edge(edge_map[j],cells=jo_cells)\\n # yikes. any chance that worked?\\n\\n cedges[ji]=edge_map[j]\\n\\n # maybe this is where we'd update cells['edges'] too?\\n self.modify_cell(c,nodes=cnodes,edges=cedges)\\n\\n for dead_edge in edge_map:\\n self.delete_edge(dead_edge)\\n\\n self.delete_node(n1)\",\n \"def build_nodes(self, tasks, clean_list):\\n for name in clean_list:\\n # add node itself if not in list of nodes\\n self.nodes.setdefault(name, [])\\n task = tasks[name]\\n # reversing not required\\n for dep_name in reversed(task.task_dep):\\n if tasks[dep_name].subtask_of == name:\\n rev_dep = self.nodes.setdefault(dep_name, [])\\n rev_dep.append(name)\",\n \"def job_tree(self):\\n\\n # 1. Enforce depth of 1 for steps\\n def depth_one(steps):\\n depth_one = []\\n for step in steps:\\n if type(step) is list:\\n if type(step[0]) is list:\\n depth_one.append(step[0])\\n else:\\n depth_one.append(step)\\n else:\\n depth_one.append([step])\\n return depth_one\\n\\n # 2. Convert steps to list of node objects (0,1,2,3...)\\n def assign_nodes(steps):\\n nodes = [i for i in range(len(steps))]\\n objects = list(\\n set([elem for sublist in steps for elem in sublist]))\\n\\n # checks for multiple src and dst objects -- added when looking for\\n # mutiples\\n split_objects = []\\n for obj in objects:\\n if len(obj) > 1:\\n new_objs = obj.split(\\\", \\\")\\n split_objects.extend(new_objs)\\n else:\\n split_objects.append(obj)\\n objects = split_objects\\n del(split_objects)\\n\\n # populate with leafless trees (Node objects, no edges)\\n for node in nodes:\\n nodes[node] = Node(str(node))\\n\\n # search for leafy trees\\n for obj in objects:\\n\\n # accounts for multiple drc/dst objects\\n leaves = []\\n for i, sublist in enumerate(steps):\\n for string in sublist:\\n if string.count(',') > 0:\\n if obj in string:\\n leaves.append(i)\\n else:\\n if obj in sublist:\\n leaves.append(i)\\n leaves = sorted(list(set(leaves)))\\n\\n if len(leaves) > 1:\\n viable_edges = []\\n\\n # compute cross-product\\n for leaf1 in leaves:\\n for leaf2 in leaves:\\n if str(leaf1) != str(leaf2) and sorted((leaf1, leaf2)) not in viable_edges:\\n viable_edges.append(sorted((leaf1, leaf2)))\\n\\n # form edge networks\\n for edge in viable_edges:\\n n1, n2 = nodes[edge[0]], nodes[edge[1]]\\n n1.add_edge(n2)\\n n2.add_edge(n1)\\n nodes[int(n1.name)], nodes[int(n2.name)] = n1, n2\\n return nodes\\n\\n # 3. Determine number of trees and regroup by connected nodes\\n def connected_nodes(nodes):\\n proto_trees = []\\n nodes = set(nodes)\\n\\n while nodes:\\n n = nodes.pop()\\n group = {n}\\n queue = [n]\\n while queue:\\n n = queue.pop(0)\\n neighbors = n.edges\\n neighbors.difference_update(group)\\n nodes.difference_update(neighbors)\\n group.update(neighbors)\\n queue.extend(neighbors)\\n proto_trees.append(group)\\n return proto_trees\\n\\n # 4. Convert nodes to nested dictionary of parent-children relations\\n # i.e. adding depth -- also deals with tree-node sorting and path\\n # optimization\\n def build_tree_dict(trees, steps):\\n # node sorting in trees\\n sorted_trees = []\\n for tree in trees:\\n sorted_trees.append(\\n sorted(tree, key=lambda x: int(x.name)))\\n\\n # retrieve values of the nodes (the protocol's containers)\\n # for each tree ... may want to use dictionary eventually\\n all_values = []\\n for tree in sorted_trees:\\n values = [steps[int(node.name)] for node in tree]\\n all_values.append(values)\\n\\n # create relational tuples:\\n all_digs = []\\n singles = []\\n dst_potentials = []\\n for tree_idx in range(len(sorted_trees)):\\n edge_flag = False\\n tree_digs = []\\n for node_idx in range(len(sorted_trees[tree_idx])):\\n\\n # digs: directed graph vectors\\n digs = []\\n dst_nodes = []\\n node_values = all_values[tree_idx][node_idx]\\n src_node = str(sorted_trees[tree_idx][node_idx].name)\\n\\n # ACTION ON MULTIPLE OBJECTS (E.G. TRANSFER FROM SRC -> DST\\n # WELLS)\\n # Outcome space: {1-1, 1-many, many-1, many-many}\\n if len(node_values) == 2:\\n # single destination (x-1)\\n if node_values[1].count(\\\",\\\") == 0:\\n dst_nodes = [i for i, sublist in enumerate(\\n steps) if node_values[1] == sublist[0]]\\n # multiple destinations (x-many)\\n elif node_values[1].count(\\\",\\\") > 0:\\n dst_nodes = []\\n for dst in node_values[1].replace(\\\", \\\", \\\"\\\"):\\n for i, sublist in enumerate(steps):\\n if i not in dst_nodes and dst == sublist[0]:\\n dst_nodes.append(i)\\n\\n # ACTION ON A SINGLE OBJECT\\n elif len(node_values) == 1:\\n dst_nodes = [i for i, sublist in enumerate(\\n steps) if node_values[0] == sublist[0]]\\n\\n # Constructing tuples in (child, parent) format\\n for dst_node in dst_nodes:\\n dig = (int(dst_node), int(src_node))\\n digs.append(dig)\\n\\n # else: an edge-case for dictionaries constructed with no edges\\n # initiates tree separation via flag\\n if digs != []:\\n edge_flag = False\\n tree_digs.append(digs)\\n else:\\n edge_flag = True\\n digs = [(int(src_node), int(src_node))]\\n tree_digs.append(digs)\\n\\n # digraph cycle detection: avoids cycles by overlooking set\\n # repeats\\n true_tree_digs = []\\n for digs in tree_digs:\\n for dig in digs:\\n if tuple(sorted(dig, reverse=True)) not in true_tree_digs:\\n true_tree_digs.append(\\n tuple(sorted(dig, reverse=True)))\\n\\n # edge-case for dictionaries constructed with no edges\\n if true_tree_digs != [] and edge_flag == False:\\n all_digs.append(true_tree_digs)\\n elif edge_flag == True:\\n all_digs.extend(tree_digs)\\n\\n # Enforces forest ordering\\n all_digs = sorted(all_digs, key=lambda x: x[0])\\n\\n # job tree traversal to find all paths:\\n forest = []\\n for digs_set in all_digs:\\n\\n # pass 1: initialize nodes dictionary\\n nodes = OrderedDict()\\n for tup in digs_set:\\n id, parent_id = tup\\n # ensure all nodes accounted for\\n nodes[id] = OrderedDict({'id': id})\\n nodes[parent_id] = OrderedDict({'id': parent_id})\\n\\n # pass 2: create trees and parent-child relations\\n for tup in digs_set:\\n id, parent_id = tup\\n node = nodes[id]\\n # links node to its parent\\n if id != parent_id:\\n # add new_node as child to parent\\n parent = nodes[parent_id]\\n if not 'children' in parent:\\n # ensure parent has a 'children' field\\n parent['children'] = []\\n children = parent['children']\\n children.append(node)\\n\\n desired_tree_idx = sorted(list(nodes.keys()))[0]\\n forest.append(nodes[desired_tree_idx])\\n return forest\\n\\n # 5. Convert dictionary-stored nodes to unflattened, nested list of\\n # parent-children relations\\n def dict_to_list(forest):\\n forest_list = []\\n for tree in forest:\\n tString = str(json.dumps(tree))\\n tString = tString.replace('\\\"id\\\": ', \\\"\\\").replace('\\\"children\\\": ', \\\"\\\").replace(\\n '[{', \\\"[\\\").replace('}]', \\\"]\\\").replace('{', \\\"[\\\").replace('}', \\\"]\\\")\\n\\n # find largest repeated branch (if applicable)\\n # maybe think about using prefix trees or SIMD extensions for better\\n # efficiency\\n x, y, length, match = 0, 0, 0, ''\\n for y in range(len(tString)):\\n for x in range(len(tString)):\\n substring = tString[y:x]\\n if len(list(re.finditer(re.escape(substring), tString))) > 1 and len(substring) > length:\\n match = substring\\n length = len(substring)\\n\\n # checking for legitimate branch repeat\\n if \\\"[\\\" in match and \\\"]\\\" in match:\\n hits = []\\n index = 0\\n if len(tString) > 3:\\n while index < len(tString):\\n index = tString.find(str(match), index)\\n if index == -1:\\n break\\n hits.append(index)\\n index += len(match)\\n\\n # find all locations of repeated branch and remove\\n if len(hits) > 1:\\n for start_loc in hits[1:]:\\n tString = tString[:start_loc] + \\\\\\n tString[start_loc:].replace(match, \\\"]\\\", 1)\\n\\n # increment all numbers in string to match the protocol\\n newString = \\\"\\\"\\n numString = \\\"\\\"\\n for el in tString:\\n if el.isdigit(): # build number\\n numString += el\\n else:\\n if numString != \\\"\\\": # convert it to int and reinstantaite numString\\n numString = str(int(numString) + 1)\\n newString += numString\\n newString += el\\n numString = \\\"\\\"\\n tString = newString\\n del newString\\n\\n forest_list.append(ast.literal_eval(tString))\\n return forest_list\\n\\n # 6. Print job tree(s)\\n def print_tree(lst, level=0):\\n print(' ' * (level - 1) + '+---' * (level > 0) + str(lst[0]))\\n for l in lst[1:]:\\n if type(l) is list:\\n print_tree(l, level + 1)\\n else:\\n print(' ' * level + '+---' + l)\\n\\n # 1\\n steps = depth_one(self.object_list)\\n # 2\\n nodes = assign_nodes(steps)\\n # 3\\n proto_forest = connected_nodes(nodes)\\n # 4\\n forest = build_tree_dict(proto_forest, steps)\\n # 5\\n self.forest_list = dict_to_list(forest)\\n # 6\\n print(\\\"\\\\n\\\" + \\\"A suggested Job Tree based on container dependency: \\\\n\\\")\\n for tree_list in self.forest_list:\\n print_tree(tree_list)\",\n \"def all_routing_tree_2(G, tors1, tors2, table_file_name):\\n \\n table = OrderedDict({})\\n for s in G.nodes():\\n table[s] = OrderedDict({})\\n for s in tors1:\\n for d in tors2:\\n if s != d:\\n routing(G, s, d, table)\\n for d in tors1:\\n for s in tors2:\\n if s != d:\\n routing(G, s, d, table)\\n\\n with open(table_file_name, 'w') as file:\\n file.write(json.dumps(table))\\n return table\",\n \"def build_tree(elements):\\n print(\\\"Building tree with these elements:\\\",elements)\\n root = BinarySearchTreeNode(elements[0])\\n\\n for i in range(1, len(elements)):\\n root.add_child(elements[i])\\n\\n return root\",\n \"def merge(list1, list2):\\n holding = list1.to_list()\\n [holding.append(i) for i in list2.to_list()]\\n # for i in list2.to_list():\\n # holding.append(i)\\n holding = sorted(holding)\\n\\n output = LinkedList(Node(holding[0]))\\n for i in holding[1:]:\\n output.append(i)\\n return output\",\n \"def compare_nodes(n1, n2):\\n return n1['g_val'] + n1['h_val'] < n2['g_val'] + n2['h_val']\",\n \"def depth_node_ordering(start_node, end_nodes):\\n ordered_list = []\\n ordered_set = set()\\n working_list = [start_node]\\n while working_list != []:\\n node = working_list.pop(0)\\n if not node in ordered_set:\\n ordered_set.add(node)\\n ordered_list.append(node)\\n if not is_leaf_node(node) and not node in end_nodes:\\n for node_op in node.get_inputs():\\n working_list.append(node_op)\\n return ordered_list\",\n \"def compare_nodes(n1, n2):\\n if not isinstance(n1, dict):\\n raise TypeError(\\\"Invalid n1! Expected dict, got %s instead\\\" %\\n type(n1).__name__)\\n if not isinstance(n2, dict):\\n raise TypeError(\\\"Invalid n2! Expected dict, got %s instead\\\" %\\n type(n2).__name__)\\n\\n if not Pharmacophore.check_node(n1):\\n raise ValueError(\\\"Invalid n1!\\\")\\n\\n if not Pharmacophore.check_node(n2):\\n raise ValueError(\\\"Invalid n2!\\\")\\n\\n c = n1[\\\"freq\\\"] + n2[\\\"freq\\\"]\\n d1 = sum(n1[\\\"type\\\"].values())\\n d2 = sum(n2[\\\"type\\\"].values())\\n d = d1 + d2\\n sim = 0.0\\n t = {}\\n\\n for phar in PHARS:\\n if phar in n1[\\\"type\\\"] and phar in n2[\\\"type\\\"]:\\n sim += (n1[\\\"type\\\"][phar] + n2[\\\"type\\\"][phar]) / d\\n t[phar] = n1[\\\"type\\\"][phar] + n2[\\\"type\\\"][phar]\\n elif phar in n1[\\\"type\\\"]:\\n t[phar] = n1[\\\"type\\\"][phar]\\n elif phar in n2[\\\"type\\\"]:\\n t[phar] = n2[\\\"type\\\"][phar]\\n return sim * c, t\",\n \"def create_nodes(self, articles, merges):\\n # self.all_nodes = [RealNode(a) for a in articles]\\n if merges is None:\\n for article in articles:\\n matching_layer = self.find_layer_by_name(article[\\\"year\\\"])\\n matching_layer.create_node(article)\\n else:\\n for merge in merges:\\n art1 = next(x for x in articles if x['key'] == merge['art1'])\\n art2 = next(x for x in articles if x['key'] == merge['art2'])\\n if 'art3' in merge:\\n art3 = next(x for x in articles if x['key'] == merge['art3'])\\n matching_layer = self.find_layer_by_name(art1['year'])\\n merge_key = art1['key'] + art2['key']\\n merge_dict = {'key': merge_key, 'year': matching_layer.name, 'art1': art1, 'art2': art2, 'merge': merge}\\n if 'art3' in merge:\\n merge_key += art3['key']\\n merge_dict = {'key': merge_key, 'year': matching_layer.name, 'art1': art1, 'art2': art2, 'art3': art3, 'merge': merge}\\n new_node = matching_layer.create_node(merge_dict)\\n new_node.kind = \\\"Merge\\\"\\n for article in articles:\\n merge_art = False\\n for merge in merges:\\n if article['key'] == merge['art1'] or article['key'] == merge['art2'] or \\\\\\n ('art3' in merge and article['key'] == merge['art3']):\\n merge_art = True\\n break\\n if not merge_art:\\n matching_layer = self.find_layer_by_name(article[\\\"year\\\"])\\n matching_layer.create_node(article)\",\n \"def generate_tree(sp_root=0, num_nodes=7):\\n # generate tree\\n tree = dict()\\n tree_lc = dict()\\n tree_rc = dict()\\n tree[sp_root] = None\\n queue = [sp_root]\\n available_id = 0\\n\\n while True:\\n curr_node = queue.pop(0)\\n lc = available_id + 1\\n if lc == num_nodes:\\n break\\n rc = available_id + 2\\n if rc == num_nodes:\\n break\\n tree_lc[curr_node] = lc\\n tree_rc[curr_node] = rc\\n tree[lc] = curr_node\\n tree[rc] = curr_node\\n available_id += 2\\n queue.append(lc)\\n queue.append(rc)\\n if len(tree) == num_nodes:\\n break\\n return tree, tree_lc, tree_rc\",\n \"def Trees__LCA_LowestCommonDenominator():\\n # Python2 ported to Python3 via 2to3-3.7\\n # URL:# URL:https://www.hackerrank.com/challenges/binary-search-tree-lowest-common-ancestor/problem\\n '''\\n class Node:\\n def __init__(self,info): \\n self.info = info \\n self.left = None \\n self.right = None \\n // this is a node of the tree , which contains info as data, left , right\\n '''\\n def lca(root, v1, v2):\\n # Find a and b. Link child nodes to parent to be able to backtrack.\\n # (1) Note, we add 'parent' attribute to node dynamically via node.parent = ...\\n root.parent = None\\n node_stack = []\\n node_stack.append(root)\\n v1_node, v2_node = None, None\\n while node_stack:\\n node = node_stack.pop()\\n if not v1_node and node.info == v1:\\n v1_node = node\\n if not v2_node and node.info == v2:\\n v2_node = node\\n for child_node in [node.left, node.right]:\\n if child_node:\\n child_node.parent = node # (1)\\n node_stack.append(child_node)\\n\\n # Generate path from A to root.\\n curr = v1_node\\n a_to_root = set()\\n while curr:\\n a_to_root.add(curr.info)\\n curr = curr.parent\\n\\n # traverse up b until you come across an element in a's path to parent.\\n curr = v2_node\\n while curr:\\n if curr.info in a_to_root:\\n return curr\\n else:\\n curr = curr.parent\\n\\n print(\\\"Shouldn't be here, Something went wrong\\\")\\n\\n # # Recursive. (Iterative is better, but did recursive for practice.) ~15 min.\\n # # Main idea is that we count the number of v1/v2's found of the subnodes.\\n # # If a node has sum of 2, we know it's the lca.\\n # def lca(root, v1, v2):\\n # def lca_helper(node):\\n # ret_node = None\\n # if not node:\\n # return 0, None\\n # v_match_counter = 0\\n # if node.info in [v1, v2]:\\n # v_match_counter += 1\\n # left_count, left_node_ret = lca_helper(node.left)\\n # right_count, right_node_ret = lca_helper(node.right)\\n # v_match_counter += left_count + right_count\\n # if v_match_counter == 2:\\n # ret_node = node\\n # if left_node_ret:\\n # ret_node = left_node_ret\\n # if right_node_ret:\\n # ret_node = right_node_ret\\n # return v_match_counter, ret_node\\n\\n # _, node = lca_helper(root)\\n # return node\",\n \"def _connect_nodes(self, node_deque):\\r\\n # Case where there is only 1 node in the test\\r\\n if len(node_deque) == 1:\\r\\n child = node_deque.pop()\\r\\n # create root for only child\\r\\n root = Node()\\r\\n root.set_freq_value(1)\\r\\n root.set_left_child(child)\\r\\n return root\\r\\n\\r\\n while len(node_deque) > 1:\\r\\n first_tree = node_deque.popleft()\\r\\n second_tree = node_deque.popleft()\\r\\n # The first tree is getting to big so start another\\r\\n if first_tree.get_freq_value() > second_tree.get_freq_value():\\r\\n node_deque.append(first_tree)\\r\\n first_tree = node_deque.popleft()\\r\\n # A parent node for the two children\\r\\n tree_node = Node()\\r\\n\\r\\n tree_node.set_left_child(first_tree)\\r\\n tree_node.set_right_child(second_tree)\\r\\n\\r\\n # Add the two child frequency values to the parent node value\\r\\n total_freq = tree_node.get_left_child().get_freq_value() + tree_node.get_right_child().get_freq_value()\\r\\n tree_node.set_freq_value(total_freq)\\r\\n node_deque.appendleft(tree_node)\\r\\n\\r\\n return node_deque.pop()\",\n \"def test_tree_intersection_on_challenge_example(first_example, second_example):\\n expected = [500, 350, 200, 175, 160, 125, 100]\\n actual = tree_intersection(first_example, second_example)\\n assert expected == actual\",\n \"def build_match_tree(abbreviation_list):\\n match_tree = {}\\n for word, abbreviation in abbreviation_list:\\n tree_node = match_tree\\n for letter in word[:-1]:\\n if letter not in tree_node:\\n tree_node[letter] = {}\\n tree_node = tree_node[letter]\\n tree_node[word[-1]] = abbreviation\\n return match_tree\",\n \"def test_1(self):\\r\\n r1, r2, r5 = MyVariable(1), MyVariable(2), MyVariable(5)\\r\\n o = MyOp.make_node(r1, r1)\\r\\n o2 = MyOp.make_node(o.outputs[0], r5)\\r\\n all = general_toposort(o2.outputs, prenode)\\r\\n assert all == [r5, r1, o, o.outputs[0], o2, o2.outputs[0]]\",\n \"def build_tree_from_ordered(input, tree=None):\\n\\n if len(input) == 0:\\n return tree\\n if len(input) == 1:\\n tree = BSTNode(input[0])\\n return tree\\n\\n middle_pos = int(len(input) / 2)\\n right_tree = input[:middle_pos - 1]\\n left_tree = input[middle_pos + 1:]\\n actual_node = input[middle_pos - 1:middle_pos][0]\\n\\n # insert tree node\\n if tree is None:\\n tree = BSTNode(actual_node)\\n else:\\n tree.value = actual_node\\n tree.right = build_tree_from_ordered(right_tree, tree=tree.right)\\n tree.left = build_tree_from_ordered(left_tree, tree=tree.left)\\n\\n return tree\",\n \"def test_collision(quadtree1, quadtree2, shift1, shift2, stay_away):\\r\\n\\r\\n r1, r2 = quadtree1.root, quadtree2.root\\r\\n\\r\\n if (not r1) or (not r2):\\r\\n return False\\r\\n\\r\\n stack = [(r1, r2)]\\r\\n\\r\\n while stack:\\r\\n p1, p2 = stack.pop() # the nodes of the 1st and the 2nd trees\\r\\n\\r\\n if not rectangles_intersect(p1.value, p2.value, shift1, shift2, stay_away):\\r\\n # if larger rectangles do not collide, their children will not collide either\\r\\n # hence no need to go for sub-nodes\\r\\n continue\\r\\n\\r\\n if p1.is_leaf() and p2.is_leaf():\\r\\n # leaves collide, we're done\\r\\n return True\\r\\n\\r\\n c1, c2 = p1.get_children_list(), p2.get_children_list()\\r\\n\\r\\n if not c1:\\r\\n for x in c2:\\r\\n stack.append((p1, x))\\r\\n else:\\r\\n if not c2:\\r\\n for x in c1:\\r\\n stack.append((x, p2))\\r\\n else:\\r\\n # none are empty, i.e. the nodes are not leaves\\r\\n for x in c1:\\r\\n for y in c2:\\r\\n stack.append((x, y))\\r\\n\\r\\n return False\",\n \"def test_tree_support(self):\\r\\n master_tree = parse_newick('((a:2,b:3)ab:2,(c:1,d:2)cd:7)rt;')\\r\\n \\\"\\\"\\\"\\r\\n /-------.5 /-a\\r\\n ---1| \\\\-b\\r\\n \\\\------.5 /-c\\r\\n \\\\-d\\r\\n \\\"\\\"\\\"\\r\\n t2 = parse_newick('((a:2,b:3,c:33)ho:2,d:7);') # abc are siblings\\r\\n\\r\\n tc.tree_support(master_tree, t2)\\r\\n assert_almost_equal(\\r\\n master_tree.getNodeMatchingName('rt').bootstrap_support, 1.0)\",\n \"def recoverTree1(self, root: Optional[TreeNode]) -> None:\\n self.traverseTree(root)\\n def find_two_swapped(nums: List[int]) -> (int, int):\\n length = len(nums)\\n for i in range(length - 1, 0, -1):\\n if nums[i] < nums[i - 1]:\\n j = i - 1\\n while j >=0 and nums[j] > nums[i]:\\n j -= 1\\n return nums[i], nums[j + 1]\\n a, b = find_two_swapped(self.arr)\\n\\n self.nodeMap[a].val = b\\n self.nodeMap[b].val = a\",\n \"def linear_merge(sorted1, sorted2):\\n first_pointer = 0\\n second_pointer = 0\\n sorted_result = []\\n\\n while second_pointer < len(sorted2) and first_pointer < len(sorted1):\\n if sorted1[first_pointer] < sorted2[second_pointer]:\\n sorted_result.append(sorted1[first_pointer])\\n first_pointer += 1\\n else:\\n sorted_result.append(sorted2[second_pointer])\\n second_pointer += 1\\n\\n while second_pointer < len(sorted2):\\n sorted_result.append(sorted2[second_pointer])\\n second_pointer += 1\\n\\n while first_pointer < len(sorted1):\\n sorted_result.append(sorted1[first_pointer])\\n first_pointer += 1\\n\\n\\n return sorted_result\",\n \"def compare_branch_lengths(tree1, tree2):\\n stack = [] # stack to store nodes in tree2\\n\\n for count, node in enumerate(tree1.postorder(include_self=False)):\\n if node.is_tip():\\n try:\\n cur = tree2.find(node.name)\\n except MissingNodeError:\\n return False\\n else:\\n if node.id == stack[-1].id:\\n cur = stack.pop()\\n else:\\n return False\\n\\n if _compare_length(node, cur) is False:\\n return False\\n if node.parent.id is None and cur.parent.id is None:\\n cur.parent.id = node.parent.id = str(count)\\n elif (node.parent.id is not None) ^ (cur.parent.id is not None):\\n return False\\n if cur.parent not in stack:\\n stack.append(cur.parent)\\n return True\",\n \"def add_nodes_as_trees(self,\\n nodes: Nodes,\\n tree_ids: List[int] = None,\\n group_ids: List[int] = None,\\n names: List[str] = None,\\n colors: List[Tuple[float, float, float, float]] = None):\\n\\n if tree_ids is None:\\n tree_id_start = self.max_tree_id() + 1\\n tree_id_end = tree_id_start + len(nodes)\\n tree_ids = list(range(tree_id_start, tree_id_end))\\n\\n if group_ids is None:\\n group_ids = [None for x in range(len(nodes))]\\n\\n if names is None:\\n names = ['' for x in range(len(nodes))]\\n\\n if colors is None:\\n colors = [(0.0, 0.0, 0.0, 1.0) for x in range(len(nodes))]\\n\\n for node_idx, _ in nodes.iterrows():\\n self.add_tree(\\n nodes=nodes[node_idx:node_idx+1],\\n tree_id=tree_ids[node_idx],\\n group_id=group_ids[node_idx],\\n name=names[node_idx],\\n color=colors[node_idx]\\n )\",\n \"def test_sort_chain_multiple_reuse():\\n data = [-10, 42, 8, 64, -6, 76, 48, 8, -30, 1, 11, 92, 37, 4]\\n chain = None\\n for item in data:\\n chain = N.Node(item, chain)\\n\\n id_record = {}\\n walker = chain\\n while walker is not None:\\n id_record[id(walker)] = walker.data\\n walker = walker.next\\n\\n result = A8.sort_chain(chain)\\n\\n walker = result\\n while walker is not None:\\n assert id(walker) in id_record, \\\"sort_chain created new node\\\"\\n assert id_record[id(walker)] == walker.data, \\\"sort_chain moved data value {} to new node\\\".format(walker.data)\\n walker = walker.next\",\n \"def __align_rings(p1, p2, n1, n2, idx1, idx2, mapping=None, dist1=None,\\n dist2=None, dist_tol=0):\\n\\n assert len(n1) == len(n2), \\\"wrong n1 or n2\\\"\\n\\n if mapping is None:\\n mapping = np.zeros((p1.numnodes, p2.numnodes))\\n\\n for i in range(p1.numnodes):\\n for j in range(p2.numnodes):\\n weighted_freq, _ = compare_nodes(p1.nodes[i], p2.nodes[j])\\n if weighted_freq > 0.0:\\n mapping[i][j] = weighted_freq\\n\\n if dist1 is None:\\n dist1 = distances(p1)\\n dist1[p1.edges > 0] = p1.edges[p1.edges > 0]\\n\\n if dist2 is None:\\n dist2 = distances(p2)\\n dist2[p2.edges > 0] = p2.edges[p2.edges > 0]\\n\\n # create modular product of graph using alignment as constraints\\n nodes = []\\n scores = []\\n\\n assert len(idx1) == len(idx2), \\\"unequal subgraphs sizes\\\"\\n old_len = len(idx1)\\n\\n for i in range(old_len):\\n weighted_freq = mapping[idx1[i], idx2[i]]\\n assert weighted_freq > 0, \\\"wrong alignment given\\\"\\n nodes.append({\\\"n1\\\": idx1[i], \\\"n2\\\": idx2[i]})\\n scores.append(weighted_freq)\\n\\n for i in range(len(n1)):\\n possible_matches = np.where(mapping[n1[i], :][:, n2[i]] > 0)\\n pairs1 = n1[i][possible_matches[0]]\\n pairs2 = n2[i][possible_matches[1]]\\n if len(idx1) > 0:\\n # find pairs compatible with given alignment\\n d1 = dist1[pairs1, :][:, idx1]\\n d2 = dist2[pairs2, :][:, idx2]\\n compatible = np.where(np.all(np.abs(d1 - d2) <= dist_tol,\\n axis=1))[0]\\n else:\\n # empty alignment given, accept everything\\n compatible = np.array(list(range(len(pairs1))))\\n\\n for i in compatible:\\n weighted_freq = mapping[pairs1[i], pairs2[i]]\\n assert weighted_freq > 0, \\\"wrong possible matches\\\"\\n nodes.append({\\\"n1\\\": pairs1[i], \\\"n2\\\": pairs2[i]})\\n scores.append(weighted_freq)\\n\\n scores = np.array(scores)\\n\\n n = len(nodes)\\n edges = np.zeros((n, n))\\n costs = np.zeros((n, n))\\n\\n for i in range(n):\\n for j in range(i):\\n if nodes[i][\\\"n1\\\"] == nodes[j][\\\"n1\\\"] or \\\\\\n nodes[i][\\\"n2\\\"] == nodes[j][\\\"n2\\\"]:\\n continue\\n\\n is_connected = False\\n\\n if p1.edges[nodes[i][\\\"n1\\\"], nodes[j][\\\"n1\\\"]] > 0:\\n is_connected = True\\n d1 = dist1[nodes[i][\\\"n1\\\"], nodes[j][\\\"n1\\\"]]\\n\\n if p2.edges[nodes[i][\\\"n2\\\"], nodes[j][\\\"n2\\\"]] > 0:\\n is_connected = True\\n d2 = dist2[nodes[i][\\\"n2\\\"], nodes[j][\\\"n2\\\"]]\\n\\n if math.fabs(d1 - d2) <= dist_tol:\\n if is_connected:\\n costs[i, j] = costs[j, i] = math.fabs(d1 - d2)\\n edges[i, j] = edges[j, i] = 1.0\\n\\n alignment = list(range(old_len))\\n score = np.sum(scores[alignment])\\n cost = np.sum(costs[alignment, :][:, alignment]) / 2\\n scorecost = score-cost\\n\\n for clique in __BronKerbosch(edges):\\n clique = list(clique)\\n s = np.sum(scores[clique])\\n c = np.sum(costs[clique, :][:, clique]) / 2\\n\\n if (s - c > scorecost) or (s - c == scorecost and s > score):\\n idx1 = []\\n idx2 = []\\n n1 = []\\n n2 = []\\n score = s\\n cost = c\\n scorecost = s - c\\n\\n for pair in clique:\\n idx1.append(nodes[pair][\\\"n1\\\"])\\n idx2.append(nodes[pair][\\\"n2\\\"])\\n return score, cost, [idx1, idx2]\",\n \"def make_tree(self, strings):\\n # start from tree root\\n root = self.tree()\\n # mark if letter is the end of string or just its part\\n root['end'] = set()\\n root['part'] = set(self.s_options_total)\\n for idx, string in enumerate(strings):\\n node = root\\n for letter in string:\\n new_node = node[letter]\\n new_node.setdefault('end', set())\\n new_node.setdefault('part', set()).add(idx)\\n node = new_node\\n node['end'].add(idx)\\n node['part'].remove(idx)\\n\\n return root\",\n \"def solve(self):\\n self.a_tree = self.make_tree(self.a_strings)\\n self.b_tree = self.make_tree(self.b_strings)\\n\\n # apply prefix filter\\n self.s_options_for_beginning = self.prefix_filter()\\n if len(self.s_options_for_beginning) == 0:\\n self.final_sequence = 'IMPOSSIBLE'\\n return\\n\\n # apply postfix filter\\n self.s_options_for_ending = self.postfix_filter()\\n if len(self.s_options_for_ending) == 0:\\n self.final_sequence = 'IMPOSSIBLE'\\n return\\n\\n # apply length balance filter (on the result after prefix and postfix filter)\\n self.s_combinations_by_length = self.length_balance_filter(self.s_options_for_beginning,\\n self.s_options_for_ending)\\n if len(self.s_combinations_by_length) == 0:\\n self.final_sequence = 'IMPOSSIBLE'\\n return\\n\\n # apple elements balance filter (on the result after length balance filter)\\n self.s_combinations_by_elements = self.elements_balance_filter(self.s_combinations_by_length)\\n if len(self.s_combinations_by_elements) == 0:\\n self.final_sequence = 'IMPOSSIBLE'\\n return\\n\\n # sort filtered combinations by its elements length in ascending order\\n self.s_combinations_filtered = sorted(self.s_combinations_by_elements.items())\\n\\n # for each combinations length try to find the lexicographically shortest sequence using depth-first search\\n for length, combinations in self.s_combinations_filtered:\\n for combination in combinations:\\n self.combination = combination\\n self.dfs()\\n\\n # return sequence as soon as we got one\\n if self.final_sequence:\\n return\\n\\n # otherwise - return 'IMPOSSIBLE'\\n if not self.final_sequence:\\n self.final_sequence = 'IMPOSSIBLE'\\n return\",\n \"def substructure_sim_partial(subtrees_1, subtrees_2):\\n assert(len(subtrees_1) == len(subtrees_2))\\n n = len(subtrees_1)\\n f1 = np.zeros(n)\\n f2 = np.zeros(n)\\n for i in range(n):\\n if (subtrees_1[i] == subtrees_2[i]): # exact match, or both are dropped\\n f1[i] = 1.0\\n f2[i] = 1.0\\n else: # partial match\\n f1[i] = SubstructureAgreement.save_div( len(subtrees_1[i].intersection(subtrees_2[i])), float(len(subtrees_2[i])))\\n f2[i] = SubstructureAgreement.save_div( len(subtrees_2[i].intersection(subtrees_1[i])), float(len(subtrees_1[i])))\\n\\n return (np.sum(f1) + np.sum(f2)) / (2.0 * float(n)) # average of average recall\",\n \"def dist_tree(self, other, tol=1e-8):\\n if self.ndim == 2:\\n from pyparm import d2 as sim\\n else:\\n from pyparm import d3 as sim\\n\\n assert self.ndim == other.ndim\\n\\n if self.shear != 0 or other.shear != 0:\\n assert np.abs(self.shear - other.shear) <= tol\\n shear = (self.shear + other.shear) / 2.0\\n box = sim.LeesEdwardsBox(sim.Vec(1, 1), shear)\\n else:\\n box = sim.OriginBox(1.0)\\n\\n sz1 = self.size_indices()\\n assert(len(sz1) == 2)\\n cutoff1 = int(np.sum(sz1[0]))\\n\\n sz2 = other.size_indices()\\n assert(len(sz2) == 2)\\n cutoff2 = int(np.sum(sz2[0]))\\n\\n vs1 = np.array([xy for idx in sz1 for xy in self.rs[idx]])\\n vs2 = np.array([xy for idx in sz2 for xy in other.rs[idx]])\\n\\n tree = sim.JammingTreeBD(box, vs1, vs2, cutoff1, cutoff2)\\n return tree\",\n \"def PickSeeds(self, leaf1, leaf2):\\n d = 0\\n t1 = 0\\n t2 = 0\\n\\n # iter all possible children nodes, to find the max difference.\\n for i in range(len(self.leaves)):\\n for j in range(i + 1, len(self.leaves)):\\n MBR_new = merge(self.leaves[i].MBR, self.leaves[j].MBR)\\n S_new = 1.0 * (MBR_new['xmax'] - MBR_new['xmin']) * (MBR_new['ymax'] - MBR_new['ymin'])\\n S1 = 1.0 * (self.leaves[i].MBR['xmax'] - self.leaves[i].MBR['xmin']) * (\\n self.leaves[i].MBR['ymax'] - self.leaves[i].MBR['ymin'])\\n S2 = 1.0 * (self.leaves[j].MBR['xmax'] - self.leaves[j].MBR['xmin']) * (\\n self.leaves[j].MBR['ymax'] - self.leaves[j].MBR['ymin'])\\n if S_new - S1 - S2 > d:\\n t1 = i\\n t2 = j\\n d = S_new - S1 - S2\\n n2 = self.leaves.pop(t2)\\n n2.father = leaf1\\n leaf1.leaves.append(n2)\\n leaf1.MBR = leaf1.leaves[0].MBR\\n n1 = self.leaves.pop(t1)\\n n1.father = leaf2\\n leaf2.leaves.append(n1)\\n leaf2.MBR = leaf2.leaves[0].MBR\",\n \"def combine(a, b):\\n newnode = None\\n # not sure what to do if comes_before is false\\n if a.char < b.char:\\n newchar = a.char\\n else:\\n newchar = b.char\\n newfreq = a.freq + b.freq\\n newnode = HuffmanNode(newchar, newfreq)\\n newnode.left = a\\n newnode.right = b\\n return newnode\",\n \"def MatchMatrixs (self,Node1,Node2):\\n\\n T1Native_Node = Node1\\n T1Native_Matrix = slicer.util.arrayFromVolume(T1Native_Node)\\n DimN = T1Native_Matrix.shape\\n T1Enhanced_Node = Node2\\n T1Enhanced_Matrix = slicer.util.arrayFromVolume(T1Enhanced_Node)\\n DimE = T1Enhanced_Matrix.shape\\n\\n NMatrix = self.GetIJKToRASnpArray(T1Native_Node)\\n NVector = NMatrix[:-1,-1]\\n EMatrix = self.GetIJKToRASnpArray(T1Enhanced_Node)\\n EVector = EMatrix[:-1,-1]\\n NPixelSize = [np.linalg.norm(NMatrix[:-1,0]), np.linalg.norm(NMatrix[:-1,1])]\\n EPixelSize = [np.linalg.norm(EMatrix[:-1,0]), np.linalg.norm(EMatrix[:-1,1])]\\n\\n Niversor = NMatrix[:-1,0]/NPixelSize[0]\\n Njversor = NMatrix[:-1,1]/NPixelSize[1]\\n Nkversor = np.round(np.cross(Niversor,Njversor),3)\\n Nkstep = round(np.linalg.norm(NMatrix[:-1,2]),3)\\n\\n Eiversor = EMatrix[:-1,0]/EPixelSize[0]\\n Ejversor = EMatrix[:-1,1]/EPixelSize[1]\\n Ekversor = np.round(np.cross(Eiversor,Ejversor),3)\\n Ekstep = round(np.linalg.norm(EMatrix[:-1,2]),3)\\n print(Nkversor,Ekversor,Nkstep,Ekstep,NVector,EVector,(NVector-EVector).dot(Ekversor))\\n if not ( np.sum(Nkversor==Ekversor) == 3 and Nkstep==Ekstep and ((NVector-EVector).dot(Ekversor)) == 0 ): # it verifies if the slices are oriented in the same direction, with the same step between slices and if the first images are complanar.\\n slicer.util.warningDisplay('The geometry of the LL Native and LL Enhanced volume doesn\\\\'t match. It could deteriorate the ECV map', windowTitle= 'Warning')\\n\\n if (DimE == DimN):\\n T1_ECVMappingLogic.setupNodeFromNode(self,self.ECVMapNode , self.NativeT1_Selector.currentNode()) \\n return [T1Native_Matrix,T1Enhanced_Matrix]\\n if (DimE[1:3] == DimN[1:3]):\\n k = min([DimE[1],DimN[1]])\\n T1_ECVMappingLogic.setupNodeFromNode(self,self.ECVMapNode , self.NativeT1_Selector.currentNode())\\n return [T1Native_Matrix[:k,:,:],T1Enhanced_Matrix[:k,:,:]]\\n\\n jN = np.arange(0,DimN[2]*NPixelSize[1],NPixelSize[1])+NPixelSize[1]/2+(NVector-EVector).dot(Njversor)\\n iN = np.arange(0,DimN[1]*NPixelSize[0],NPixelSize[0])+NPixelSize[0]/2+(NVector-EVector).dot(Niversor)\\n iE = np.arange(0,DimE[1]*EPixelSize[0],EPixelSize[0])+EPixelSize[0]/2\\n jE = np.arange(0,DimE[2]*EPixelSize[1],EPixelSize[1])+EPixelSize[1]/2 \\n if DimE[1] > DimN[1]: ## I concidered a square image\\n T1Nreshaped = np.zeros(DimE)\\n for k in range(DimN[0]):\\n f = interpolate.interp2d(iN, jN, np.nan_to_num(T1Native_Matrix[k,:,:]), fill_value = 0)\\n T1Nreshaped[k,:,:] = f(iE, jE)\\n T1Ereshaped = T1Enhanced_Matrix[:k+1,:,:]\\n T1_ECVMappingLogic.setupNodeFromNode(self,self.ECVMapNode , self.EnhancedT1_Selector.currentNode())\\n return [T1Nreshaped,T1Ereshaped]\\n else:\\n T1Ereshaped = np.zeros(DimN)\\n for k in range(DimE[0]):\\n f = interpolate.interp2d(iE, jE, np.nan_to_num(T1Enhanced_Matrix[k,:,:]), fill_value = 0)\\n T1Ereshaped[k,:,:] = f(iN, jN) \\n T1Nreshaped = T1Native_Matrix[:k+1,:,:]\\n T1_ECVMappingLogic.setupNodeFromNode(self,self.ECVMapNode , self.NativeT1_Selector.currentNode()) \\n return [T1Nreshaped,T1Ereshaped]\",\n \"def topologicalSort(self, nodes: List[int], prerequisites: List[List[int]]) -> List[int]:\\n # graph\\n # prep: x ->requires set(y1, y2, ..), before take x need y1, y2, .., takes count only\\n # post: y ->followup set(x1, x2, ..), \\n # after take y, it is possible (only possible may not, as x_i might need others) x1, x2, ..\\n prep = defaultdict(lambda: 0)\\n post = defaultdict(set)\\n for x, y in prerequisites:\\n prep[x] += 1\\n post[y].add(x)\\n # schedule\\n # start with all nodes requires no prerequisites\\n schedule, boundary = [], [x for x in nodes if x not in prep]\\n while boundary:\\n y = boundary.pop()\\n schedule.append(y)\\n if y in post:\\n xs = post.pop(y)\\n for x in xs:\\n prep[x] -= 1\\n # all prerequisites of x are cleared \\n if prep[x] == 0:\\n prep.pop(x)\\n boundary.append(x)\\n # some nodes are impossible to complete?\\n if prep:\\n return []\\n return schedule\",\n \"def build_tree(tree_list, nums):\\n\\n if len(nums) == 0:\\n return tree_list\\n next_list = []\\n j = 0\\n for i in tree_list:\\n for _ in range(2):\\n if i is not None and j < len(nums):\\n if nums[j] is None:\\n next_list.append(None)\\n else:\\n next_list.append(TreeNode(nums[j]))\\n j += 1\\n res_list = build_tree(next_list, nums[j:])\\n j = 0\\n for i in tree_list:\\n if i is None:\\n continue\\n if j < len(res_list):\\n if next_list[j] is not None:\\n next_list[j].parent = i\\n i.left = next_list[j]\\n j += 1\\n if j < len(res_list):\\n if next_list[j] is not None:\\n next_list[j].parent = i\\n i.right = next_list[j]\\n j += 1\\n return tree_list\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6480154","0.6017104","0.5900179","0.58926785","0.57914406","0.5785781","0.56803095","0.5670274","0.5616493","0.5585591","0.548172","0.5441299","0.5415218","0.54117894","0.5322896","0.53055215","0.53055215","0.52935976","0.5283271","0.5247669","0.5240782","0.52276677","0.5227565","0.5224411","0.5210285","0.520364","0.51938504","0.5144241","0.51428246","0.5142545","0.51335037","0.5112655","0.5106698","0.5100125","0.5085769","0.50772923","0.50703824","0.50692093","0.50690037","0.5068533","0.50580466","0.5053718","0.50343615","0.50317717","0.50294197","0.50280905","0.50133437","0.5011629","0.50095654","0.49997067","0.49760866","0.49722546","0.49722302","0.49718735","0.4968616","0.49576777","0.49457046","0.49397397","0.49389794","0.4933964","0.4919064","0.4907819","0.49047548","0.48992872","0.48904982","0.4887092","0.488347","0.4878359","0.48782867","0.48769435","0.4876186","0.4872163","0.48675495","0.4867289","0.48647138","0.48610824","0.48551244","0.4848234","0.48455602","0.48439637","0.48387524","0.4838019","0.48352653","0.48228455","0.48142213","0.48135725","0.48122442","0.48099047","0.48079538","0.4807701","0.48061067","0.48036903","0.47926444","0.47904146","0.47884035","0.47833222","0.47782785","0.47765613","0.47674623","0.4765686"],"string":"[\n \"0.6480154\",\n \"0.6017104\",\n \"0.5900179\",\n \"0.58926785\",\n \"0.57914406\",\n \"0.5785781\",\n \"0.56803095\",\n \"0.5670274\",\n \"0.5616493\",\n \"0.5585591\",\n \"0.548172\",\n \"0.5441299\",\n \"0.5415218\",\n \"0.54117894\",\n \"0.5322896\",\n \"0.53055215\",\n \"0.53055215\",\n \"0.52935976\",\n \"0.5283271\",\n \"0.5247669\",\n \"0.5240782\",\n \"0.52276677\",\n \"0.5227565\",\n \"0.5224411\",\n \"0.5210285\",\n \"0.520364\",\n \"0.51938504\",\n \"0.5144241\",\n \"0.51428246\",\n \"0.5142545\",\n \"0.51335037\",\n \"0.5112655\",\n \"0.5106698\",\n \"0.5100125\",\n \"0.5085769\",\n \"0.50772923\",\n \"0.50703824\",\n \"0.50692093\",\n \"0.50690037\",\n \"0.5068533\",\n \"0.50580466\",\n \"0.5053718\",\n \"0.50343615\",\n \"0.50317717\",\n \"0.50294197\",\n \"0.50280905\",\n \"0.50133437\",\n \"0.5011629\",\n \"0.50095654\",\n \"0.49997067\",\n \"0.49760866\",\n \"0.49722546\",\n \"0.49722302\",\n \"0.49718735\",\n \"0.4968616\",\n \"0.49576777\",\n \"0.49457046\",\n \"0.49397397\",\n \"0.49389794\",\n \"0.4933964\",\n \"0.4919064\",\n \"0.4907819\",\n \"0.49047548\",\n \"0.48992872\",\n \"0.48904982\",\n \"0.4887092\",\n \"0.488347\",\n \"0.4878359\",\n \"0.48782867\",\n \"0.48769435\",\n \"0.4876186\",\n \"0.4872163\",\n \"0.48675495\",\n \"0.4867289\",\n \"0.48647138\",\n \"0.48610824\",\n \"0.48551244\",\n \"0.4848234\",\n \"0.48455602\",\n \"0.48439637\",\n \"0.48387524\",\n \"0.4838019\",\n \"0.48352653\",\n \"0.48228455\",\n \"0.48142213\",\n \"0.48135725\",\n \"0.48122442\",\n \"0.48099047\",\n \"0.48079538\",\n \"0.4807701\",\n \"0.48061067\",\n \"0.48036903\",\n \"0.47926444\",\n \"0.47904146\",\n \"0.47884035\",\n \"0.47833222\",\n \"0.47782785\",\n \"0.47765613\",\n \"0.47674623\",\n \"0.4765686\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.7211512"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":89892,"cells":{"query":{"kind":"string","value":"Returns the longest paths through the tree starting at root."},"document":{"kind":"string","value":"def find_treepaths(root, treepaths):\n treepaths.append(root)# possible that more than one match of the same length\n if root.children:\n path_children = max(root.children, key = lambda node: node.depth) # pick the deepest child tree(s)\n if isinstance(path_children, TreeNode):\n find_treepaths(path_children, treepaths)\n else: # more than one child tree with the max depth\n num_paths = len(path_children)\n treepaths = [treepaths[:]]*num_paths # copies, not references\n for i in range(0, num_paths):\n find_treepaths(path_children[i], treepaths[i])\n return treepaths"},"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 longest_path(game, player, cur_length=0, max_length=10):\n moves = game.get_legal_moves(player)\n\n # Break recursion if we reach a dead end or we're at the limit.\n if not moves or cur_length >= max_length:\n return cur_length\n # Otherwise search recursively.\n else:\n best_depth = 0\n for move in moves:\n game_copy = try_move(game, move, player)\n move_depth = longest_path(game_copy, player, cur_length + 1)\n if move_depth > best_depth:\n best_depth = move_depth\n # As soon as we're at the depth limit, there's no reason to\n # search more moves.\n if best_depth == max_length:\n return best_depth\n return best_depth","def find_longest(nseqs = None):\n if nseqs:\n set_nseqs(nseqs)\n\n # If nseqs == 1, the function would return all the words of the dict.\n if _nseqs == 1:\n return node(_wordset.pop(),None)\n\n global COUNT\n def reset_grow(node):\n COUNT = 0\n return grow(node)\n\n #leaves = [reset_grow(node(word,None)) for word in _wordset]\n #return max(leaves)\n maxleaf = node('',None)\n for word in _wordset:\n # This print statement is best indicator of inf loop or wasting time\n print('checking root: '+word)\n maxleaf = max([maxleaf, grow(node(word,None))])\n\n return maxleaf","def get_longest_paths(nodes, graph):\n paths = []\n distances = []\n possible_paths = list(combinations(nodes, r=2))\n for node1, node2 in possible_paths:\n try:\n path = nx.shortest_path(graph, node1, node2, \"weight\")\n except Exception,e:\n path = []\n if len(path)>1:\n distance = get_path_distance(path, graph)\n paths.append(path)\n distances.append(distance)\n paths_sorted = [x for (y,x) in sorted(zip(distances, paths), reverse=True)]\n # longest_path = paths_sorted[0]\n # return longest_path\n return paths_sorted","def calculate_tree_height(tree):\n max_height = 0\n for i in tree.values():\n if i.is_leaf():\n path = i.path_to_root()\n if len(path) > max_height:\n max_height = len(path)\n\n return max_height","def max_single_path(self, root: Optional[TreeNode]) -> int:\n if not root:\n return 0\n\n if root in self.single_path_cache:\n return self.single_path_cache[root]\n\n result = max(0, root.val)\n if root.left:\n left = self.max_single_path(root.left)\n result = max(result, left + root.val)\n if root.right:\n right = self.max_single_path(root.right)\n result = max(result, right + root.val)\n\n self.single_path_cache[root] = result\n return result","def longest_path(self, sorted_node):\n \n dist = {}\n \n # Initialise dict with weight ('0') and previous seq ('null')\n for node in sorted_node: \n \n dist[node] = [0, \"\"] \n \n # Finding longest path\n for node in sorted_node:\n \n for prefix in self.prefix[node]: \n \n temp_weight = self.get_weight(prefix, node) + dist[prefix][0]\n # update each weight with greatest path\n if temp_weight > dist[node][0]:\n dist[node][0] = temp_weight\n dist[node][1] = prefix \n \n \n return dist","def _find_max(self, root):\n while root.right:\n root = root.right\n return root","def internal_path_len(root, height=0):\n\n if root is None:\n return 0\n else:\n return height + internal_path_len(root.left, height + 1) + internal_path_len(root.right, height + 1)","def max_root_time(self):\n if self.num_samples == 0:\n raise ValueError(\n \"max_root_time is not defined in a tree sequence with 0 samples\"\n )\n ret = max(self.nodes_time[u] for u in self.samples())\n if self.num_edges > 0:\n # Edges are guaranteed to be listed in parent-time order, so we can get the\n # last one to get the oldest root\n edge = self.edge(self.num_edges - 1)\n # However, we can have situations where there is a sample older than a\n # 'proper' root\n ret = max(ret, self.nodes_time[edge.parent])\n return ret","def maxPathSum(self, root):\n def maxPotential(node):\n \"\"\"Return max potention from each node in tree.\"\"\"\n nonlocal maxsum\n # Allocate null values to 0\n if not node:\n return 0\n\n # Get the max sum from the left and right subtrees\n # We only care about possible gains (no negative values)\n # Iterates all the way to the far left\n left_max = max(maxPotential(node.left), 0)\n print(\"left_max:\", left_max)\n # Iterates down the recursive stack\n right_max = max(maxPotential(node.right), 0)\n print(\"right_max:\", right_max)\n\n # Get sum of potential\n potential = node.val + left_max + right_max\n print(\"potential\", potential)\n\n # Update new maxsum\n maxsum = max(maxsum, potential)\n\n # Recursively return the max potential if continue on same path\n return node.val + max(left_max, right_max)\n\n # Initialize maxsum to negative infinity\n maxsum = float('-inf')\n maxPotential(root)\n\n return maxsum","def diameterOfBinaryTree(self, root):\n self.max_length = 0\n def maxDepth(root):\n if not root:\n return 0\n left_branch = maxDepth(root.left)\n right_branch = maxDepth(root.right)\n self.max_length = max(self.max_length, left_branch + right_branch)\n return max(left_branch, right_branch) + 1\n maxDepth(root)\n return self.max_length","def find_best_path(self, root):\n number_vertices = len(self.states)\n distances = [-float(\"inf\")] * number_vertices\n distances[root] = 0\n predecessors = [None] * number_vertices\n\n for _ in range(number_vertices - 1):\n for origin in range(number_vertices):\n for (target, value) in self.transitions[origin]:\n if distances[target] < distances[origin] + value:\n distances[target] = distances[origin] + value\n predecessors[target] = origin\n\n # compute the vertices with the highest value, excluding the root\n distances[root] = -float(\"inf\")\n most_valued_vertices = np.nonzero(distances == np.max(distances))[0]\n # choose at *random* among the most valuable vertices\n most_valued_vertex = np.random.choice(most_valued_vertices)\n return most_valued_vertex, predecessors","def find_maximal_path(graph):\n maximal_path_in_graph = [] # This is where the maximal path in the graph is stored (updates)\n checked_pairs = set() # In order not to check a pair twice, the set stores the already checked pairs (and the\n # reversed order of the tuple\n for node_start in graph.nodes.keys():\n for node_end in graph.nodes.keys():\n tup_of_nodes = (node_start, node_end) # This tuple is checked in checked_pairs\n # Need to make sure that the path is valid (!=Node) and that it is not checked yet\n if graph.find_longest_path(node_start,\n node_end) != None and tup_of_nodes not in checked_pairs:\n tup_of_nodes_reverse = (node_end, node_start) # This is a tuple with the opposite order\n checked_pairs.add(tup_of_nodes)\n checked_pairs.add(tup_of_nodes_reverse)\n maximal_path_for_pair = graph.find_longest_path(node_start, node_end)\n # Updates the maximal path per pair exceeds the current one\n if len(maximal_path_for_pair) > len(maximal_path_in_graph):\n maximal_path_in_graph = maximal_path_for_pair\n return \"Maximal path between nodes is: {}, and the length is {} nodes.\".format(maximal_path_in_graph, \\\n len(maximal_path_in_graph))","def longest(self):\n longest = None\n max_len = 0\n for vector in self._vectors:\n len = vector.length2\n if len > max_len:\n longest = vector\n max_len = len\n return longest","def find_longest(input):\r\n for thing in input:\r\n print thing\r\n dist_array = [[0 for x in range(rows)] for x in range(cols)] # rows and cols are static variables in main method\r\n for x in xrange(0, len(input), 1):\r\n for y in xrange(0, len(input[x]), 1):\r\n dist_array[x][y] = calculate_longest(dist_array, input, x, y)\r\n for item in dist_array:\r\n print item\r\n return max(max(dist_array))","def find_max(self, root = None):\n return self._find_max(root if root else self.root)","def deep_max(self):\r\n node = self\r\n while not node.is_leaf():\r\n node = node.children[-1]\r\n return node.keys[-1] if node.keys else None","def find_max(self) -> TreeNode:\n node = self.root\n while True:\n if not node.right:\n return node\n node = node.right","def getParseWithLongestRootWord(self) -> FsmParse:\n maxLength = -1\n bestParse = None\n for currentParse in self.__fsmParses:\n if len(currentParse.getWord().getName()) > maxLength:\n maxLength = len(currentParse.getWord().getName())\n bestParse = currentParse\n return bestParse","def compute_longest_chain(self):\n max_len = 0\n for m in self.miners:\n if m.chain.blocks[-1].height > max_len:\n max_len = m.chain.blocks[-1].height\n self.main_chain = m.chain.blocks","def max_path_sum(root_elem):\r\n\tif root_elem is None:\r\n\t\treturn 0\r\n\tif root_elem.left is None and root_elem.right is None:\r\n\t\treturn root_elem.value\r\n\tmax_child = max(max_path_sum(root_elem.left),max_path_sum(root_elem.left))\r\n\treturn root_elem.value + max_child","def max_tree_depth(self):\n\n depths = np.array([leaf.tree_depth for leaf in self.leaves])\n\n return depths.max()","def _max_depth(self):\n max_depth = 0\n for node, data in self.traverse():\n max_depth = max(max_depth, data['level'])\n return max_depth","def maximumDistance(self):\n from ete2 import Tree\n t = Tree(name='LUCA_root')\n empty_forest = {'sp':t,'gns':t,'fam':t,'ord':t,'cls':t,'phy':t,'kng':t}\n return self.distanceToTree(empty_forest,update_inner_attributes=False)","def longestStrChain_wrong(self, words) -> int:\n\n # sort list based on length\n words_dict = {}\n for i in words:\n l = len(i)\n if l not in words_dict.keys():\n words_dict[l] = [i]\n else:\n words_dict[l].append(i)\n word_sort = sorted([(i, j) for i, j in words_dict.items()], key=lambda x: x[0])\n #print(word_sort)\n\n roots = [Node(i) for i in word_sort[0][1]]\n pre_roots = roots\n cur_roots = []\n for _, word_list in word_sort[1:]:\n cur_roots = []\n for i in pre_roots:\n child = [Node(x) for x in word_list if self.is_predecessor(i.val, x)]\n i.child = child\n cur_roots += child\n pre_roots = cur_roots\n print(f'layer={_}, list: {word_list}, cur_roots={[x.val for x in cur_roots]}')\n\n return self.run_list(roots)","def a_long_simple_root(self):\n if self.dynkin_diagram().rank() == 1:\n return self.simple_roots()[self.index_set()[0]]\n longest=self.dynkin_diagram().outgoing_edges()[0]\n for j in self.dynkin_diagram().outgoing_edges():\n if j[2]>longest[2]:\n longest=j\n return self.simple_roots()[longest[0]]","def longest_flight(self):\r\n distance = 0\r\n for code, _list in self.edges.items():\r\n for edge in _list:\r\n if edge.distance > distance:\r\n distance = edge.distance\r\n start = edge.start\r\n destination = edge.destination\r\n return start, destination, distance","def longest_flight(g):\n max_distance = None\n max_destination = None\n max_key = None\n \n for key in g.city_dict:\n for flight in g.city_dict[key].get_flights_out():\n if(flight[1] > max_distance):\n max_key = key\n max_destination = flight[0]\n max_distance = flight[1]\n return g.city_dict[max_key].get_code(), max_destination, max_distance","def calculate_max_paths(self):\n self.max_paths = {}\n first_nodes = [key for (key, val) in self.predecessors.items() if not val]\n for nm in first_nodes:\n self.max_paths[nm] = {}\n self._checking_path(node_name=nm, first_name=nm)","def height(root:Node) -> int:\n current = root.left\n depth = 0\n maxdepth = [0]\n #track the value and whether it has a branchpoint or not (bool)\n seen = dict()\n\n #do the left side first, then the right\n\n while current is not None:\n if current.val not in seen:\n if (current.left is not None) and (current.right is not None):\n seen.update({current.val:True})\n else:\n seen.update({current.val:False})\n depth +=1\n maxdepth.append(depth)\n if current.left is not None:\n current = current.left\n elif current.right is not None:\n current = current.right\n else:\n current = None\n\n print(' maxdepth left so far is {}'.format(maxdepth))\n\n current = root.right\n depth = 0\n\n while current is not None:\n if current.val not in seen:\n if (current.left is not None) and (current.right is not None):\n seen.update({current.val: True})\n else:\n seen.update({current.val: False})\n depth +=1\n maxdepth.append(depth)\n if current.right is not None:\n current = current.right\n elif current.left is not None:\n current = current.left\n else:\n current = None\n print(' maxdepth right so far is {}'.format(maxdepth))\n\n return max(maxdepth)","def get_height_iterative(self):\n max_so_far = 0\n nodes_queue = deque()\n nodes_queue.append((self.root, 0))\n while nodes_queue:\n node, depth = nodes_queue.popleft()\n max_so_far = max(max_so_far, depth)\n if node.left:\n nodes_queue.append((node.left, depth + 1))\n if node.right:\n nodes_queue.append((node.right, depth + 1))\n return max_so_far","def findLeaves(self, root):\n leaves = []\n self.dfs(root, leaves)\n return leaves","def heightTree(root):\n try:\n if (root is None):\n return -1\n else:\n return 1 + max(heightTree(root['left']), heightTree(root['right']))\n except Exception as exp:\n error.reraise(exp, 'RBT:heightTree')","def longest_ORF(dna):\n \n all_ORFs = find_all_ORFs_both_strands(dna)\n\n if len(all_ORFs) > 0:\n return max(all_ORFs, key = len)\n else:\n return []","def longest_path(numbers_list: List[int]) -> int:\r\n matrix = [1 for m in range(len(numbers_list))]\r\n for i in range(len(numbers_list)):\r\n for j in range(i):\r\n if numbers_list[i] > numbers_list[j]:\r\n matrix[i] = max(matrix[i], matrix[j] + 1)\r\n for i in matrix:\r\n print(i)\r\n return matrix[-1]","def longest_ORF(dna):\n orfs = find_all_ORFs_both_strands(dna)\n longest = max(orfs, key=len)\n return longest","def get_longest_state(data):\n return max(data, key=len)","def longest_key(self):\n longest = None\n for key in self:\n if not longest or len(key) > len(longest):\n longest = key\n return longest","def longest_ORF(dna):\n\n\n\n\n #use the find_all_orfs_both_strands function and then compute the max length of these\n ORFs = find_all_ORFs_both_strands(dna)\n return max(ORFs,key=len)","def longest_ORF(dna):\n ORFs = find_all_ORFs_both_strands(dna)\n longest = ''\n for ORF in ORFs:\n if len(ORF) > len(longest):\n longest = ORF\n return longest","def dump_longest_syntactic_path(self, file_name):\n assert(file_name is not None)\n with open(file_name, 'w') as fd:\n longest_path, maxpath_node_uids, subgraph_node_uids, subgraph_edge_uids = self.compute_longest_syntactic_path(False)\n for cur_uid in maxpath_node_uids:\n cur_node = self._nodes[cur_uid]\n s = \"\"\n if cur_uid != self._start_uid:\n s += \", \" + cur_node.get_label() + \")\\n\"\n if cur_uid != self._end_uid:\n s += \"(\" + cur_node.get_label()\n fd.write(s)\n return","def highest_root(self):\n assert(self.root_system.is_finite())\n assert(self.root_system.is_irreducible())\n return self.a_long_simple_root().to_dominant_chamber()","def get_max(self):\n if self.root is None: # BC1\n return float('-inf')\n\n current = self.root\n while current.right is not None: # Traverse like a linked-list\n current = current.right\n\n return current.key","def _height1(self): # works, but O(n^2) worst-case time\n return max(self.depth(p) for p in self.positions() if self.is_leaf(p))","def shortest_path_to_root(self):\n paths = self.hypernym_paths()\n shortest = paths.index(min([len(path) for path in paths]))\n return paths[shortest]","def mostLikelyPath(self, start, length=100):\n path = [start]\n for step in range(length):\n bestValue = -100000000\n bestAction = None\n for action in range(self.A):\n pathValue = self.valueLookAhead(path[-1][0], [1], action)\n # print((self.stateToCoord[nextState[0]], pathValue))\n if pathValue > bestValue:\n bestValue = pathValue\n bestAction = action\n possibleNextStates = self.trans(path[-1][0], path[-1][1])[bestAction]\n path.append(randomSample(possibleNextStates))\n return path","def longest_path_callback(self, data):\n min_idx = self.find_minimum_distance(data.poses) # closest point index\n if min_idx is None:\n return\n else:\n # extract 20 points along the closest point\n # use z position of ego car since z displacement doesn't matter\n # truncate if encounter head or tail\n path_points = np.array([\n (pose.pose.position.x, pose.pose.position.y, self.car_pos[2])\n for pose in data.poses[max(min_idx-10, 0):min_idx+10]]\n )\n # use svd to find the approximate tangent direction of longest path\n approx_dir = np.linalg.svd(path_points-np.mean(path_points,axis=0))[2][0]\n self.last_yaw_longestpath = np.arctan2(approx_dir[1], approx_dir[0])\n # perpendicular distance is then the norm of vector\n # (car_pos - pos_point) x approx_dir, x is cross product\n self.last_dist_longestpath = np.linalg.norm(\n np.cross(path_points[0,:] - self.car_pos, approx_dir)\n )\n # publish\n self.pub_closest_dist_longestpath.publish(self.last_dist_longestpath)","def longest_ORF(dna):\n l = find_all_ORFs_both_strands(dna)\n longest=''\n if len(l)>=1:\n\t longest =max(l,key=len)\n return longest","def __get_largest_node(self, root_node: _AVLTreeNode) -> _AVLTreeNode:\n\n curr_node = root_node\n while curr_node.right is not None:\n curr_node = curr_node.right\n\n return curr_node","def longest_ORF(dna):\n\n reverseComp = get_reverse_complement(dna)\n openFramesfromReverse = find_all_ORFs(reverseComp)\n openFramesfromNormal = find_all_ORFs(dna)\n all_ORFs = openFramesfromNormal + openFramesfromReverse\n longest = max(all_ORFs, key=len)\n return longest","def longest_word_length(words):","def longest_ORF(dna):\n orfs = find_all_ORFs_both_strands(dna)\n maxorf =orfs[1];\n for s in orfs:\n if len(s)>len(maxorf):\n maxorf=s\n return maxorf","def max_depth(self): # DirObj.max_depth\n md=self.depth\n if len(self.subdirs.keys()):\n for name, entry in self.subdirs.iteritems():\n if not entry.deleted:\n td = entry.max_depth()\n if td > md:\n md=td\n return md\n elif len(self.files.keys()):\n return md + 1\n else:\n return md","def longest_ORF(dna):\n i = 0\n both_ORFs = find_all_ORFs_both_strands(dna)\n longest = both_ORFs[0]\n while i + 1 < len(both_ORFs):\n if len(both_ORFs[i+1]) > len(longest):\n longest = both_ORFs[i+1]\n i+=1\n return longest","def get_max(self, root):\n if not root:\n return 0, 0, 0\n \n inc, dec = 1, 1\n\n li, ld, lt = self.get_max(root.left)\n ri, rd, rt = self.get_max(root.right)\n\n if root.left:\n if li and root.left.val - root.val == 1:\n inc = li + 1\n\n if ld and root.left.val - root.val == -1:\n dec = ld + 1\n\n if root.right:\n if ri and root.right.val - root.val == 1:\n inc = max(inc, ri + 1)\n\n if rd and root.right.val - root.val == -1:\n dec = max(dec, rd + 1)\n\n return inc, dec, max(inc + dec - 1, lt, rt)","def find_max_depth(start_url):\n print \"****** sequence of links that must be followed to reach the page *****\"\n S, Q = set(), deque()\n Q.append(start_url)\n while Q:\n u = Q.popleft()\n if u in S: continue\n b = u\n S.add(u)\n Q.extend(getLinks(u))\n find_shortest_path(start_url,b)\n print \"****** URL that is the greatest distance from start_url *****\"\n print b","def max_tree_id(self) -> int:\n\n return max(self.tree_ids) if len(self.tree_ids)>0 else 0","def lastPath(self, toNative=True):\n return self.paths(toNative=toNative)[-1]","def longest_prefix_match(self, routes):\n outroutes = []\n longest_prefix = 0\n for route in routes:\n bin_nmsk = '.'.join([bin(int(x)+256)[3:] for x in route[NMSK].split('.')])\n curr = self.len_pref(bin_nmsk)\n if curr > longest_prefix:\n outroutes = [route]\n longest_prefix = curr\n elif curr == longest_prefix:\n outroutes.append(route)\n return outroutes","def find_longest_matches(sorted_nodes1, sorted_nodes2):\n root = TreeNode(-1,-1)\n fill_tree(root, sorted_nodes1, sorted_nodes2)\n match = find_treepaths(root, [])\n\n # Remove (-1, -1) superroot.\n if isinstance(match[0], list): # More than one match of the same length.\n res = []\n for m in match:\n res.append([node.to_tuple() for node in m[1:]])\n return res\n else:\n return [[node.to_tuple() for node in match[1:]]]","def height(root: Node):\n return (max(height(root.left), height(root.right)) + 1) if root else 0","def max_depth(root):\n # basic case\n if root is None:\n return 0\n\n # breadth-first traversal\n queue = collections.deque([root])\n depth = 0\n while queue:\n queue_size = len(queue)\n for i in range(queue_size):\n curr = queue.popleft()\n if curr.left is not None:\n queue.append(curr.left)\n if curr.right is not None:\n queue.append(curr.right)\n depth += 1\n\n return depth","def get_height(root):\n if root is None:\n return 0\n return max(get_height(root.left), get_height(root.right)) + 1","def treeLevel(root):\n\n if not root:\n return 0\n else:\n return 1+max(treeLevel(root.left),treeLevel(root.right))","def longest_overall_delays(db: str) -> List[tuple]:\n query = \"\"\"SELECT station, SUM(minutes) AS total_delays\n FROM delays\n GROUP BY station\n ORDER BY total_delays DESC\"\"\"\n return run_query(db, query)[0:5]","def longest_ORF(dna):\n longest_ORF = []\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t# initialize empty list\n longest_ORF = longest_ORF + find_all_ORFs_both_strands(dna)\t\t\t\t\t\t\t\t# adds all ORFs both strands to list\n\n for n in range(len(longest_ORF)):\t\t\t\t\t\t\t\t\t\t\t\t\t\t# searches through the list\n\t if longest_ORF[n] == max(longest_ORF, key=len):\t\t\t\t\t\t\t\t\t\t# finds longest string\n\t \treturn longest_ORF[n]\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t# returns longest string","def longest_ORF(dna):\n l = find_all_ORFs_both_strands(dna)\n max_len = 0\n r = \"\"\n # [???] what if there are ORFs with same length?\n # this function just get the first one.\n if len(l) == 0:\n return \"\"\n for o in l:\n if len(o) > max_len:\n r = o\n max_len = len(o)\n return r","def get_height_iterative_augmentNode(self):\n max_so_far = 0\n nodes_queue = deque()\n self.root.depth = 0\n nodes_queue.append(self.root)\n while nodes_queue:\n curr = nodes_queue.popleft()\n max_so_far = max(max_so_far, curr.depth)\n for node in [curr.left, curr.right]:\n if node is None:\n continue\n node.depth = curr.depth + 1\n nodes_queue.append(node)\n return max_so_far","def get_longest_state(data):\n if isinstance(data, dict):\n data = data.keys()\n return sorted(data, key=len)[-1]","def max(self):\n return self._max(self.root)","def find_max(self):\n return self.root and self.root.find_max()","def _height1(self): # works, but O(n^2) worst-case time\n return max(self.depth(p) for p in self.positions() if self.is_leaf(p))","def longest(my_list):\r\n\treturn sorted(my_list, key=len)[-1]","def max_depth(self) -> int:\n return 0","def _height1(self): #works but n^2 time\n return max(self.depth(p) for p in self.positions() if self.is_leaf(p))","def find_maximum_value(self):\n if self.root: \n self.max_val = self.root.value\n else:\n return 'No tree found'\n def inner(root):\n if root.left:\n inner(root.left)\n\n if root.right:\n inner(root.right)\n\n if self.max_val < root.value:\n self.max_val = root.value\n\n inner(self.root)\n return self.max_val","def build_right_most_path(dfs_codes):\n\tpath = []\n\tprev_id = -1\n\tfor idx,c in reversed(list(enumerate(dfs_codes))):\n\t\tif c.fromn < c.to and (len(path) == 0 or prev_id == c.to):\n\t\t\tprev_id = c.fromn\n\t\t\tpath.append(idx)\n\treturn path","def longest(self):\n cps = collections.Counter()\n for crd in self:\n cps += collections.Counter( {crd.suit} )\n return sorted(cps.items(), reverse=True, key=lambda x:x[1])","def get_tree_length(x):\n length = list(self.__plan_graph.objects(subject=x, predicate=AGORA.length)).pop()\n return length","def max_error_leaf(self) -> int | str:\n if not self.separate_leaves:\n return (\n Enumerable(self.mlc_meas)\n .order_by_descending(lambda m: np.max(np.abs(m.error)))\n .select(lambda m: m.full_leaf_nums[0])\n .first()\n )\n else:\n max_meas = (\n Enumerable(self.mlc_meas)\n .order_by_descending(lambda m: np.max(np.abs(m.error)))\n .first()\n )\n if abs(max_meas.error[0]) > abs(max_meas.error[1]):\n return max_meas.full_leaf_nums[0]\n else:\n return max_meas.full_leaf_nums[1]","def max(self):\n return self.root.rightmost","def longest_ORF(dna):\n both_strings=find_all_ORFs_both_strands(dna)\n L=max(both_strings,key=len)\n Q=len(L)\n return Q\n\n #save out put of find all orfboth string to some variable","def largest_path_sum(T):\n return max(ft.reduce(fold_dist, T))","def part_2(distances: Distances) -> int:\n\n result, _ = max(generate_routes(distances))\n print(f\"part 2: longest route has distance {result}\")\n return result","def get_max_depth(clf):\n tree =clf.tree_\n def get_node_depths_(current_node, current_depth, l, r, depths):\n depths += [current_depth]\n if l[current_node] != -1 and r[current_node] != -1:\n get_node_depths_(l[current_node], current_depth + 1, l, r, depths)\n get_node_depths_(r[current_node], current_depth + 1, l, r, depths)\n\n depths = []\n get_node_depths_(0, 0, tree.children_left, tree.children_right, depths) \n return max(depths)","def get_latest_root_id(self, root_id: np.uint64) -> np.ndarray:\n\n id_working_set = [root_id]\n new_parent_key = serialize_key(\"new_parents\")\n latest_root_ids = []\n\n while len(id_working_set) > 0:\n\n next_id = id_working_set[0]\n del(id_working_set[0])\n r = self.table.read_row(serialize_uint64(next_id))\n\n # Check if a new root id was attached to this root id\n if new_parent_key in r.cells[self.family_id]:\n id_working_set.extend(\n np.frombuffer(\n r.cells[self.family_id][new_parent_key][0].value,\n dtype=np.uint64))\n else:\n latest_root_ids.append(next_id)\n\n return np.unique(latest_root_ids)","def path_lengths(graph):\n allPairsPathLengths = dict(nx.all_pairs_dijkstra_path_length(graph, weight='lgth'))\n shortestPathLength = np.array([[length for length in pair.values()] for pair in allPairsPathLengths.values()])\n shortestPathLength = np.tril(shortestPathLength)\n shortestPathLength[shortestPathLength == 0] = np.nan\n return(shortestPathLength)","def get_longest_word(lettersGrid, dictionary):\n size = len(lettersGrid)\n maxLen = size*size\n # pruning: filter impossible words in the dictionary\n newDict = filterDict(lettersGrid, dictionary, maxLen)\n\n longestLen = 0\n longestPath = []\n for i in range(size):\n for j in range(size): \n startCoord = (i,j)\n startPath = [startCoord]\n startStack = [(startCoord, startPath)]\n # find longest path with each start cell, and update longest\n # length and path\n currLen, currPath = dfs_on_grid(startStack, size, maxLen,\n lettersGrid, newDict)\n if currLen == maxLen:\n return path_to_word(currPath, lettersGrid)\n if currLen > longestLen:\n longestLen = currLen\n longestPath = currPath\n\n # convert coordinates to letters before returning\n return path_to_word(longestPath, lettersGrid)","def path_from_root(self):\n path = []\n parent = self.parent\n child = self\n while parent is not None:\n if child is parent.left_subtree:\n path.append('left')\n else:\n path.append('right')\n child = parent\n parent = parent.parent\n \n path.reverse()\n return path","def depth(self):\n return max(n.depth for n in self.iternodes())","def max_recursive(S):\n if len(S) == 0:\n return None\n elif len(S) == 1:\n return S[0]\n else:\n max_ele1 = max_recursive(S[:len(S) // 2])\n max_ele2 = max_recursive(S[len(S) // 2 :])\n if max_ele1 > max_ele2:\n return max_ele1\n else:\n return max_ele2","def max_depth(self) -> int:\n return pulumi.get(self, \"max_depth\")","def _update_max(self):\n tmp = self\n while tmp.right is not None:\n tmp = tmp.right\n return tmp.parent.key","def longest_seq(n):\n max_seq = 0\n for i in range(SEQ_LENGTH):\n max_seq = max(max_seq, longest_seq_of_1s(n, i))\n\n return max_seq","def longest_word_length(words):\n\n longest = len(word[0])\n\n for word in words:\n if longest < len(word):\n longest = len(word)\n\n return longest","def find_longest_word(words):\n \n # lengths = []\n\n # for word in words: \n # l = len(word)\n # lengths.append(l)\n # result = max(lengths)\n # return result\n\n #ALT SOLUTION ONE LINE \n return len(max(words, key=lambda words: len(words)))","def find_all_longest_words(dirname):\n return {filename: \\\n find_longest_word(os.path.join(dirname, filename))\n for filename in os.listdir(dirname)\n if os.path.isfile(os.path.join(dirname,\\\n filename))}","def max_depth(self):\r\n lvl = 1\r\n has_lvl_desc = True\r\n while has_lvl_desc:\r\n num_children = len(self.level_n_descendants(lvl))\r\n if num_children==0:\r\n has_lvl_desc = False\r\n else:\r\n lvl+=1\r\n return lvl-1","def longest_run(L):\n\tlongest_length = 1\n\tincreasing_length = 1\n\tdecreasing_length = 1\n\tfor i in range(len(L) - 1):\n\t\tif L[i] >= L[i+1]:\n\t\t\tdecreasing_length += 1\n\t\telse:\n\t\t\tdecreasing_length = 1\n\t\tif L[i] <= L[i+1]:\n\t\t\tincreasing_length += 1\n\t\telse:\n\t\t\tincreasing_length = 1\n\t\tif increasing_length > longest_length:\n\t\t\tlongest_length = increasing_length\n\t\t\trun_end = i + 1\n\t\telif decreasing_length > longest_length:\n\t\t\tlongest_length = decreasing_length\n\t\t\trun_end = i + 1\n\n\treturn sum(L[run_end - longest_length + 1 : run_end+1])","def get_max_depth_node(nodes):\n curr = nodes[0]\n for i in range(0, len(nodes)):\n if nodes[i].depth > curr.depth:\n curr = nodes[i]\n return curr"],"string":"[\n \"def longest_path(game, player, cur_length=0, max_length=10):\\n moves = game.get_legal_moves(player)\\n\\n # Break recursion if we reach a dead end or we're at the limit.\\n if not moves or cur_length >= max_length:\\n return cur_length\\n # Otherwise search recursively.\\n else:\\n best_depth = 0\\n for move in moves:\\n game_copy = try_move(game, move, player)\\n move_depth = longest_path(game_copy, player, cur_length + 1)\\n if move_depth > best_depth:\\n best_depth = move_depth\\n # As soon as we're at the depth limit, there's no reason to\\n # search more moves.\\n if best_depth == max_length:\\n return best_depth\\n return best_depth\",\n \"def find_longest(nseqs = None):\\n if nseqs:\\n set_nseqs(nseqs)\\n\\n # If nseqs == 1, the function would return all the words of the dict.\\n if _nseqs == 1:\\n return node(_wordset.pop(),None)\\n\\n global COUNT\\n def reset_grow(node):\\n COUNT = 0\\n return grow(node)\\n\\n #leaves = [reset_grow(node(word,None)) for word in _wordset]\\n #return max(leaves)\\n maxleaf = node('',None)\\n for word in _wordset:\\n # This print statement is best indicator of inf loop or wasting time\\n print('checking root: '+word)\\n maxleaf = max([maxleaf, grow(node(word,None))])\\n\\n return maxleaf\",\n \"def get_longest_paths(nodes, graph):\\n paths = []\\n distances = []\\n possible_paths = list(combinations(nodes, r=2))\\n for node1, node2 in possible_paths:\\n try:\\n path = nx.shortest_path(graph, node1, node2, \\\"weight\\\")\\n except Exception,e:\\n path = []\\n if len(path)>1:\\n distance = get_path_distance(path, graph)\\n paths.append(path)\\n distances.append(distance)\\n paths_sorted = [x for (y,x) in sorted(zip(distances, paths), reverse=True)]\\n # longest_path = paths_sorted[0]\\n # return longest_path\\n return paths_sorted\",\n \"def calculate_tree_height(tree):\\n max_height = 0\\n for i in tree.values():\\n if i.is_leaf():\\n path = i.path_to_root()\\n if len(path) > max_height:\\n max_height = len(path)\\n\\n return max_height\",\n \"def max_single_path(self, root: Optional[TreeNode]) -> int:\\n if not root:\\n return 0\\n\\n if root in self.single_path_cache:\\n return self.single_path_cache[root]\\n\\n result = max(0, root.val)\\n if root.left:\\n left = self.max_single_path(root.left)\\n result = max(result, left + root.val)\\n if root.right:\\n right = self.max_single_path(root.right)\\n result = max(result, right + root.val)\\n\\n self.single_path_cache[root] = result\\n return result\",\n \"def longest_path(self, sorted_node):\\n \\n dist = {}\\n \\n # Initialise dict with weight ('0') and previous seq ('null')\\n for node in sorted_node: \\n \\n dist[node] = [0, \\\"\\\"] \\n \\n # Finding longest path\\n for node in sorted_node:\\n \\n for prefix in self.prefix[node]: \\n \\n temp_weight = self.get_weight(prefix, node) + dist[prefix][0]\\n # update each weight with greatest path\\n if temp_weight > dist[node][0]:\\n dist[node][0] = temp_weight\\n dist[node][1] = prefix \\n \\n \\n return dist\",\n \"def _find_max(self, root):\\n while root.right:\\n root = root.right\\n return root\",\n \"def internal_path_len(root, height=0):\\n\\n if root is None:\\n return 0\\n else:\\n return height + internal_path_len(root.left, height + 1) + internal_path_len(root.right, height + 1)\",\n \"def max_root_time(self):\\n if self.num_samples == 0:\\n raise ValueError(\\n \\\"max_root_time is not defined in a tree sequence with 0 samples\\\"\\n )\\n ret = max(self.nodes_time[u] for u in self.samples())\\n if self.num_edges > 0:\\n # Edges are guaranteed to be listed in parent-time order, so we can get the\\n # last one to get the oldest root\\n edge = self.edge(self.num_edges - 1)\\n # However, we can have situations where there is a sample older than a\\n # 'proper' root\\n ret = max(ret, self.nodes_time[edge.parent])\\n return ret\",\n \"def maxPathSum(self, root):\\n def maxPotential(node):\\n \\\"\\\"\\\"Return max potention from each node in tree.\\\"\\\"\\\"\\n nonlocal maxsum\\n # Allocate null values to 0\\n if not node:\\n return 0\\n\\n # Get the max sum from the left and right subtrees\\n # We only care about possible gains (no negative values)\\n # Iterates all the way to the far left\\n left_max = max(maxPotential(node.left), 0)\\n print(\\\"left_max:\\\", left_max)\\n # Iterates down the recursive stack\\n right_max = max(maxPotential(node.right), 0)\\n print(\\\"right_max:\\\", right_max)\\n\\n # Get sum of potential\\n potential = node.val + left_max + right_max\\n print(\\\"potential\\\", potential)\\n\\n # Update new maxsum\\n maxsum = max(maxsum, potential)\\n\\n # Recursively return the max potential if continue on same path\\n return node.val + max(left_max, right_max)\\n\\n # Initialize maxsum to negative infinity\\n maxsum = float('-inf')\\n maxPotential(root)\\n\\n return maxsum\",\n \"def diameterOfBinaryTree(self, root):\\n self.max_length = 0\\n def maxDepth(root):\\n if not root:\\n return 0\\n left_branch = maxDepth(root.left)\\n right_branch = maxDepth(root.right)\\n self.max_length = max(self.max_length, left_branch + right_branch)\\n return max(left_branch, right_branch) + 1\\n maxDepth(root)\\n return self.max_length\",\n \"def find_best_path(self, root):\\n number_vertices = len(self.states)\\n distances = [-float(\\\"inf\\\")] * number_vertices\\n distances[root] = 0\\n predecessors = [None] * number_vertices\\n\\n for _ in range(number_vertices - 1):\\n for origin in range(number_vertices):\\n for (target, value) in self.transitions[origin]:\\n if distances[target] < distances[origin] + value:\\n distances[target] = distances[origin] + value\\n predecessors[target] = origin\\n\\n # compute the vertices with the highest value, excluding the root\\n distances[root] = -float(\\\"inf\\\")\\n most_valued_vertices = np.nonzero(distances == np.max(distances))[0]\\n # choose at *random* among the most valuable vertices\\n most_valued_vertex = np.random.choice(most_valued_vertices)\\n return most_valued_vertex, predecessors\",\n \"def find_maximal_path(graph):\\n maximal_path_in_graph = [] # This is where the maximal path in the graph is stored (updates)\\n checked_pairs = set() # In order not to check a pair twice, the set stores the already checked pairs (and the\\n # reversed order of the tuple\\n for node_start in graph.nodes.keys():\\n for node_end in graph.nodes.keys():\\n tup_of_nodes = (node_start, node_end) # This tuple is checked in checked_pairs\\n # Need to make sure that the path is valid (!=Node) and that it is not checked yet\\n if graph.find_longest_path(node_start,\\n node_end) != None and tup_of_nodes not in checked_pairs:\\n tup_of_nodes_reverse = (node_end, node_start) # This is a tuple with the opposite order\\n checked_pairs.add(tup_of_nodes)\\n checked_pairs.add(tup_of_nodes_reverse)\\n maximal_path_for_pair = graph.find_longest_path(node_start, node_end)\\n # Updates the maximal path per pair exceeds the current one\\n if len(maximal_path_for_pair) > len(maximal_path_in_graph):\\n maximal_path_in_graph = maximal_path_for_pair\\n return \\\"Maximal path between nodes is: {}, and the length is {} nodes.\\\".format(maximal_path_in_graph, \\\\\\n len(maximal_path_in_graph))\",\n \"def longest(self):\\n longest = None\\n max_len = 0\\n for vector in self._vectors:\\n len = vector.length2\\n if len > max_len:\\n longest = vector\\n max_len = len\\n return longest\",\n \"def find_longest(input):\\r\\n for thing in input:\\r\\n print thing\\r\\n dist_array = [[0 for x in range(rows)] for x in range(cols)] # rows and cols are static variables in main method\\r\\n for x in xrange(0, len(input), 1):\\r\\n for y in xrange(0, len(input[x]), 1):\\r\\n dist_array[x][y] = calculate_longest(dist_array, input, x, y)\\r\\n for item in dist_array:\\r\\n print item\\r\\n return max(max(dist_array))\",\n \"def find_max(self, root = None):\\n return self._find_max(root if root else self.root)\",\n \"def deep_max(self):\\r\\n node = self\\r\\n while not node.is_leaf():\\r\\n node = node.children[-1]\\r\\n return node.keys[-1] if node.keys else None\",\n \"def find_max(self) -> TreeNode:\\n node = self.root\\n while True:\\n if not node.right:\\n return node\\n node = node.right\",\n \"def getParseWithLongestRootWord(self) -> FsmParse:\\n maxLength = -1\\n bestParse = None\\n for currentParse in self.__fsmParses:\\n if len(currentParse.getWord().getName()) > maxLength:\\n maxLength = len(currentParse.getWord().getName())\\n bestParse = currentParse\\n return bestParse\",\n \"def compute_longest_chain(self):\\n max_len = 0\\n for m in self.miners:\\n if m.chain.blocks[-1].height > max_len:\\n max_len = m.chain.blocks[-1].height\\n self.main_chain = m.chain.blocks\",\n \"def max_path_sum(root_elem):\\r\\n\\tif root_elem is None:\\r\\n\\t\\treturn 0\\r\\n\\tif root_elem.left is None and root_elem.right is None:\\r\\n\\t\\treturn root_elem.value\\r\\n\\tmax_child = max(max_path_sum(root_elem.left),max_path_sum(root_elem.left))\\r\\n\\treturn root_elem.value + max_child\",\n \"def max_tree_depth(self):\\n\\n depths = np.array([leaf.tree_depth for leaf in self.leaves])\\n\\n return depths.max()\",\n \"def _max_depth(self):\\n max_depth = 0\\n for node, data in self.traverse():\\n max_depth = max(max_depth, data['level'])\\n return max_depth\",\n \"def maximumDistance(self):\\n from ete2 import Tree\\n t = Tree(name='LUCA_root')\\n empty_forest = {'sp':t,'gns':t,'fam':t,'ord':t,'cls':t,'phy':t,'kng':t}\\n return self.distanceToTree(empty_forest,update_inner_attributes=False)\",\n \"def longestStrChain_wrong(self, words) -> int:\\n\\n # sort list based on length\\n words_dict = {}\\n for i in words:\\n l = len(i)\\n if l not in words_dict.keys():\\n words_dict[l] = [i]\\n else:\\n words_dict[l].append(i)\\n word_sort = sorted([(i, j) for i, j in words_dict.items()], key=lambda x: x[0])\\n #print(word_sort)\\n\\n roots = [Node(i) for i in word_sort[0][1]]\\n pre_roots = roots\\n cur_roots = []\\n for _, word_list in word_sort[1:]:\\n cur_roots = []\\n for i in pre_roots:\\n child = [Node(x) for x in word_list if self.is_predecessor(i.val, x)]\\n i.child = child\\n cur_roots += child\\n pre_roots = cur_roots\\n print(f'layer={_}, list: {word_list}, cur_roots={[x.val for x in cur_roots]}')\\n\\n return self.run_list(roots)\",\n \"def a_long_simple_root(self):\\n if self.dynkin_diagram().rank() == 1:\\n return self.simple_roots()[self.index_set()[0]]\\n longest=self.dynkin_diagram().outgoing_edges()[0]\\n for j in self.dynkin_diagram().outgoing_edges():\\n if j[2]>longest[2]:\\n longest=j\\n return self.simple_roots()[longest[0]]\",\n \"def longest_flight(self):\\r\\n distance = 0\\r\\n for code, _list in self.edges.items():\\r\\n for edge in _list:\\r\\n if edge.distance > distance:\\r\\n distance = edge.distance\\r\\n start = edge.start\\r\\n destination = edge.destination\\r\\n return start, destination, distance\",\n \"def longest_flight(g):\\n max_distance = None\\n max_destination = None\\n max_key = None\\n \\n for key in g.city_dict:\\n for flight in g.city_dict[key].get_flights_out():\\n if(flight[1] > max_distance):\\n max_key = key\\n max_destination = flight[0]\\n max_distance = flight[1]\\n return g.city_dict[max_key].get_code(), max_destination, max_distance\",\n \"def calculate_max_paths(self):\\n self.max_paths = {}\\n first_nodes = [key for (key, val) in self.predecessors.items() if not val]\\n for nm in first_nodes:\\n self.max_paths[nm] = {}\\n self._checking_path(node_name=nm, first_name=nm)\",\n \"def height(root:Node) -> int:\\n current = root.left\\n depth = 0\\n maxdepth = [0]\\n #track the value and whether it has a branchpoint or not (bool)\\n seen = dict()\\n\\n #do the left side first, then the right\\n\\n while current is not None:\\n if current.val not in seen:\\n if (current.left is not None) and (current.right is not None):\\n seen.update({current.val:True})\\n else:\\n seen.update({current.val:False})\\n depth +=1\\n maxdepth.append(depth)\\n if current.left is not None:\\n current = current.left\\n elif current.right is not None:\\n current = current.right\\n else:\\n current = None\\n\\n print(' maxdepth left so far is {}'.format(maxdepth))\\n\\n current = root.right\\n depth = 0\\n\\n while current is not None:\\n if current.val not in seen:\\n if (current.left is not None) and (current.right is not None):\\n seen.update({current.val: True})\\n else:\\n seen.update({current.val: False})\\n depth +=1\\n maxdepth.append(depth)\\n if current.right is not None:\\n current = current.right\\n elif current.left is not None:\\n current = current.left\\n else:\\n current = None\\n print(' maxdepth right so far is {}'.format(maxdepth))\\n\\n return max(maxdepth)\",\n \"def get_height_iterative(self):\\n max_so_far = 0\\n nodes_queue = deque()\\n nodes_queue.append((self.root, 0))\\n while nodes_queue:\\n node, depth = nodes_queue.popleft()\\n max_so_far = max(max_so_far, depth)\\n if node.left:\\n nodes_queue.append((node.left, depth + 1))\\n if node.right:\\n nodes_queue.append((node.right, depth + 1))\\n return max_so_far\",\n \"def findLeaves(self, root):\\n leaves = []\\n self.dfs(root, leaves)\\n return leaves\",\n \"def heightTree(root):\\n try:\\n if (root is None):\\n return -1\\n else:\\n return 1 + max(heightTree(root['left']), heightTree(root['right']))\\n except Exception as exp:\\n error.reraise(exp, 'RBT:heightTree')\",\n \"def longest_ORF(dna):\\n \\n all_ORFs = find_all_ORFs_both_strands(dna)\\n\\n if len(all_ORFs) > 0:\\n return max(all_ORFs, key = len)\\n else:\\n return []\",\n \"def longest_path(numbers_list: List[int]) -> int:\\r\\n matrix = [1 for m in range(len(numbers_list))]\\r\\n for i in range(len(numbers_list)):\\r\\n for j in range(i):\\r\\n if numbers_list[i] > numbers_list[j]:\\r\\n matrix[i] = max(matrix[i], matrix[j] + 1)\\r\\n for i in matrix:\\r\\n print(i)\\r\\n return matrix[-1]\",\n \"def longest_ORF(dna):\\n orfs = find_all_ORFs_both_strands(dna)\\n longest = max(orfs, key=len)\\n return longest\",\n \"def get_longest_state(data):\\n return max(data, key=len)\",\n \"def longest_key(self):\\n longest = None\\n for key in self:\\n if not longest or len(key) > len(longest):\\n longest = key\\n return longest\",\n \"def longest_ORF(dna):\\n\\n\\n\\n\\n #use the find_all_orfs_both_strands function and then compute the max length of these\\n ORFs = find_all_ORFs_both_strands(dna)\\n return max(ORFs,key=len)\",\n \"def longest_ORF(dna):\\n ORFs = find_all_ORFs_both_strands(dna)\\n longest = ''\\n for ORF in ORFs:\\n if len(ORF) > len(longest):\\n longest = ORF\\n return longest\",\n \"def dump_longest_syntactic_path(self, file_name):\\n assert(file_name is not None)\\n with open(file_name, 'w') as fd:\\n longest_path, maxpath_node_uids, subgraph_node_uids, subgraph_edge_uids = self.compute_longest_syntactic_path(False)\\n for cur_uid in maxpath_node_uids:\\n cur_node = self._nodes[cur_uid]\\n s = \\\"\\\"\\n if cur_uid != self._start_uid:\\n s += \\\", \\\" + cur_node.get_label() + \\\")\\\\n\\\"\\n if cur_uid != self._end_uid:\\n s += \\\"(\\\" + cur_node.get_label()\\n fd.write(s)\\n return\",\n \"def highest_root(self):\\n assert(self.root_system.is_finite())\\n assert(self.root_system.is_irreducible())\\n return self.a_long_simple_root().to_dominant_chamber()\",\n \"def get_max(self):\\n if self.root is None: # BC1\\n return float('-inf')\\n\\n current = self.root\\n while current.right is not None: # Traverse like a linked-list\\n current = current.right\\n\\n return current.key\",\n \"def _height1(self): # works, but O(n^2) worst-case time\\n return max(self.depth(p) for p in self.positions() if self.is_leaf(p))\",\n \"def shortest_path_to_root(self):\\n paths = self.hypernym_paths()\\n shortest = paths.index(min([len(path) for path in paths]))\\n return paths[shortest]\",\n \"def mostLikelyPath(self, start, length=100):\\n path = [start]\\n for step in range(length):\\n bestValue = -100000000\\n bestAction = None\\n for action in range(self.A):\\n pathValue = self.valueLookAhead(path[-1][0], [1], action)\\n # print((self.stateToCoord[nextState[0]], pathValue))\\n if pathValue > bestValue:\\n bestValue = pathValue\\n bestAction = action\\n possibleNextStates = self.trans(path[-1][0], path[-1][1])[bestAction]\\n path.append(randomSample(possibleNextStates))\\n return path\",\n \"def longest_path_callback(self, data):\\n min_idx = self.find_minimum_distance(data.poses) # closest point index\\n if min_idx is None:\\n return\\n else:\\n # extract 20 points along the closest point\\n # use z position of ego car since z displacement doesn't matter\\n # truncate if encounter head or tail\\n path_points = np.array([\\n (pose.pose.position.x, pose.pose.position.y, self.car_pos[2])\\n for pose in data.poses[max(min_idx-10, 0):min_idx+10]]\\n )\\n # use svd to find the approximate tangent direction of longest path\\n approx_dir = np.linalg.svd(path_points-np.mean(path_points,axis=0))[2][0]\\n self.last_yaw_longestpath = np.arctan2(approx_dir[1], approx_dir[0])\\n # perpendicular distance is then the norm of vector\\n # (car_pos - pos_point) x approx_dir, x is cross product\\n self.last_dist_longestpath = np.linalg.norm(\\n np.cross(path_points[0,:] - self.car_pos, approx_dir)\\n )\\n # publish\\n self.pub_closest_dist_longestpath.publish(self.last_dist_longestpath)\",\n \"def longest_ORF(dna):\\n l = find_all_ORFs_both_strands(dna)\\n longest=''\\n if len(l)>=1:\\n\\t longest =max(l,key=len)\\n return longest\",\n \"def __get_largest_node(self, root_node: _AVLTreeNode) -> _AVLTreeNode:\\n\\n curr_node = root_node\\n while curr_node.right is not None:\\n curr_node = curr_node.right\\n\\n return curr_node\",\n \"def longest_ORF(dna):\\n\\n reverseComp = get_reverse_complement(dna)\\n openFramesfromReverse = find_all_ORFs(reverseComp)\\n openFramesfromNormal = find_all_ORFs(dna)\\n all_ORFs = openFramesfromNormal + openFramesfromReverse\\n longest = max(all_ORFs, key=len)\\n return longest\",\n \"def longest_word_length(words):\",\n \"def longest_ORF(dna):\\n orfs = find_all_ORFs_both_strands(dna)\\n maxorf =orfs[1];\\n for s in orfs:\\n if len(s)>len(maxorf):\\n maxorf=s\\n return maxorf\",\n \"def max_depth(self): # DirObj.max_depth\\n md=self.depth\\n if len(self.subdirs.keys()):\\n for name, entry in self.subdirs.iteritems():\\n if not entry.deleted:\\n td = entry.max_depth()\\n if td > md:\\n md=td\\n return md\\n elif len(self.files.keys()):\\n return md + 1\\n else:\\n return md\",\n \"def longest_ORF(dna):\\n i = 0\\n both_ORFs = find_all_ORFs_both_strands(dna)\\n longest = both_ORFs[0]\\n while i + 1 < len(both_ORFs):\\n if len(both_ORFs[i+1]) > len(longest):\\n longest = both_ORFs[i+1]\\n i+=1\\n return longest\",\n \"def get_max(self, root):\\n if not root:\\n return 0, 0, 0\\n \\n inc, dec = 1, 1\\n\\n li, ld, lt = self.get_max(root.left)\\n ri, rd, rt = self.get_max(root.right)\\n\\n if root.left:\\n if li and root.left.val - root.val == 1:\\n inc = li + 1\\n\\n if ld and root.left.val - root.val == -1:\\n dec = ld + 1\\n\\n if root.right:\\n if ri and root.right.val - root.val == 1:\\n inc = max(inc, ri + 1)\\n\\n if rd and root.right.val - root.val == -1:\\n dec = max(dec, rd + 1)\\n\\n return inc, dec, max(inc + dec - 1, lt, rt)\",\n \"def find_max_depth(start_url):\\n print \\\"****** sequence of links that must be followed to reach the page *****\\\"\\n S, Q = set(), deque()\\n Q.append(start_url)\\n while Q:\\n u = Q.popleft()\\n if u in S: continue\\n b = u\\n S.add(u)\\n Q.extend(getLinks(u))\\n find_shortest_path(start_url,b)\\n print \\\"****** URL that is the greatest distance from start_url *****\\\"\\n print b\",\n \"def max_tree_id(self) -> int:\\n\\n return max(self.tree_ids) if len(self.tree_ids)>0 else 0\",\n \"def lastPath(self, toNative=True):\\n return self.paths(toNative=toNative)[-1]\",\n \"def longest_prefix_match(self, routes):\\n outroutes = []\\n longest_prefix = 0\\n for route in routes:\\n bin_nmsk = '.'.join([bin(int(x)+256)[3:] for x in route[NMSK].split('.')])\\n curr = self.len_pref(bin_nmsk)\\n if curr > longest_prefix:\\n outroutes = [route]\\n longest_prefix = curr\\n elif curr == longest_prefix:\\n outroutes.append(route)\\n return outroutes\",\n \"def find_longest_matches(sorted_nodes1, sorted_nodes2):\\n root = TreeNode(-1,-1)\\n fill_tree(root, sorted_nodes1, sorted_nodes2)\\n match = find_treepaths(root, [])\\n\\n # Remove (-1, -1) superroot.\\n if isinstance(match[0], list): # More than one match of the same length.\\n res = []\\n for m in match:\\n res.append([node.to_tuple() for node in m[1:]])\\n return res\\n else:\\n return [[node.to_tuple() for node in match[1:]]]\",\n \"def height(root: Node):\\n return (max(height(root.left), height(root.right)) + 1) if root else 0\",\n \"def max_depth(root):\\n # basic case\\n if root is None:\\n return 0\\n\\n # breadth-first traversal\\n queue = collections.deque([root])\\n depth = 0\\n while queue:\\n queue_size = len(queue)\\n for i in range(queue_size):\\n curr = queue.popleft()\\n if curr.left is not None:\\n queue.append(curr.left)\\n if curr.right is not None:\\n queue.append(curr.right)\\n depth += 1\\n\\n return depth\",\n \"def get_height(root):\\n if root is None:\\n return 0\\n return max(get_height(root.left), get_height(root.right)) + 1\",\n \"def treeLevel(root):\\n\\n if not root:\\n return 0\\n else:\\n return 1+max(treeLevel(root.left),treeLevel(root.right))\",\n \"def longest_overall_delays(db: str) -> List[tuple]:\\n query = \\\"\\\"\\\"SELECT station, SUM(minutes) AS total_delays\\n FROM delays\\n GROUP BY station\\n ORDER BY total_delays DESC\\\"\\\"\\\"\\n return run_query(db, query)[0:5]\",\n \"def longest_ORF(dna):\\n longest_ORF = []\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t# initialize empty list\\n longest_ORF = longest_ORF + find_all_ORFs_both_strands(dna)\\t\\t\\t\\t\\t\\t\\t\\t# adds all ORFs both strands to list\\n\\n for n in range(len(longest_ORF)):\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t# searches through the list\\n\\t if longest_ORF[n] == max(longest_ORF, key=len):\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t# finds longest string\\n\\t \\treturn longest_ORF[n]\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t# returns longest string\",\n \"def longest_ORF(dna):\\n l = find_all_ORFs_both_strands(dna)\\n max_len = 0\\n r = \\\"\\\"\\n # [???] what if there are ORFs with same length?\\n # this function just get the first one.\\n if len(l) == 0:\\n return \\\"\\\"\\n for o in l:\\n if len(o) > max_len:\\n r = o\\n max_len = len(o)\\n return r\",\n \"def get_height_iterative_augmentNode(self):\\n max_so_far = 0\\n nodes_queue = deque()\\n self.root.depth = 0\\n nodes_queue.append(self.root)\\n while nodes_queue:\\n curr = nodes_queue.popleft()\\n max_so_far = max(max_so_far, curr.depth)\\n for node in [curr.left, curr.right]:\\n if node is None:\\n continue\\n node.depth = curr.depth + 1\\n nodes_queue.append(node)\\n return max_so_far\",\n \"def get_longest_state(data):\\n if isinstance(data, dict):\\n data = data.keys()\\n return sorted(data, key=len)[-1]\",\n \"def max(self):\\n return self._max(self.root)\",\n \"def find_max(self):\\n return self.root and self.root.find_max()\",\n \"def _height1(self): # works, but O(n^2) worst-case time\\n return max(self.depth(p) for p in self.positions() if self.is_leaf(p))\",\n \"def longest(my_list):\\r\\n\\treturn sorted(my_list, key=len)[-1]\",\n \"def max_depth(self) -> int:\\n return 0\",\n \"def _height1(self): #works but n^2 time\\n return max(self.depth(p) for p in self.positions() if self.is_leaf(p))\",\n \"def find_maximum_value(self):\\n if self.root: \\n self.max_val = self.root.value\\n else:\\n return 'No tree found'\\n def inner(root):\\n if root.left:\\n inner(root.left)\\n\\n if root.right:\\n inner(root.right)\\n\\n if self.max_val < root.value:\\n self.max_val = root.value\\n\\n inner(self.root)\\n return self.max_val\",\n \"def build_right_most_path(dfs_codes):\\n\\tpath = []\\n\\tprev_id = -1\\n\\tfor idx,c in reversed(list(enumerate(dfs_codes))):\\n\\t\\tif c.fromn < c.to and (len(path) == 0 or prev_id == c.to):\\n\\t\\t\\tprev_id = c.fromn\\n\\t\\t\\tpath.append(idx)\\n\\treturn path\",\n \"def longest(self):\\n cps = collections.Counter()\\n for crd in self:\\n cps += collections.Counter( {crd.suit} )\\n return sorted(cps.items(), reverse=True, key=lambda x:x[1])\",\n \"def get_tree_length(x):\\n length = list(self.__plan_graph.objects(subject=x, predicate=AGORA.length)).pop()\\n return length\",\n \"def max_error_leaf(self) -> int | str:\\n if not self.separate_leaves:\\n return (\\n Enumerable(self.mlc_meas)\\n .order_by_descending(lambda m: np.max(np.abs(m.error)))\\n .select(lambda m: m.full_leaf_nums[0])\\n .first()\\n )\\n else:\\n max_meas = (\\n Enumerable(self.mlc_meas)\\n .order_by_descending(lambda m: np.max(np.abs(m.error)))\\n .first()\\n )\\n if abs(max_meas.error[0]) > abs(max_meas.error[1]):\\n return max_meas.full_leaf_nums[0]\\n else:\\n return max_meas.full_leaf_nums[1]\",\n \"def max(self):\\n return self.root.rightmost\",\n \"def longest_ORF(dna):\\n both_strings=find_all_ORFs_both_strands(dna)\\n L=max(both_strings,key=len)\\n Q=len(L)\\n return Q\\n\\n #save out put of find all orfboth string to some variable\",\n \"def largest_path_sum(T):\\n return max(ft.reduce(fold_dist, T))\",\n \"def part_2(distances: Distances) -> int:\\n\\n result, _ = max(generate_routes(distances))\\n print(f\\\"part 2: longest route has distance {result}\\\")\\n return result\",\n \"def get_max_depth(clf):\\n tree =clf.tree_\\n def get_node_depths_(current_node, current_depth, l, r, depths):\\n depths += [current_depth]\\n if l[current_node] != -1 and r[current_node] != -1:\\n get_node_depths_(l[current_node], current_depth + 1, l, r, depths)\\n get_node_depths_(r[current_node], current_depth + 1, l, r, depths)\\n\\n depths = []\\n get_node_depths_(0, 0, tree.children_left, tree.children_right, depths) \\n return max(depths)\",\n \"def get_latest_root_id(self, root_id: np.uint64) -> np.ndarray:\\n\\n id_working_set = [root_id]\\n new_parent_key = serialize_key(\\\"new_parents\\\")\\n latest_root_ids = []\\n\\n while len(id_working_set) > 0:\\n\\n next_id = id_working_set[0]\\n del(id_working_set[0])\\n r = self.table.read_row(serialize_uint64(next_id))\\n\\n # Check if a new root id was attached to this root id\\n if new_parent_key in r.cells[self.family_id]:\\n id_working_set.extend(\\n np.frombuffer(\\n r.cells[self.family_id][new_parent_key][0].value,\\n dtype=np.uint64))\\n else:\\n latest_root_ids.append(next_id)\\n\\n return np.unique(latest_root_ids)\",\n \"def path_lengths(graph):\\n allPairsPathLengths = dict(nx.all_pairs_dijkstra_path_length(graph, weight='lgth'))\\n shortestPathLength = np.array([[length for length in pair.values()] for pair in allPairsPathLengths.values()])\\n shortestPathLength = np.tril(shortestPathLength)\\n shortestPathLength[shortestPathLength == 0] = np.nan\\n return(shortestPathLength)\",\n \"def get_longest_word(lettersGrid, dictionary):\\n size = len(lettersGrid)\\n maxLen = size*size\\n # pruning: filter impossible words in the dictionary\\n newDict = filterDict(lettersGrid, dictionary, maxLen)\\n\\n longestLen = 0\\n longestPath = []\\n for i in range(size):\\n for j in range(size): \\n startCoord = (i,j)\\n startPath = [startCoord]\\n startStack = [(startCoord, startPath)]\\n # find longest path with each start cell, and update longest\\n # length and path\\n currLen, currPath = dfs_on_grid(startStack, size, maxLen,\\n lettersGrid, newDict)\\n if currLen == maxLen:\\n return path_to_word(currPath, lettersGrid)\\n if currLen > longestLen:\\n longestLen = currLen\\n longestPath = currPath\\n\\n # convert coordinates to letters before returning\\n return path_to_word(longestPath, lettersGrid)\",\n \"def path_from_root(self):\\n path = []\\n parent = self.parent\\n child = self\\n while parent is not None:\\n if child is parent.left_subtree:\\n path.append('left')\\n else:\\n path.append('right')\\n child = parent\\n parent = parent.parent\\n \\n path.reverse()\\n return path\",\n \"def depth(self):\\n return max(n.depth for n in self.iternodes())\",\n \"def max_recursive(S):\\n if len(S) == 0:\\n return None\\n elif len(S) == 1:\\n return S[0]\\n else:\\n max_ele1 = max_recursive(S[:len(S) // 2])\\n max_ele2 = max_recursive(S[len(S) // 2 :])\\n if max_ele1 > max_ele2:\\n return max_ele1\\n else:\\n return max_ele2\",\n \"def max_depth(self) -> int:\\n return pulumi.get(self, \\\"max_depth\\\")\",\n \"def _update_max(self):\\n tmp = self\\n while tmp.right is not None:\\n tmp = tmp.right\\n return tmp.parent.key\",\n \"def longest_seq(n):\\n max_seq = 0\\n for i in range(SEQ_LENGTH):\\n max_seq = max(max_seq, longest_seq_of_1s(n, i))\\n\\n return max_seq\",\n \"def longest_word_length(words):\\n\\n longest = len(word[0])\\n\\n for word in words:\\n if longest < len(word):\\n longest = len(word)\\n\\n return longest\",\n \"def find_longest_word(words):\\n \\n # lengths = []\\n\\n # for word in words: \\n # l = len(word)\\n # lengths.append(l)\\n # result = max(lengths)\\n # return result\\n\\n #ALT SOLUTION ONE LINE \\n return len(max(words, key=lambda words: len(words)))\",\n \"def find_all_longest_words(dirname):\\n return {filename: \\\\\\n find_longest_word(os.path.join(dirname, filename))\\n for filename in os.listdir(dirname)\\n if os.path.isfile(os.path.join(dirname,\\\\\\n filename))}\",\n \"def max_depth(self):\\r\\n lvl = 1\\r\\n has_lvl_desc = True\\r\\n while has_lvl_desc:\\r\\n num_children = len(self.level_n_descendants(lvl))\\r\\n if num_children==0:\\r\\n has_lvl_desc = False\\r\\n else:\\r\\n lvl+=1\\r\\n return lvl-1\",\n \"def longest_run(L):\\n\\tlongest_length = 1\\n\\tincreasing_length = 1\\n\\tdecreasing_length = 1\\n\\tfor i in range(len(L) - 1):\\n\\t\\tif L[i] >= L[i+1]:\\n\\t\\t\\tdecreasing_length += 1\\n\\t\\telse:\\n\\t\\t\\tdecreasing_length = 1\\n\\t\\tif L[i] <= L[i+1]:\\n\\t\\t\\tincreasing_length += 1\\n\\t\\telse:\\n\\t\\t\\tincreasing_length = 1\\n\\t\\tif increasing_length > longest_length:\\n\\t\\t\\tlongest_length = increasing_length\\n\\t\\t\\trun_end = i + 1\\n\\t\\telif decreasing_length > longest_length:\\n\\t\\t\\tlongest_length = decreasing_length\\n\\t\\t\\trun_end = i + 1\\n\\n\\treturn sum(L[run_end - longest_length + 1 : run_end+1])\",\n \"def get_max_depth_node(nodes):\\n curr = nodes[0]\\n for i in range(0, len(nodes)):\\n if nodes[i].depth > curr.depth:\\n curr = nodes[i]\\n return curr\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.70472926","0.66193223","0.64925385","0.6379252","0.6372987","0.6354955","0.6342008","0.63089573","0.62788874","0.62379885","0.6157672","0.61548233","0.6142876","0.60721266","0.6016198","0.59961236","0.5966782","0.59641474","0.5886199","0.58638775","0.580928","0.5796546","0.57923734","0.5788505","0.5773799","0.5758662","0.57561046","0.57558787","0.5753732","0.57457596","0.573878","0.57272434","0.5726088","0.57258373","0.5720755","0.5712308","0.5708235","0.56978184","0.5696578","0.5679684","0.56768036","0.56677157","0.56502855","0.5642758","0.5635865","0.563045","0.5628328","0.56218576","0.56144696","0.5614105","0.5567726","0.55488336","0.5547771","0.5543221","0.5539866","0.55269855","0.5523402","0.55144304","0.54994506","0.549922","0.54921997","0.54743046","0.5473836","0.545942","0.54550934","0.54531527","0.54528654","0.54496914","0.5446928","0.54455763","0.5445267","0.54444337","0.54427326","0.5435446","0.5431364","0.5426328","0.5419197","0.54089177","0.54078746","0.54002553","0.5397434","0.53836626","0.537523","0.5352313","0.5352109","0.53098863","0.530162","0.5300561","0.5294048","0.52932143","0.5292905","0.52907395","0.5281221","0.5276852","0.52716154","0.52685535","0.5265782","0.5265656","0.5246419","0.5236046"],"string":"[\n \"0.70472926\",\n \"0.66193223\",\n \"0.64925385\",\n \"0.6379252\",\n \"0.6372987\",\n \"0.6354955\",\n \"0.6342008\",\n \"0.63089573\",\n \"0.62788874\",\n \"0.62379885\",\n \"0.6157672\",\n \"0.61548233\",\n \"0.6142876\",\n \"0.60721266\",\n \"0.6016198\",\n \"0.59961236\",\n \"0.5966782\",\n \"0.59641474\",\n \"0.5886199\",\n \"0.58638775\",\n \"0.580928\",\n \"0.5796546\",\n \"0.57923734\",\n \"0.5788505\",\n \"0.5773799\",\n \"0.5758662\",\n \"0.57561046\",\n \"0.57558787\",\n \"0.5753732\",\n \"0.57457596\",\n \"0.573878\",\n \"0.57272434\",\n \"0.5726088\",\n \"0.57258373\",\n \"0.5720755\",\n \"0.5712308\",\n \"0.5708235\",\n \"0.56978184\",\n \"0.5696578\",\n \"0.5679684\",\n \"0.56768036\",\n \"0.56677157\",\n \"0.56502855\",\n \"0.5642758\",\n \"0.5635865\",\n \"0.563045\",\n \"0.5628328\",\n \"0.56218576\",\n \"0.56144696\",\n \"0.5614105\",\n \"0.5567726\",\n \"0.55488336\",\n \"0.5547771\",\n \"0.5543221\",\n \"0.5539866\",\n \"0.55269855\",\n \"0.5523402\",\n \"0.55144304\",\n \"0.54994506\",\n \"0.549922\",\n \"0.54921997\",\n \"0.54743046\",\n \"0.5473836\",\n \"0.545942\",\n \"0.54550934\",\n \"0.54531527\",\n \"0.54528654\",\n \"0.54496914\",\n \"0.5446928\",\n \"0.54455763\",\n \"0.5445267\",\n \"0.54444337\",\n \"0.54427326\",\n \"0.5435446\",\n \"0.5431364\",\n \"0.5426328\",\n \"0.5419197\",\n \"0.54089177\",\n \"0.54078746\",\n \"0.54002553\",\n \"0.5397434\",\n \"0.53836626\",\n \"0.537523\",\n \"0.5352313\",\n \"0.5352109\",\n \"0.53098863\",\n \"0.530162\",\n \"0.5300561\",\n \"0.5294048\",\n \"0.52932143\",\n \"0.5292905\",\n \"0.52907395\",\n \"0.5281221\",\n \"0.5276852\",\n \"0.52716154\",\n \"0.52685535\",\n \"0.5265782\",\n \"0.5265656\",\n \"0.5246419\",\n \"0.5236046\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.5438467"},"document_rank":{"kind":"string","value":"73"}}},{"rowIdx":89893,"cells":{"query":{"kind":"string","value":"Returns the longest common subsequences between sorted_nodes1 and sorted_nodes2."},"document":{"kind":"string","value":"def find_longest_matches(sorted_nodes1, sorted_nodes2):\n root = TreeNode(-1,-1)\n fill_tree(root, sorted_nodes1, sorted_nodes2)\n match = find_treepaths(root, [])\n\n # Remove (-1, -1) superroot.\n if isinstance(match[0], list): # More than one match of the same length.\n res = []\n for m in match:\n res.append([node.to_tuple() for node in m[1:]])\n return res\n else:\n return [[node.to_tuple() for node in match[1:]]]"},"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 longest_common_subsequence(seq1, seq2):\n mat = DPMatrix(seq1, seq2, match=1, mismatch=0, gap=0)\n mat.fill()\n\n lcs = []\n augSeq1, augSeq2 = mat.augmented_sequences()\n for c1, c2 in zip(augSeq1, augSeq2):\n if c1 == c2:\n lcs.append(c1)\n\n return ''.join(lcs)","def longest_shared_between(cls, seq_1, seq_2):\n tree = cls(seq_2 + '$', 'B').append_named_sequence(seq_1 + '$', 'A')\n condition = lambda n, c, p: 'B' not in c.seq_ids\n out = lambda n, c, p: p + n.label\n unshared = tree.root.bfs_paths(condition, out)\n shortest = next(unshared)\n common = [shortest]\n for possible in unshared:\n if len(possible) > len(shortest) and not possible[-1] == '$':\n shortest = possible\n common = [possible]\n elif len(possible) == len(shortest) and not possible[-1] == '$':\n common.append(possible)\n return min(common)","def longest_common_subsequence(x, y):\n\n # find the length of the strings\n m = len(x)\n n = len(y)\n\n # declaring the array for storing the dp values\n lcs = np.zeros((m + 1, n + 1))\n\n # iterate through each sub problem\n for i in range(m + 1):\n for j in range(n + 1):\n if i == 0 or j == 0:\n lcs[i, j] = 0\n elif x[i - 1] == y[j - 1]:\n lcs[i, j] = lcs[i - 1, j - 1] + 1\n else:\n # use the optimal substructure property\n # of using already computed results previous subproblems\n lcs[i, j] = max(lcs[i - 1, j], lcs[i, j - 1])\n\n # L[m,n] contains the length of LCS of X[0..n-1] & Y[0..m-1]\n return lcs[m, n]","def longestCommonSubsequence(self, text1: str, text2: str) -> int:\n if len(text1) == 0 or len(text2) == 0:\n return 0\n if text1[0] == text2[0]:\n return 1 + self.longestCommonSubsequence(text1[1:], text2[1:])\n else:\n return max(self.longestCommonSubsequence(text1[1:], text2),\n self.longestCommonSubsequence(text1, text2[1:]))","def lcs(s1, s2):\n\n shape = (len(s1) + 1, len(s2) + 1)\n M = np.zeros(shape)\n\n max_length_so_far = 0\n candidates = set()\n\n for i in range(len(s1)):\n for j in range(len(s2)):\n\n if s1[i] == s2[j]:\n M[i+1,j+1] = M[i,j] + 1\n\n if M[i+1,j+1] > max_length_so_far:\n max_length_so_far = int(M[i+1,j+1])\n candidates = {s1[i - max_length_so_far + 1: i + 1]}\n\n elif M[i+1,j+1] == max_length_so_far:\n candidates.add(s1[i - max_length_so_far + 1: i + 1])\n\n else:\n M[i,j] = 0\n\n candidates.add('')\n\n return candidates","def longest(s1, s2):\n return ''.join(sorted(set(s1+s2)))","def longest_common_substring_bottom_up(s1, s2):\n lcs_array = lcs(s1, s2)\n n = len(s1)\n m = len(s2)\n l = lcs_array[n][m]\n result = \"\"\n while l != 0:\n if s1[n - 1] == s2[m - 1]:\n result = s1[n - 1] + result\n l -= 1\n n -= 1\n m -= 1\n elif lcs_array[n][m - 1] >= lcs_array[n - 1][m]:\n m -= 1\n else:\n n -= 1\n return result","def m_longest_common_subsequence_2(s):\n\n # Correct me if I'm wrong but I think unsorted list is faster\n lst = list(s)\n\n lcs = lst[0]\n for string in lst[1:]:\n lcs = LCS(lcs, string)\n\n return lcs","def longest_common_substring_iterative_bottom_up(s1, s2):\n\n cache = [[0] * (len(s2)+1) for _ in range(-1, len(s1))]\n\n for i in range(1, len(s1)+1):\n for j in range(1, len(s2)+1):\n\n if s1[i-1] == s2[j-1]:\n\n # previous count is cache[i-1][j-1]\n cache[i][j] = cache[i-1][j-1] + 1\n else:\n cache[i][j] = max(cache[i-1][j-1],\n max(cache[i-1][j],\n cache[i][j-1]))\n\n return cache[-1][-1]","def dynamic(a, b):\n m = len(a)\n n = len(b)\n d = [[0 for i in range(n)] for j in range(m)] # d[i][j] is length of common sequence of consecutive\n prev = [-1 for j in range(n)] # numbers that ends with a[i] == b[j]\n global_max = 0\n global_pos = -1\n for i in range(0, m):\n for j in range(0, n): # iterate through all the elements by dual circle\n if a[i] == b[j]: # if pair is equal then check if there is sequence that ends with a[i]-1\n max_len = 0 # find longest sequence ends with a[i]-1\n max_prev = -1\n for k in range(i+1):\n for l in range(j+1):\n if k == i and l == j:\n continue\n if d[k][l] > max_len and a[k] == b[l] == a[i] - 1:\n max_len = d[k][l]\n max_prev = l\n d[i][j] = max_len + 1\n if d[i][j] > global_max:\n global_max = d[i][j]\n global_pos = j\n prev[j] = max_prev\n\n res = [] # rebuild the answer\n while global_pos != -1:\n res.append(b[global_pos])\n global_pos = prev[global_pos]\n\n return res[::-1]","def find_LCS(seq1, seq2, all=False):\n C = [[0 for j in range(len(seq2) + 1)] for i in range(len(seq1) + 1)]\n\n for i in range(1, len(seq1) + 1):\n for j in range(1, len(seq2) + 1):\n inter = seq1[i - 1].intersection(seq2[j - 1])\n\n C[i][j] = max([C[i - 1][j - 1] + len(inter),\n C[i - 1][j],\n C[i][j - 1]])\n\n # now we need to backtrack the structure to get the pattern\n if all:\n all_lcs = backtrack_all_LCS(C, seq1, seq2, len(seq1), len(seq2))\n return {i[1:] for i in all_lcs}\n\n lcs = []\n backtrack_LCS(C, seq1, seq2, len(seq1), len(seq2), lcs)\n return lcs","def longest_subsequence(s1: str, s2: str, s3: str) -> int:\n # Find the shortest string\n s = min(s1, s2, s3, key=lambda x: len(x))\n total = 0\n ok = False\n while s1:\n for i1, c1 in enumerate(s1):\n for i2, c2 in enumerate(s2):\n if ok:\n ok = False\n break\n if c1 == c2:\n for i3, c3 in enumerate(s3):\n if c1 == c3:\n total += 1\n s1 = s1[i1 + 1:]\n s2 = s2[i2 + 1:]\n s3 = s3[i3 + 1:]\n ok = True\n break\n\n return total","def longest_common_prefix(strings: list):\n raise NotImplemented","def lcs_length(s1, s2):\n n = len(s1)\n m = len(s2)\n matrix = [([0]*(m+1)) for i in xrange(n+1)]\n for i in xrange(1, n+1):\n for j in xrange(1, m+1):\n if(s1[i-1]==s2[j-1]):\n matrix[i][j] = matrix[i-1][j-1] + 1\n else:\n matrix[i][j] = max(matrix[i-1][j], matrix[i][j-1])\n return matrix[n][m]","def longest_common_prefix(fst: str, snd: str) -> str:\n bound = 0\n for a, b in zip(fst, snd):\n if a != b:\n break\n bound += 1\n return fst[:bound]","def compare_eq_len(a, b):\n n = len(a)\n m = len(b)\n\n # slide b across a from left to right till from just overlapping till full overlap\n overlap = 0 # stores length of the overlap\n lconcat = \"\" # this stores the shortest common superstring\n for j in range(m):\n starta = 0\n enda = j+1\n startb = m - (j+1)\n endb = m\n if a[starta:enda] == b[startb:endb]:\n # if an overlap is found, check if it is larger than the previously detected one\n # print(\"overlap found\")\n if len(a[starta:enda]) > overlap: \n overlap = len(a[starta:enda]) \n lconcat = b + a[enda:] # this is the current shortest common superstring\n # print(starta, enda, startb, endb, a[starta:enda], b[startb:endb])\n\n # print(\"-\")\n\n # slide b across a so that b starts from one element past a after full overlap\n rconcat = \"\"\n for j in range(m-1):\n starta = j+1\n enda = m\n startb = 0\n endb = m - (j+1)\n if a[starta:enda] == b[startb:endb]:\n if len(a[starta:enda]) > overlap: # if there is a bigger overlap then save it \n # print(\"overlap found\")\n overlap = len(a[starta:enda]) \n rconcat = a + b[endb:]\n # print(starta, enda, startb, endb, a[starta:enda], b[startb:endb])\n\n # after checking for overlaps there may be 1 or no shortest common\n # superstrings stored in both lconcat and rconcat. Choose the shortest one if it exists\n # or the concatenation of a and b if there are no overlaps. We may have to make some\n # arbitrary choices here.\n\n if not lconcat and not rconcat: # both lconcat and rconcat are empty, no overlaps\n superstring = a + b # append b to a (could prepend here too, this is an arbitrary choice)\n elif lconcat and not rconcat: # lconcat contains overlap and rconcat is empty\n superstring = lconcat \n elif rconcat and not lconcat: # rconcat contains overlap and lconcat is empty\n superstring = rconcat\n elif rconcat and lconcat and (len(lconcat) <= len(rconcat)): # use lconcat if it is shorter or equal len to rconat\n superstring = lconcat\n elif rconcat and lconcat and (len(rconcat) < len(lconcat)): # use rconcat only if it is shorter than lconat\n superstring = rconcat\n return superstring","def find_lcs(l1: str, l2: str, length1: int, length2: int):\n \"\"\" Theorem:{\n Initialize matrix with 0 for first row and colm\n If s1[i] = s2[j], update matrix[i][j] with value\n of matrix[i-1][j-1]+1\n Else update matrix[i][j] with max of value among\n matrix[i][j-1],matrix[i-1][j]\n Matrix[n][m] will be lcs\n }\n \"\"\"\n matrix = [[None]*(length1+1) for i in range(0, length2+1)]\n for i in range(0, length2+1):\n for j in range(0, length1+1):\n if i == 0 or j == 0:\n matrix[i][j] = 0\n elif l1[j-1] == l2[i-1]:\n matrix[i][j] = matrix[i-1][j-1] + 1\n else:\n matrix[i][j] = max(matrix[i][j-1], matrix[i-1][j])\n lcs = [None for i in range(0, matrix[length2][length1])]\n index = matrix[length2][length1]\n m = length2 \n n = length1\n while(m > -1 and n > -1):\n if l2[m-1] == l1[n-1]:\n lcs[index-1] = l2[m-1]\n index -= 1\n m -= 1\n n -= 1\n elif matrix[m-1][n] > matrix[m][n-1]:\n m -= 1\n else:\n n -= 1\n return lcs","def linear_merge(sorted1, sorted2):\n first_pointer = 0\n second_pointer = 0\n sorted_result = []\n\n while second_pointer < len(sorted2) and first_pointer < len(sorted1):\n if sorted1[first_pointer] < sorted2[second_pointer]:\n sorted_result.append(sorted1[first_pointer])\n first_pointer += 1\n else:\n sorted_result.append(sorted2[second_pointer])\n second_pointer += 1\n\n while second_pointer < len(sorted2):\n sorted_result.append(sorted2[second_pointer])\n second_pointer += 1\n\n while first_pointer < len(sorted1):\n sorted_result.append(sorted1[first_pointer])\n first_pointer += 1\n\n\n return sorted_result","def longestCommomSubsequence(self, arrays: List[List[int]]) -> List[int]:\n counts = Counter(val for arr in arrays for val in arr)\n res = []\n for val, count in counts.items():\n if count == len(arrays): res.append(val)\n return res","def findLongestCommonSubstring(self, string1, string2):\n countingArray = [[0]*len(string2) for i in range(len(string1))]\n ##we set up an array to locate the possible substrings\n lcss = \"\"\n for row in range(len(countingArray)):\n for column in range(len(countingArray[row])):\n if string1[row] == string2[column]:\n countingArray[row][column] += 1 ##if there's a match the common string length is at least 1\n if not (row == 0 or column == 0):\n countingArray[row][column] += countingArray[row-1][column-1] ##memoize the length of the common string so far\n if countingArray[row][column] > longestLength: ##if it's longer than our current longest string, we'll plan on returning it\n longestLength = countingArray[row][column]\n lcss = string1[row-longestLength+1:row+1]\n return lcss","def find_longest_common_prefix_reduce(words:list):\n if not words:\n return ''\n \n def common_start(w1, w2):\n shorter = w1 if len(w1) < len(w2) else w2\n for i in range(0, len(shorter)):\n if w1[i] != w2[i]:\n return shorter[:i]\n return shorter\n \n return reduce(common_start, words)","def common(s1, s2):\n cl = commonlen(s1, s2)\n return s2[:cl]","def _get_overlap(word1, word2):\n max_overlap = min(len(word1), len(word2))\n max_found = 0\n for size in range(1, max_overlap+1):\n suffix = word1[-size:]\n prefix = word2[:size]\n if suffix == prefix:\n max_found = size\n return max_found","def LCS_length(str1, str2):\n if str1 is None or str2 is None:\n return 0\n\n len1 = len(str1)\n len2 = len(str2)\n if len1 == 0 or len2 == 0:\n return 0\n\n lcs = [[0 for _ in range(len2 + 1)] for _ in range(2)]\n for i in range(1, len1 + 1):\n for j in range(1, len2 + 1):\n if str1[i - 1] == str2[j - 1]:\n lcs[i % 2][j] = lcs[(i - 1) % 2][j - 1] + 1\n else:\n if lcs[i % 2][j - 1] >= lcs[(i - 1) % 2][j]:\n lcs[i % 2][j] = lcs[i % 2][j - 1]\n else:\n lcs[i % 2][j] = lcs[(i - 1) % 2][j]\n\n return lcs[len1 % 2][-1]","def findLongestCommonSubstringManyStrings(listOfStrings):","def fullCmpSets(s1, s2):\n if len(s1) != len(s2):\n return 1\n for s1i, s2i in map(None, s1, s2):\n f = s1i.fullCmp(s2i)\n if f:\n return f","def naive(l1: ListNode, l2: ListNode) -> ListNode:\n n = (get_length(l1), l1)\n m = (get_length(l2), l2)\n smaller = min(n, m, key=lambda x: x[0])[1] # choose the smaller list, of l1 and l2\n larger = max(n, m, key=lambda x: x[0])[1]\n seen = {}\n while smaller: # Using the smaller list, track seen nodes using a hash table\n seen[smaller] = True\n smaller = smaller.next\n while larger:\n if larger in seen: # if any node in the larger list has been seen (overlaps with smaller list) return it\n return larger\n larger = larger.next\n return None # no intersection","def longest_common_substring_top_down(s1, s2, q=1, r=1, cache=None):\n if cache is None:\n cache = {}\n if (q, r) in cache:\n return cache[(q, r)]\n n = len(s1)\n m = len(s2)\n if n == q - 1 or m == r - 1:\n cache[(q, r)] = \"\"\n return \"\"\n elif s1[n - q] == s2[m - r]: #\n ss = longest_common_substring_top_down(s1, s2, q + 1, r + 1, cache) + s1[n - q]\n cache[(q, r)] = ss\n return ss\n ss1 = longest_common_substring_top_down(s1, s2, q, r + 1, cache)\n ss2 = longest_common_substring_top_down(s1, s2, q + 1, r, cache)\n if (len(ss1) >= len(ss2)):\n cache[(q, r)] = ss1\n return ss1\n else:\n cache[(q, r)] = ss2\n return ss2","def _commonParent(zi1, zi2):\n shorter, longer = sorted([_linearize(x)[::-1] for x in zi1, zi2],\n key=len)\n for n in range(len(shorter)):\n if shorter[n] != longer[n]:\n if n == 0:\n return None\n return shorter[n-1]\n return shorter[-1]","def _lcs_dp(a, b):\n dp = [[0 for _ in range(0, len(b) + 1)]\n for _ in range(0, len(a) + 1)]\n # dp[i][j]: lcs_len(a[:i], b[:j])\n for i in range(1, len(a) + 1):\n for j in range(1, len(b) + 1):\n if a[i - 1] == b[j - 1]:\n dp[i][j] = dp[i - 1][j - 1] + 1\n else:\n dp[i][j] = max(dp[i - 1][j], dp[i][j - 1])\n return dp","def overlap(s1,s2):\n if len(s1) >= len(s2):\n longer = s1.lower()\n shorter = s2.lower()\n else:\n longer = s2.lower()\n shorter = s1.lower()\n s3 = shorter + longer # by default this is our combination \n if shorter in longer: # return if shorter is contained in longer\n return longer\n else:\n for i in rnage(1,len(shorter)):\n if shorter[i:] == longer[:len(shorter[i:])]:\n #checks if shorter is in beginning of longer\n s3 = shorter + longer[len(shorter[i:]):]\n break\n for i in reversed(range(len(shorter))):\n if shorter[:i] == longer[-len(shorter[:i]):]:\n # checks if shorter is in ending of longer\n if len(s3) > len(longer[:-len(shorter[:i])] + shorter:\n s3 = longer[:-len(shorter[:i])] + shorter\n break\n return s3","def dameraulevenshtein(self, seq1, seq2):\n # codesnippet:D0DE4716-B6E6-4161-9219-2903BF8F547F\n # Conceptually, this is based on a len(seq1) + 1 * len(seq2) + 1 matrix.\n # However, only the current and two previous rows are needed at once,\n # so we only store those.\n oneago = None\n thisrow = range(1, len(seq2) + 1) + [0]\n for x in xrange(len(seq1)):\n # Python lists wrap around for negative indices, so put the\n # leftmost column at the *end* of the list. This matches with\n # the zero-indexed strings and saves extra calculation.\n twoago, oneago, thisrow = oneago, thisrow, [0] * len(seq2) + [x + 1]\n for y in xrange(len(seq2)):\n delcost = oneago[y] + 1\n addcost = thisrow[y - 1] + 1\n subcost = oneago[y - 1] + (seq1[x] != seq2[y])\n thisrow[y] = min(delcost, addcost, subcost)\n # This block deals with transpositions\n if (x > 0 and y > 0 and seq1[x] == seq2[y - 1]\n and seq1[x-1] == seq2[y] and seq1[x] != seq2[y]):\n thisrow[y] = min(thisrow[y], twoago[y - 2] + 1)\n return thisrow[len(seq2) - 1]","def _common_prefix(sequence1, sequence2):\n i = 0\n for elem1, elem2 in zip(sequence1, sequence2):\n if elem1 != elem2:\n return i\n i += 1\n\n # Return length of sequence if sequences are identical\n return min(len(sequence1), len(sequence2))","def getCommon(self, st1, st2):\n fl = len(st1)\n shorter = len(st2)\n if fl < shorter:\n shorter = fl\n \n i = 0\n while i < shorter:\n if st1[i] != st2[i]:\n break\n i += 1\n return i","def common_end(a, b):\n return a[0] == b[0] or a[-1] == b[-1]\n # return [0] == [0] or [-1] == [-1]","def findAllCommonSubstrings(self, string1, string2):\n countingArray = [[0]*len(string1) for i in range(len(string2))]\n ##we set up an array to locate the possible substrings\n candidates = set()\n for row in range(len(countingArray)):\n for column in range(len(countingArray[row])):\n if string2[row] == string1[column]:\n countingArray[row][column] += 1\n if not (row == 0 or column == 0):\n countingArray[row][column] += countingArray[row-1][column-1]\n candidates.add(string2[row-countingArray[row][column]+1:row+1])\n candidates = list(candidates)\n candidates.sort(key=len)\n candidates = list(reversed(candidates))\n return candidates","def test_lcs_nouns(id1, id2, expected_ids):\n syn1 = germanet_data.get_synset_by_id(id1)\n syn2 = germanet_data.get_synset_by_id(id2)\n lcs = syn1.lowest_common_subsumer(syn2)\n np.testing.assert_equal(sorted([l.id for l in lcs]), sorted(expected_ids))","def shortest_unshared_between(cls, seq_1, seq_2):\n tree = cls(seq_2 + '$', 'B').append_named_sequence(seq_1 + '$', 'A')\n condition = lambda n, c, p: 'B' not in c.seq_ids\n out = lambda n, c, p: p + n.label + c.label[0]\n unshared = tree.root.bfs_paths(condition, out)\n shortest = next(unshared)\n common = [shortest]\n for possible in unshared:\n if len(possible) < len(shortest) and not possible[-1] == '$':\n shortest = possible\n common = [possible]\n elif len(possible) == len(shortest) and not possible[-1] == '$':\n common.append(possible)\n return min(common)","def lowest_common_subsumer(self, other):\n lcs = set()\n if other == self:\n lcs.add(self)\n return lcs\n if other in self._direct_hypernyms or other.is_root():\n lcs.add(other)\n return lcs\n if self in other._direct_hypernyms or self.is_root():\n lcs.add(self)\n return lcs\n common_hypernyms = self.common_hypernyms(other)\n dist_dict1 = self.get_distances_hypernym_dic()\n dist_dict2 = other.get_distances_hypernym_dic()\n dist = math.inf\n for hypernym in common_hypernyms:\n dist1 = dist_dict1[hypernym]\n dist2 = dist_dict2[hypernym]\n if dist1 + dist2 < dist:\n lcs.clear()\n lcs.add(hypernym)\n dist = dist1 + dist2\n if dist1 + dist2 == dist:\n lcs.add(hypernym)\n return lcs","def dameraulevenshtein(seq1, seq2):\n # codesnippet:D0DE4716-B6E6-4161-9219-2903BF8F547F\n # Conceptually, this is based on a len(seq1) + 1 * len(seq2) + 1 matrix.\n # However, only the current and two previous rows are needed at once,\n # so we only store those.\n oneago = None\n thisrow = list(range(1, len(seq2) + 1)) + [0]\n for x in range(len(seq1)):\n # Python lists wrap around for negative indices, so put the\n # leftmost column at the *end* of the list. This matches with\n # the zero-indexed strings and saves extra calculation.\n twoago, oneago, thisrow = (oneago, thisrow, [0] * len(seq2) + [x + 1])\n for y in range(len(seq2)):\n delcost = oneago[y] + 1\n addcost = thisrow[y - 1] + 1\n subcost = oneago[y - 1] + (seq1[x] != seq2[y])\n thisrow[y] = min(delcost, addcost, subcost)\n # This block deals with transpositions\n if (x > 0 and y > 0 and seq1[x] == seq2[y - 1]\n and seq1[x - 1] == seq2[y] and seq1[x] != seq2[y]):\n thisrow[y] = min(thisrow[y], twoago[y - 2] + 1)\n return thisrow[len(seq2) - 1]","def dameraulevenshtein(seq1, seq2):\n # codesnippet:D0DE4716-B6E6-4161-9219-2903BF8F547F\n # Conceptually, this is based on a len(seq1) + 1 * len(seq2) + 1 matrix.\n # However, only the current and two previous rows are needed at once,\n # so we only store those.\n oneago = None\n thisrow = list(range(1, len(seq2) + 1)) + [0]\n for x in range(len(seq1)):\n # Python lists wrap around for negative indices, so put the\n # leftmost column at the *end* of the list. This matches with\n # the zero-indexed strings and saves extra calculation.\n twoago, oneago, thisrow = (oneago, thisrow, [0] * len(seq2) + [x + 1])\n for y in range(len(seq2)):\n delcost = oneago[y] + 1\n addcost = thisrow[y - 1] + 1\n subcost = oneago[y - 1] + (seq1[x] != seq2[y])\n thisrow[y] = min(delcost, addcost, subcost)\n # This block deals with transpositions\n if (x > 0 and y > 0 and seq1[x] == seq2[y - 1]\n and seq1[x - 1] == seq2[y] and seq1[x] != seq2[y]):\n thisrow[y] = min(thisrow[y], twoago[y - 2] + 1)\n return thisrow[len(seq2) - 1]","def scs_of_pair(a, b):\n # compare two strings where the text a is longer than the pattern b\n n = len(a)\n m = len(b)\n\n # check the args are the right way round\n if m > n:\n raise ValueError(\"string b is longer than string a\")\n\n # slide b across a from left to right till from just overlapping till full overlap\n overlap = 0 # stores length of the overlap\n lconcat = \"\" # stores the curretn shortest common superstring\n for j in range(n): \n starta = 0 if (j+1) <= m else ((j+1) - m) \n enda = j+1 \n startb = (m - (j+1)) if (j+1) < m else 0 \n endb = m \n if a[starta:enda] == b[startb:endb]:\n # print(\"overlap found\")\n if len(a[starta:enda]) > overlap: # if there is a bigger overlap then save it \n overlap = len(a[starta:enda]) \n lconcat = b + a[enda:]\n # print(starta, enda, startb, endb, a[starta:enda], b[startb:endb])\n\n # print(\"-\")\n rconcat = \"\"\n for j in range(m - 1):\n starta = (n - m) + (j + 1) \n enda = n \n startb = 0 \n endb = m - (j+1) \n if a[starta:enda] == b[startb:endb]:\n # print(\"overlap found\")\n if len(a[starta:enda]) > overlap: # if there is a bigger overlap then save it \n overlap = len(a[starta:enda]) \n rconcat = a + b[endb:]\n # print(starta, enda, startb, endb, a[starta:enda], b[startb:endb])\n\n # after checking for overlaps there may be 1 or no shortest common\n # superstrings stored in both lconcat and rconcat. Choose the shortest one if it exists\n # or the concatenation of a and b if there are no overlaps. We may have to make some\n # arbitrary choices here.\n\n if not lconcat and not rconcat: # both lconcat and rconcat are empty, no overlaps\n superstring = a + b # append b to a (could prepend here too)\n elif lconcat and not rconcat: # lconcat contains overlap and rconcat is empty\n superstring = lconcat\n elif rconcat and not lconcat: # rconcat contains overlap and lconcat is empty\n superstring = rconcat\n elif rconcat and lconcat and (len(lconcat) <= len(rconcat)): # use lconcat if it is shorter or equal len to rconat\n superstring = lconcat\n elif rconcat and lconcat and (len(rconcat) < len(lconcat)): # use rconcat only if it is shorter than lconat\n superstring = rconcat\n return superstring","def lcs(s1, s2):\n n = len(s1)\n m = len(s2)\n # initialise 2d array with size n+1 x m+1\n lcs_array = [[None for _ in range(m + 1)] for _ in range(n + 1)]\n # build array of LCS counters\n for i in range(n + 1):\n for j in range(m + 1):\n if i == 0 or j == 0:\n lcs_array[i][j] = 0\n elif s1[i - 1] == s2[j - 1]:\n lcs_array[i][j] = lcs_array[i - 1][j - 1] + 1\n else:\n lcs_array[i][j] = max(lcs_array[i - 1][j], lcs_array[i][j - 1])\n return lcs_array","def test_lcs_adjectives(id1, id2, expected_ids):\n syn1 = germanet_data.get_synset_by_id(id1)\n syn2 = germanet_data.get_synset_by_id(id2)\n lcs = syn1.lowest_common_subsumer(syn2)\n np.testing.assert_equal(sorted([l.id for l in lcs]), sorted(expected_ids))","def overlap(string_one: str, string_two: str):\n len_s_one = len(string_one)\n len_s_two = len(string_two)\n\n # Content of the tuple => (start_index, stop_index, string from start_index to stop_index)\n largest_overlap = {\"suffix_string\": string_one,\n \"prefix_string\": string_two,\n \"overlap\": None,\n \"weight\": 0}\n len_overlap = 0\n # Iterate over every suffix from string one from right to left\n for i in range(len_s_one, 0, -1):\n # Current suffix from string one\n current_suffix_one = string_one[i - 1:len_s_one]\n\n # Iterate over every prefix of string two from left to right\n for j in range(len_s_two + 1):\n current_prefix_two = string_two[:j]\n if current_suffix_one == current_prefix_two:\n tmp_len = len(current_prefix_two)\n if tmp_len > len_overlap:\n len_overlap = tmp_len\n\n largest_overlap[\"suffix_start\"] = i - 1\n largest_overlap[\"suffix_end\"] = len_s_one\n\n largest_overlap[\"prefix_start\"] = 0\n largest_overlap[\"prefix_end\"] = j\n\n largest_overlap[\"weight\"] = tmp_len\n largest_overlap[\"overlap\"] = current_suffix_one\n return largest_overlap","def compare(seq1, seq2):\n if seq1 == seq2:\n return 1\n len_diff = len(seq1) / len(seq2)\n if len_diff > 1:\n len_diff = 1 / len_diff\n\n ngrams1 = {tuple(ng) for ng in get_all_ngrams(seq1)}\n ngrams2 = {tuple(ng) for ng in get_all_ngrams(seq2)}\n\n overall = len(ngrams1 & ngrams2) / len(ngrams1 | ngrams2)\n if overall == 1 or overall == 0:\n return overall\n\n try:\n max_match = len(max(ngrams1 & ngrams2, key=len)) / len(seq1)\n except ValueError:\n return 0\n\n return (len_diff + max_match + overall) / 3","def get_longest_paths(nodes, graph):\n paths = []\n distances = []\n possible_paths = list(combinations(nodes, r=2))\n for node1, node2 in possible_paths:\n try:\n path = nx.shortest_path(graph, node1, node2, \"weight\")\n except Exception,e:\n path = []\n if len(path)>1:\n distance = get_path_distance(path, graph)\n paths.append(path)\n distances.append(distance)\n paths_sorted = [x for (y,x) in sorted(zip(distances, paths), reverse=True)]\n # longest_path = paths_sorted[0]\n # return longest_path\n return paths_sorted","def lcs_pairwise(s1: str, s2: str, k: int, length: int):\n\n for i in range(0, len(s1) - length + 1):\n for j in range(0, len(s2) - length + 1):\n sub1 = s1[i: i + length]\n sub2 = s2[j: j + length]\n result = pairwise2.align.globalxx(sub1, sub2)\n if result[0][2] >= length - k - 1:\n print(str(i) + \" \" + str(j) + \" \" + str(length - result[0][2]) + \" \" +\n sub1 + \" \" + sub2, end=\"\\t\")\n else:\n print(str(i) + \" \" + str(j) + \" N N N\", end=\"\\t\")\n print(\"\")","def _sequence_overlap(seq1: Sequence, seq2: Sequence):\n diff = SequenceMatcher(None, seq1, seq2)\n # Drop last matching block, since this is always a dummy entry, with length=1.\n return diff.get_matching_blocks()[:-1]","def findsegments(id1, seq1, id2, seq2, minlen):\n\n segments = \"\"\n\n # Initialize list of corresponding residues.\n correspondances = []\n for res in seq1:\n correspondances.append([])\n \n # Main loop.\n for i in range(len(seq1)-minlen):\n seg1 = seq1[i:i+minlen]\n for j in range(len(seq2)-minlen):\n if j not in correspondances[i]:\n seg2 = seq2[j:j+minlen]\n if seg1 == seg2:\n # Look if the segment is longer than minlen.\n segments_equal = True\n prev1 = seg1\n prev2 = seg2\n extend = 1\n while segments_equal == True:\n i_end = i+minlen+extend\n j_end = j+minlen+extend\n ext1 = seq1[i:i_end]\n ext2 = seq2[j:j_end]\n if i_end > len(seq1) or j_end > len(seq2):\n seqend = True\n else:\n seqend = False\n if ext1 != ext2 or seqend == True:\n segments_equal = False\n segments += \"{} \".format(prev1)\n segments += \"{} [{}, {}] \".format(id1, i, i_end-2)\n segments += \" \"\n segments += \"{} [{}, {}] \".format(id2, j, j_end-2)\n segments += \"\\n\"\n # Add residues to correspondance list.\n for k in range(minlen+extend-1):\n l = i+k\n m = j+k\n correspondances[l].append(m)\n prev1 = ext1\n prev2 = ext2\n extend += 1\n\n return segments","def overlap(g, node_1, node_2):\n inter = len(set(nx.neighbors(g, node_1)).intersection(set(nx.neighbors(g, node_2))))\n return float(inter)","def real_overlap(from_sequence, to_sequence):\n sequence_overlap = difflib.SequenceMatcher(None, from_sequence, to_sequence)\n start = 0\n start_pos_from = -1\n start_pos_to = -1\n size = -1\n while start_pos_to != 0 or not start_pos_from+size == len(from_sequence):\n start_pos_from, start_pos_to, size = sequence_overlap.find_longest_match(start, \\\n len(from_sequence), 0, len(to_sequence))\n if not start_pos_to == 0 or not start_pos_from+size == len(from_sequence):\n start = start_pos_from+1\n\n return size","def nlp_merge_common_matches(matches):\n\n merged_matches = []\n\n for idx_1, start_1, end_1 in matches:\n\n curr_idx = idx_1\n curr_start = start_1\n curr_end = end_1\n\n for idx_2, start_2, end_2 in matches:\n\n if (start_2 < curr_start and end_2 > curr_end) or (start_2 <= curr_start and end_2 > curr_end) or (\n start_2 < curr_start and end_2 >= curr_end):\n curr_idx = idx_2\n curr_start = start_2\n curr_end = end_2\n\n merged_matches.append((curr_idx, curr_start, curr_end))\n\n return list(set(merged_matches))","def longestCommonPrefix(self, strs: List[str]) -> str:\r\n common = \"\"\r\n if not strs:\r\n return common\r\n shortest_str = min(strs, key=len)\r\n for i in range(len(shortest_str)):\r\n char = shortest_str[i]\r\n for item in strs:\r\n if item[i] != char:\r\n return common\r\n common += char\r\n return common","def dameraulevenshtein(seq1, seq2):\n # Conceptually, this is based on a len(seq1) + 1 * len(seq2) + 1 matrix.\n # However, only the current and two previous rows are needed at once,\n # so we only store those.\n oneago = None\n thisrow = list(range(1, len(seq2) + 1)) + [0]\n for x in range(len(seq1)):\n # Python lists wrap around for negative indices, so put the\n # leftmost column at the *end* of the list. This matches with\n # the zero-indexed strings and saves extra calculation.\n twoago, oneago, thisrow = oneago, thisrow, [0] * len(seq2) + [x + 1]\n for y in range(len(seq2)):\n delcost = oneago[y] + 1\n addcost = thisrow[y - 1] + 1\n subcost = oneago[y - 1] + (seq1[x] != seq2[y])\n thisrow[y] = min(delcost, addcost, subcost)\n # This block deals with transpositions\n if (x > 0 and y > 0 and seq1[x] == seq2[y - 1]\n and seq1[x-1] == seq2[y] and seq1[x] != seq2[y]):\n thisrow[y] = min(thisrow[y], twoago[y - 2] + 1)\n return thisrow[len(seq2) - 1]","def find_largest_overlaps(string_one, string_two):\n two_overlaps_suffix_one = overlap(string_one, string_two)\n one_overlaps_suffix_two = overlap(string_two, string_one)\n\n return two_overlaps_suffix_one, one_overlaps_suffix_two","def optimal_string_alignment_distance(s1, s2):\n\n utils.check_for_none(s1, s2)\n utils.check_for_type(str, s1, s2)\n\n # s1 = utils.unicode_normalize(s1)\n # s2 = utils.unicode_normalize(s2)\n\n n1, n2 = len(s1), len(s2)\n\n dp = [[0] * (n2 + 1) for _ in range(n1 + 1)]\n\n for i in range(0, n1 + 1):\n dp[i][0] = i\n for j in range(0, n2 + 1):\n dp[0][j] = j\n\n for i in range(1, n1 + 1):\n for j in range(1, n2 + 1):\n cost = 0 if s1[i - 1] == s2[j - 1] else 1\n\n dp[i][j] = min(dp[i][j - 1] + 1,\n dp[i - 1][j] + 1,\n dp[i - 1][j - 1] + cost)\n\n if i > 1 and j > 1 and s1[i - 1] == s2[j - 2] and s1[i - 2] == s2[j - 1]:\n dp[i][j] = min(dp[i][j], dp[i - 2][j - 2] + cost)\n\n return dp[n1][n2]","def sm_longest_match(s1,s2):\n anslist=[]\n match = SM(None, s1, s2).find_longest_match(0, len(s1), 0, len(s2))\n match_pat = s1[match.a: match.a + match.size]\n while match.size > 1:\n anslist.append( (match_pat, match.a) )\n\n #replace match pattern from string\n s1=s1.replace(match_pat,'')\n s2 = s2.replace(match_pat, '')\n\n match = SM(None, s1, s2).find_longest_match(0, len(s1), 0, len(s2))\n\n match_pat = s1[match.a: match.a + match.size]\n\n return anslist","def m_longest_common_subsequence_3(iterable):\n lst = list(iterable)\n\n lcs = lst[0]\n for string in lst[1:]:\n lcs = all_lcs(lcs, string).pop() # TODO select a LCS instead of popping the last one\n\n return lcs","def lcs_len(x, y):\r\n \r\n if len(x) == 0 or len(y) == 0:\r\n return 0\r\n \r\n xx = x[:-1] # xx = sequence x without its last element \r\n yy = y[:-1]\r\n \r\n if x[-1] == y[-1]: # if last elements of x and y are equal\r\n return lcs_len(xx, yy) + 1\r\n else:\r\n return max(lcs_len(xx, y), lcs_len(x, yy))","def find_longest_common_prefix(words:list):\n trie = Trie(words)\n\n head = trie.head\n\n prefix = []\n\n while len(head) == 1 and trie.eof not in head:\n key, value = head.popitem()\n prefix.append(key)\n head = value\n \n return \"\".join(prefix)","def get_overlap(a, b):\n return max(0, min(a[1], b[1]) - max(a[0], b[0]))","def longest_common_substring_backtrack(s1, s2, i, j, count):\n if i == len(s1) or j == len(s2):\n return 0\n\n if s1[i-1] == s2[j-1]:\n count = 1 + longest_common_substring_backtrack(s1, s2, i+1, j+1, count)\n\n else:\n count = max(count,\n max(longest_common_substring_backtrack(s1, s2, i+1, j, count),\n longest_common_substring_backtrack(s1, s2, i, j+1, count)))\n\n return count","def compare_two_grids( treecode1, treecode2 ):\n import numpy as np\n\n common_blocks = 0\n\n for i in range(treecode1.shape[0]):\n # we look for this tree code in the second array\n code1 = treecode1[i,:]\n\n for j in range(treecode2.shape[0]):\n code2 = treecode2[j,:]\n if np.linalg.norm( code2-code1 ) < 1.0e-13:\n # found code1 in the second array\n common_blocks += 1\n break\n\n print( \"Nblocks1=%i NBlocks2=%i common blocks=%i\" % (treecode1.shape[0], treecode2.shape[0], common_blocks) )\n\n return common_blocks / treecode1.shape[0]","def lcs_similarity(s1, s2):\n max_len = 0\n i = 0\n\n while s1[i] == s2[i]:\n max_len += 1\n i += 1\n if len(s1) == i or len(s2) == i:\n break\n\n if len(s1) < len(s2):\n return float(max_len) / len(s2)\n else:\n return float(max_len) / len(s1)","def longest_common_substring_memoization(s1, s2, i, j, count, cache):\n\n if i == len(s1) or j == len(s2):\n return 0\n\n if cache[i][j] != -1:\n return cache[i][j]\n\n if s1[i-1] == s2[j-1]:\n count = 1 + longest_common_substring_memoization(s1, s2, i+1, j+1, count, cache)\n\n else:\n count = max(count,\n max(longest_common_substring_memoization(s1, s2, i+1, j, count, cache),\n longest_common_substring_memoization(s1, s2, i, j+1, count, cache)))\n\n cache[i][j] = count\n return cache[i][j]","def solve(self, cipher):\r\n a, b = cipher\r\n m = len(a)\r\n n = len(b)\r\n dp = [[0 for _ in xrange(n+1)] for _ in xrange(m+1)]\r\n for i in xrange(1, m+1):\r\n for j in xrange(1, n+1):\r\n if a[i-1]==b[j-1]:\r\n dp[i][j] = dp[i-1][j-1]+1\r\n else:\r\n dp[i][j] = max(dp[i][j-1], dp[i-1][j]) # superset\r\n return dp[-1][-1]","def common_count(self, node_1, node_2):\n return int(len(set(nx.neighbors(self.graph, node_1)).intersection(set(nx.neighbors(self.graph, node_2)))))","def commonCharacterCount(s1, s2):\n return sum(min(s1.count(x),s2.count(x)) for x in set(s1))","def overlap_len(range1, range2):\n return min(range1[1], range2[1]) - max(range1[0], range2[0])","def test_lcs_verbs(id1, id2, expected_ids):\n syn1 = germanet_data.get_synset_by_id(id1)\n syn2 = germanet_data.get_synset_by_id(id2)\n lcs = syn1.lowest_common_subsumer(syn2)\n np.testing.assert_equal(sorted([l.id for l in lcs]), sorted(expected_ids))","def lcs(a, b):\n # This is an adaptation of the standard LCS dynamic programming algorithm\n # tweaked for lower memory consumption.\n # Sequence a is laid out along the rows, b along the columns.\n # Minimize number of columns to minimize required memory\n if len(a) < len(b):\n a, b = b, a\n # Sequence b now has the minimum length\n # Quit early if one sequence is empty\n if len(b) == 0:\n return 0\n # Use a single buffer to store the counts for the current row, and\n # overwrite it on each pass\n row = [0] * len(b)\n for ai in a:\n left = 0\n diag = 0\n for j, bj in enumerate(b):\n up = row[j]\n if ai == bj:\n value = diag + 1\n else:\n value = max(left, up)\n row[j] = value\n left = value\n diag = up\n # Return the last cell of the last row\n return left","def common_suffix(s1, s2):\n if not s1 or not s2:\n return None\n # revert the seqs and get a common prefix\n common = common_prefix(s1[::-1], s2[::-1])\n # revert back\n if common:\n return common[::-1]\n else:\n return common","def mergeSeq(left, right):\n i = j = 0\n result = []\n while i < len(left) and j < len(right):\n if left[i] <= right[j]:\n result.append(left[i])\n i += 1\n else:\n result.append(right[j])\n j += 1\n\n result += left[i:]\n result += right[j:]\n return result","def find_lowest_common_decendent(graph, a, b):\n\n assert nx.is_directed_acyclic_graph(graph), \"Graph has to be acyclic and directed.\"\n\n # get ancestors of both (intersection)\n common_ancestors = list(nx.descendants(graph, a) & nx.descendants(graph, b))\n\n # get sum of path lengths\n sum_of_path_lengths = np.zeros((len(common_ancestors)))\n for ii, c in enumerate(common_ancestors):\n sum_of_path_lengths[ii] = nx.shortest_path_length(graph, a, c) \\\n + nx.shortest_path_length(graph, b, c)\n\n # print common_ancestors\n # print sum_of_path_lengths\n\n # return minima\n try:\n minima, = np.where(sum_of_path_lengths == np.min(sum_of_path_lengths))\n return [common_ancestors[ii] for ii in minima]\n except ValueError:\n return -1","def longestStrChain_wrong(self, words) -> int:\n\n # sort list based on length\n words_dict = {}\n for i in words:\n l = len(i)\n if l not in words_dict.keys():\n words_dict[l] = [i]\n else:\n words_dict[l].append(i)\n word_sort = sorted([(i, j) for i, j in words_dict.items()], key=lambda x: x[0])\n #print(word_sort)\n\n roots = [Node(i) for i in word_sort[0][1]]\n pre_roots = roots\n cur_roots = []\n for _, word_list in word_sort[1:]:\n cur_roots = []\n for i in pre_roots:\n child = [Node(x) for x in word_list if self.is_predecessor(i.val, x)]\n i.child = child\n cur_roots += child\n pre_roots = cur_roots\n print(f'layer={_}, list: {word_list}, cur_roots={[x.val for x in cur_roots]}')\n\n return self.run_list(roots)","def commonlen(s1, s2):\n # given \"hi\", \"hip\"\n # izip_longest(\"hi\", \"hip\") -> ('h','h'), ('i','i'), (None, 'p')\n # enumerate -> (0,('h','h')), (1,('i','i')), (2,(None, 'p'))\n # dropwhile(lambda (i,(x,y)): x == 5 -> (2,(None,'p')) ...\n try:\n return itertools.dropwhile(\n lambda (i, (x, y)): x == y, enumerate(zip(s1, s2))).next()[0]\n except StopIteration:\n # strings are identical return the len of one of them\n return len(s1)","def damerau_levenshtein_distance(s1, s2):\n\n utils.check_for_none(s1, s2)\n utils.check_for_type(str, s1, s2)\n\n # s1 = utils.unicode_normalize(s1)\n # s2 = utils.unicode_normalize(s2)\n\n n1, n2 = len(s1), len(s2)\n infinite = n1 + n2\n\n char_arr = defaultdict(int)\n dp = [[0] * (n2 + 2) for _ in range(n1 + 2)]\n\n dp[0][0] = infinite\n for i in range(0, n1 + 1):\n dp[i + 1][0] = infinite\n dp[i + 1][1] = i\n for i in range(0, n2 + 1):\n dp[0][i + 1] = infinite\n dp[1][i + 1] = i\n\n for i in range(1, n1 + 1):\n db = 0\n for j in range(1, n2 + 1):\n i1 = char_arr[s2[j - 1]]\n j1 = db\n cost = 1\n if s1[i - 1] == s2[j - 1]:\n cost = 0\n db = j\n\n dp[i + 1][j + 1] = min(dp[i][j] + cost,\n dp[i + 1][j] + 1,\n dp[i][j + 1] + 1,\n dp[i1][j1] + (i - i1 - 1) + 1 + (j - j1 - 1))\n char_arr[s1[i - 1]] = i\n\n return dp[n1 + 1][n2 + 1]","def shortest(self, word1, word2):\n a, b = self.d[word1], self.d[word2]\n m, n, i, j, res = len(a), len(b), 0, 0, float('inf')\n while i < m and j < n:\n res = min(res, abs(a[i] - b[j]))\n if a[i] > b[j]:\n j += 1\n else:\n i += 1\n return res","def common_token_len(self, w1, d1, w2, d2):\n w1_tk = set(self.__stem_Tokens(w1))\n w2_tk = set(self.__stem_Tokens(w2))\n common_len = len(w1_tk.intersection(w2_tk))\n return common_len","def _find_common_tail(self, l1, l2):\n i = -1\n try:\n while l1[i] == l2[i]:\n i -= 1\n except IndexError:\n # One list is the tail of the other\n pass\n # i now gives the last differing element\n assert i < -1\n return i+1","def remove_common(first: list, second: list):\n return list(set(first)-set(second))","def calculate_overlap(self, r1, r2):\n\n # We know that reads that can be glued,\n # share at least half of their length.\n # Make sure one is not shorter than\n # the half of another.\n\n if len(r1) / 2 + len(r1) % 2 <= len(r2) \\\n and len(r2) / 2 + len(r2) % 2 <= len(r1):\n\n # prepare second halves for overlap pre-check\n\n tail1 = r1[len(r1) / 2:]\n tail2 = r2[len(r2) / 2:]\n \n # case 1: r1 contains r2 completely\n #\n # For example,\n #\n # ATCGCCGGAT\n # TCGCCGGA\n \n pos = r1.find(r2)\n if pos != -1:\n self.reads[r1].overlaps[r2] = pos + len(r2) - len(r1)\n \n # case 2: r2 contains r1 completely\n #\n # For example,\n #\n # TCGCCGGA\n # ATCGCCGGAT\n \n pos = r2.find(r1)\n if pos != -1:\n self.reads[r2].overlaps[r1] = pos + len(r1) - len(r2)\n \n # case 3: end of r1 overlaps with beginning of r2\n #\n # For example,\n #\n # ATCGCCGGAT\n # TCGCCGGATGC\n #\n # First check that at least half of r1 is in r2\n # If there is a match, calculate the expected length \n # of overlap and check if they indeed overlap.\n\n \n pos = r2.find(tail1)\n if pos != -1:\n overlap = pos + len(tail1)\n if r1[-overlap:] == r2[:overlap]:\n self.reads[r1].overlaps[r2] = len(r2) - overlap\n \n # case 4: end of r2 overlaps with beginning of r1\n #\n # For example,\n #\n # CGCCGGATCC\n # TCGCCGGAT\n #\n # First check that at least half of r2 is in r1\n # If there is a match, calculate the expected length \n # of overlap and check if they indeed overlap.\n \n pos = r1.find(tail2)\n if pos != -1: \n overlap = pos + len(tail2)\n if r2[-overlap:] == r1[:overlap]:\n self.reads[r2].overlaps[r1] = len(r1) - overlap","def get_similarity(s1, s2):\n t0 = sorted(list(set(s1.split(' ')).intersection(set(s2.split(' ')))))\n t1 = sorted(list(set(t0 + s1.split(' '))))\n t2 = sorted(list(set(t0 + s2.split(' '))))\n\n r01 = SequenceMatcher(None, t0, t1).ratio()\n r02 = SequenceMatcher(None, t0, t2).ratio()\n r12 = SequenceMatcher(None, t1, t2).ratio()\n return max(r01, r02, r12)","def compSeq(s1, s2, lineL=50):\n lineN = int(np.ceil(min(len(s1), len(s2))/lineL))\n count = 0\n samecount = 0\n outStr = ''\n for linei in range(lineN):\n if (linei+1) * lineL < min(len(s1), len(s2)):\n end = (linei+1) * lineL\n else:\n end = min(len(s1), len(s2))\n outStr += 'Pos %d - %d\\n' % (linei*lineL+1, end-1+1)\n for sitei in range(linei*lineL, end):\n outStr += s1[sitei]\n outStr += '\\n'\n for sitei in range(linei*lineL, end):\n out = ' ' if s1[sitei] == s2[sitei] else '|'\n outStr += out\n count += 1\n samecount += 1 if s1[sitei]==s2[sitei] else 0\n outStr += '\\n'\n for sitei in range(linei*lineL, end):\n out = '.' if s1[sitei] == s2[sitei] else s2[sitei]\n outStr += s2[sitei]\n outStr += '\\n\\n'\n outStr += 'Seq1 (%d) and Seq2 (%d) are %1.1f%% similar\\n\\n' % (len(s1), len(s2), 1e2*samecount/count)\n print(outStr)","def _recon_lcs(x, y):\n i, j = len(x), len(y)\n table = _lcs(x, y)\n\n def _recon(i, j):\n \"\"\"private recon calculation\"\"\"\n if i == 0 or j == 0:\n return []\n elif x[i - 1] == y[j - 1]:\n return _recon(i - 1, j - 1) + [(x[i - 1], i)]\n elif table[i - 1, j] > table[i, j - 1]:\n return _recon(i - 1, j)\n else:\n return _recon(i, j - 1)\n\n recon_tuple = tuple(map(lambda x: x[0], _recon(i, j)))\n return recon_tuple","def overlapping_ranges(\n ranges_1: Sequence[Tuple[int, int]],\n ranges_2: Sequence[Tuple[int, int]],\n) -> List[Tuple[int, int]]:\n return [\n (max(first[0], second[0]), min(first[1], second[1]))\n for first in ranges_1\n for second in ranges_2\n if max(first[0], second[0]) < min(first[1], second[1])\n ]","def compute_keysets(left_seq, right_seq):\n assert isinstance(left_seq, type(right_seq)), (left_seq, right_seq)\n assert type(left_seq) in NONTERMINALS, left_seq\n\n if type(left_seq) is dict:\n left_keyset = set(left_seq.keys())\n right_keyset = set(right_seq.keys())\n else:\n left_keyset = set(range(len(left_seq)))\n right_keyset = set(range(len(right_seq)))\n\n overlap = left_keyset.intersection(right_keyset)\n left_only = left_keyset - right_keyset\n right_only = right_keyset - left_keyset\n\n return overlap, left_only, right_only","def find_overlap_range(x1, lenght1, x2, length2):\n\n\n highest_start_point = max(x1, x2)\n lowest_end_point = min(x1 + lenght1, x2 + length2)\n \n if highest_start_point >= lowest_end_point:\n return None\n \n overlap_length = lowest_end_point - highest_start_point\n \n return (highest_start_point, overlap_length)","def rgenerate(allele1, allele2, min_length, max_length):\n from .models import Primer\n\n if len(allele1) != len(allele2):\n raise ValueError('Aligned alleles must be the same length.')\n\n allele1 = str(allele1)\n allele2 = str(allele2)\n candidates = []\n\n for size in range(min_length, max_length+1):\n allele1_span = (0, size)\n allele2_span = (0, size)\n\n for i in range(len(allele1)-size):\n if allele1[i:i+size] == allele2[i:i+size]:\n candidates.append(Primer(sequence=allele1[i:i+size],\n allele1_span=allele1_span,\n allele2_span=allele2_span,\n strand=1))\n\n if allele1[i] != '-':\n allele1_span = (allele1_span[0]+1, allele1_span[1]+1)\n\n if allele2[i] != '-':\n allele2_span = (allele2_span[0]+1, allele2_span[1]+1)\n\n return candidates","def sorted_intersect(self, list1, list2):\n ### Begin your code\n result = []\n p1 = 0\n p2 = 0\n s1 = int(math.sqrt(len(list1)))\n s2 = int(math.sqrt(len(list2)))\n while (p1 < len(list1) and p2 < len(list2)):\n if list1[p1] == list2[p2]:\n result.append(list1[p1])\n p1 = p1 + 1\n p2 = p2 + 1\n elif list1[p1] < list2[p2]:\n if (p1 + s1 >= len(list1) or list1[p1 + s1] > list2[p2]):\n p1 = p1 + 1\n else:\n p1 = p1 + s1\n else:\n if (p2 + s2 >= len(list2) or list2[p2 + s2] > list2[p2]):\n p2 = p2 + 1\n else:\n p2 = p2 + s2\n # print(result)\n return result\n ### End your code","def commonality(left_struc, right_struc):\n assert type(left_struc) is type(right_struc), (left_struc, right_struc)\n assert left_struc and right_struc, (left_struc, right_struc)\n if type(left_struc) is dict:\n (overlap, left, right) = compute_keysets(left_struc, right_struc)\n com = float(len(overlap))\n tot = len(overlap.union(left, right))\n else:\n assert type(left_struc) in (list, tuple), left_struc\n com = 0.0\n for elem in left_struc:\n if elem in right_struc:\n com += 1\n tot = max(len(left_struc), len(right_struc))\n\n return com / tot","def get_synset_overlap(sentence_a, sentence_b):\n def synsets(word):\n sense_lemmas = []\n for pos in ('n'):#,'a'):\n for i in xrange(5):\n try:\n sense_lemmas += [lemma.name \n for lemma in wn.synset('{0}.{1}.0{2}'.format(word, pos, i)).lemmas]\n except WordNetError: \n pass\n return sense_lemmas\n\n a_set = set(lemma for word in sentence_a for lemma in synsets(word))\n b_set = set(lemma for word in sentence_b for lemma in synsets(word))\n score = len(a_set&b_set)/float(len(a_set|b_set))\n \n return score","def compare_words(word1, word2):\n word1 = word1.lower()\n word2 = word2.lower()\n seg_scores = []\n if len(word1) >= len(word2):\n for i in range(0, len(word1) - len(word2) + 1):\n seg_scores.append(find_difference(word1[i:i+len(word2)], word2))\n else:\n for i in range(0, len(word2) - len(word1) + 1):\n seg_scores.append(find_difference(word2[i:i+len(word1)], word1))\n return round(min(seg_scores) + abs(len(word1) - len(word2))/float(len(max([word1, word2]))),2)","def test_maximum_common_subgraph(graph1, graph2, attrs):\n expected = vermouth.graph_utils.categorical_maximum_common_subgraph(graph1, graph2, attrs)\n\n found = vermouth.graph_utils.maximum_common_subgraph(graph1, graph2, attrs)\n\n note((\"Attributes that must match\", attrs))\n note((\"Graph 1 nodes\", graph1.nodes(data=True)))\n note((\"Graph 1 edges\", graph1.edges))\n note((\"Graph 2 nodes\", graph2.nodes(data=True)))\n note((\"Graph 2 edges\", graph2.edges))\n # We don't find all MCS'es. See comment in\n # vermouth.graph_utils.maximum_common_subgraph\n found = make_into_set(found)\n expected = make_into_set(expected)\n\n if found == expected:\n event(\"Exact match\")\n assert found <= expected","def lcs_dp(strA, strB):\n rows = len(strA) + 1\n cols = len(strB) + 1\n dp_table = [[0 for j in range(cols)] for i in range(rows)]\n\n for row in range(1, rows):\n for col in range(1, cols):\n if strA[row - 1] == strB[col - 1]:\n dp_table[row][col] = dp_table[row - 1][col - 1] + 1\n else:\n dp_table[row][col] = max(dp_table[row][col - 1], dp_table[row - 1][col])\n return dp_table[rows-1][cols-1]","def merge(first, second, reverse):\r\n final = [0]*(len(first)+len(second))\r\n i = 0\r\n j = 0\r\n if reverse:\r\n while i+j < len(final):\r\n if (j >= len(second)) or ((i < len(first)) and (first[i] > second[j])):\r\n final[i+j] = first[i]\r\n i += 1\r\n else:\r\n final[i+j] = second[j]\r\n j += 1\r\n else:\r\n while i+j < len(final):\r\n if (j >= len(second)) or ((i < len(first)) and (first[i] < second[j])):\r\n final[i+j] = first[i]\r\n i += 1\r\n else:\r\n final[i+j] = second[j]\r\n j += 1\r\n return final","def _recon_lcs(x, y):\n i, j = len(x), len(y)\n table = _lcs(x, y)\n\n def _recon(i, j):\n \"\"\"private recon calculation\"\"\"\n if i == 0 or j == 0:\n return []\n elif x[i - 1] == y[j - 1]:\n return _recon(i - 1, j - 1) + [(x[i - 1], i)]\n elif table[i - 1, j] > table[i, j - 1]:\n return _recon(i - 1, j)\n else:\n return _recon(i, j - 1)\n\n recon_tuple = tuple(map(lambda x: x[0], _recon(i, j)))\n return recon_tuple","def merge(arr1, arr2):\n i = 0\n j = 0\n sol = []\n while i < len(arr1) and j < len(arr2):\n if arr1[i] <= arr2[j]:\n sol.append(arr1[i])\n i += 1\n else:\n sol.append(arr2[j])\n j += 1\n if i < len(arr1):\n sol.extend(arr1[i:])\n if j < len(arr2):\n sol.extend(arr2[j:])\n return sol","def lcs_recursion(str1, str2):\n if len(str1) == 0 or len(str2) == 0:\n return \"\"\n if str1[0] == str2[0]:\n return str1[0] + lcs_recursion(str1[1:], str2[1:])\n else:\n r1 = lcs_recursion(str1,str2[1:])\n r2 = lcs_recursion(str1[1:],str2)\n r = r1 if len(r1) > len(r2) else r2\n return r"],"string":"[\n \"def longest_common_subsequence(seq1, seq2):\\n mat = DPMatrix(seq1, seq2, match=1, mismatch=0, gap=0)\\n mat.fill()\\n\\n lcs = []\\n augSeq1, augSeq2 = mat.augmented_sequences()\\n for c1, c2 in zip(augSeq1, augSeq2):\\n if c1 == c2:\\n lcs.append(c1)\\n\\n return ''.join(lcs)\",\n \"def longest_shared_between(cls, seq_1, seq_2):\\n tree = cls(seq_2 + '$', 'B').append_named_sequence(seq_1 + '$', 'A')\\n condition = lambda n, c, p: 'B' not in c.seq_ids\\n out = lambda n, c, p: p + n.label\\n unshared = tree.root.bfs_paths(condition, out)\\n shortest = next(unshared)\\n common = [shortest]\\n for possible in unshared:\\n if len(possible) > len(shortest) and not possible[-1] == '$':\\n shortest = possible\\n common = [possible]\\n elif len(possible) == len(shortest) and not possible[-1] == '$':\\n common.append(possible)\\n return min(common)\",\n \"def longest_common_subsequence(x, y):\\n\\n # find the length of the strings\\n m = len(x)\\n n = len(y)\\n\\n # declaring the array for storing the dp values\\n lcs = np.zeros((m + 1, n + 1))\\n\\n # iterate through each sub problem\\n for i in range(m + 1):\\n for j in range(n + 1):\\n if i == 0 or j == 0:\\n lcs[i, j] = 0\\n elif x[i - 1] == y[j - 1]:\\n lcs[i, j] = lcs[i - 1, j - 1] + 1\\n else:\\n # use the optimal substructure property\\n # of using already computed results previous subproblems\\n lcs[i, j] = max(lcs[i - 1, j], lcs[i, j - 1])\\n\\n # L[m,n] contains the length of LCS of X[0..n-1] & Y[0..m-1]\\n return lcs[m, n]\",\n \"def longestCommonSubsequence(self, text1: str, text2: str) -> int:\\n if len(text1) == 0 or len(text2) == 0:\\n return 0\\n if text1[0] == text2[0]:\\n return 1 + self.longestCommonSubsequence(text1[1:], text2[1:])\\n else:\\n return max(self.longestCommonSubsequence(text1[1:], text2),\\n self.longestCommonSubsequence(text1, text2[1:]))\",\n \"def lcs(s1, s2):\\n\\n shape = (len(s1) + 1, len(s2) + 1)\\n M = np.zeros(shape)\\n\\n max_length_so_far = 0\\n candidates = set()\\n\\n for i in range(len(s1)):\\n for j in range(len(s2)):\\n\\n if s1[i] == s2[j]:\\n M[i+1,j+1] = M[i,j] + 1\\n\\n if M[i+1,j+1] > max_length_so_far:\\n max_length_so_far = int(M[i+1,j+1])\\n candidates = {s1[i - max_length_so_far + 1: i + 1]}\\n\\n elif M[i+1,j+1] == max_length_so_far:\\n candidates.add(s1[i - max_length_so_far + 1: i + 1])\\n\\n else:\\n M[i,j] = 0\\n\\n candidates.add('')\\n\\n return candidates\",\n \"def longest(s1, s2):\\n return ''.join(sorted(set(s1+s2)))\",\n \"def longest_common_substring_bottom_up(s1, s2):\\n lcs_array = lcs(s1, s2)\\n n = len(s1)\\n m = len(s2)\\n l = lcs_array[n][m]\\n result = \\\"\\\"\\n while l != 0:\\n if s1[n - 1] == s2[m - 1]:\\n result = s1[n - 1] + result\\n l -= 1\\n n -= 1\\n m -= 1\\n elif lcs_array[n][m - 1] >= lcs_array[n - 1][m]:\\n m -= 1\\n else:\\n n -= 1\\n return result\",\n \"def m_longest_common_subsequence_2(s):\\n\\n # Correct me if I'm wrong but I think unsorted list is faster\\n lst = list(s)\\n\\n lcs = lst[0]\\n for string in lst[1:]:\\n lcs = LCS(lcs, string)\\n\\n return lcs\",\n \"def longest_common_substring_iterative_bottom_up(s1, s2):\\n\\n cache = [[0] * (len(s2)+1) for _ in range(-1, len(s1))]\\n\\n for i in range(1, len(s1)+1):\\n for j in range(1, len(s2)+1):\\n\\n if s1[i-1] == s2[j-1]:\\n\\n # previous count is cache[i-1][j-1]\\n cache[i][j] = cache[i-1][j-1] + 1\\n else:\\n cache[i][j] = max(cache[i-1][j-1],\\n max(cache[i-1][j],\\n cache[i][j-1]))\\n\\n return cache[-1][-1]\",\n \"def dynamic(a, b):\\n m = len(a)\\n n = len(b)\\n d = [[0 for i in range(n)] for j in range(m)] # d[i][j] is length of common sequence of consecutive\\n prev = [-1 for j in range(n)] # numbers that ends with a[i] == b[j]\\n global_max = 0\\n global_pos = -1\\n for i in range(0, m):\\n for j in range(0, n): # iterate through all the elements by dual circle\\n if a[i] == b[j]: # if pair is equal then check if there is sequence that ends with a[i]-1\\n max_len = 0 # find longest sequence ends with a[i]-1\\n max_prev = -1\\n for k in range(i+1):\\n for l in range(j+1):\\n if k == i and l == j:\\n continue\\n if d[k][l] > max_len and a[k] == b[l] == a[i] - 1:\\n max_len = d[k][l]\\n max_prev = l\\n d[i][j] = max_len + 1\\n if d[i][j] > global_max:\\n global_max = d[i][j]\\n global_pos = j\\n prev[j] = max_prev\\n\\n res = [] # rebuild the answer\\n while global_pos != -1:\\n res.append(b[global_pos])\\n global_pos = prev[global_pos]\\n\\n return res[::-1]\",\n \"def find_LCS(seq1, seq2, all=False):\\n C = [[0 for j in range(len(seq2) + 1)] for i in range(len(seq1) + 1)]\\n\\n for i in range(1, len(seq1) + 1):\\n for j in range(1, len(seq2) + 1):\\n inter = seq1[i - 1].intersection(seq2[j - 1])\\n\\n C[i][j] = max([C[i - 1][j - 1] + len(inter),\\n C[i - 1][j],\\n C[i][j - 1]])\\n\\n # now we need to backtrack the structure to get the pattern\\n if all:\\n all_lcs = backtrack_all_LCS(C, seq1, seq2, len(seq1), len(seq2))\\n return {i[1:] for i in all_lcs}\\n\\n lcs = []\\n backtrack_LCS(C, seq1, seq2, len(seq1), len(seq2), lcs)\\n return lcs\",\n \"def longest_subsequence(s1: str, s2: str, s3: str) -> int:\\n # Find the shortest string\\n s = min(s1, s2, s3, key=lambda x: len(x))\\n total = 0\\n ok = False\\n while s1:\\n for i1, c1 in enumerate(s1):\\n for i2, c2 in enumerate(s2):\\n if ok:\\n ok = False\\n break\\n if c1 == c2:\\n for i3, c3 in enumerate(s3):\\n if c1 == c3:\\n total += 1\\n s1 = s1[i1 + 1:]\\n s2 = s2[i2 + 1:]\\n s3 = s3[i3 + 1:]\\n ok = True\\n break\\n\\n return total\",\n \"def longest_common_prefix(strings: list):\\n raise NotImplemented\",\n \"def lcs_length(s1, s2):\\n n = len(s1)\\n m = len(s2)\\n matrix = [([0]*(m+1)) for i in xrange(n+1)]\\n for i in xrange(1, n+1):\\n for j in xrange(1, m+1):\\n if(s1[i-1]==s2[j-1]):\\n matrix[i][j] = matrix[i-1][j-1] + 1\\n else:\\n matrix[i][j] = max(matrix[i-1][j], matrix[i][j-1])\\n return matrix[n][m]\",\n \"def longest_common_prefix(fst: str, snd: str) -> str:\\n bound = 0\\n for a, b in zip(fst, snd):\\n if a != b:\\n break\\n bound += 1\\n return fst[:bound]\",\n \"def compare_eq_len(a, b):\\n n = len(a)\\n m = len(b)\\n\\n # slide b across a from left to right till from just overlapping till full overlap\\n overlap = 0 # stores length of the overlap\\n lconcat = \\\"\\\" # this stores the shortest common superstring\\n for j in range(m):\\n starta = 0\\n enda = j+1\\n startb = m - (j+1)\\n endb = m\\n if a[starta:enda] == b[startb:endb]:\\n # if an overlap is found, check if it is larger than the previously detected one\\n # print(\\\"overlap found\\\")\\n if len(a[starta:enda]) > overlap: \\n overlap = len(a[starta:enda]) \\n lconcat = b + a[enda:] # this is the current shortest common superstring\\n # print(starta, enda, startb, endb, a[starta:enda], b[startb:endb])\\n\\n # print(\\\"-\\\")\\n\\n # slide b across a so that b starts from one element past a after full overlap\\n rconcat = \\\"\\\"\\n for j in range(m-1):\\n starta = j+1\\n enda = m\\n startb = 0\\n endb = m - (j+1)\\n if a[starta:enda] == b[startb:endb]:\\n if len(a[starta:enda]) > overlap: # if there is a bigger overlap then save it \\n # print(\\\"overlap found\\\")\\n overlap = len(a[starta:enda]) \\n rconcat = a + b[endb:]\\n # print(starta, enda, startb, endb, a[starta:enda], b[startb:endb])\\n\\n # after checking for overlaps there may be 1 or no shortest common\\n # superstrings stored in both lconcat and rconcat. Choose the shortest one if it exists\\n # or the concatenation of a and b if there are no overlaps. We may have to make some\\n # arbitrary choices here.\\n\\n if not lconcat and not rconcat: # both lconcat and rconcat are empty, no overlaps\\n superstring = a + b # append b to a (could prepend here too, this is an arbitrary choice)\\n elif lconcat and not rconcat: # lconcat contains overlap and rconcat is empty\\n superstring = lconcat \\n elif rconcat and not lconcat: # rconcat contains overlap and lconcat is empty\\n superstring = rconcat\\n elif rconcat and lconcat and (len(lconcat) <= len(rconcat)): # use lconcat if it is shorter or equal len to rconat\\n superstring = lconcat\\n elif rconcat and lconcat and (len(rconcat) < len(lconcat)): # use rconcat only if it is shorter than lconat\\n superstring = rconcat\\n return superstring\",\n \"def find_lcs(l1: str, l2: str, length1: int, length2: int):\\n \\\"\\\"\\\" Theorem:{\\n Initialize matrix with 0 for first row and colm\\n If s1[i] = s2[j], update matrix[i][j] with value\\n of matrix[i-1][j-1]+1\\n Else update matrix[i][j] with max of value among\\n matrix[i][j-1],matrix[i-1][j]\\n Matrix[n][m] will be lcs\\n }\\n \\\"\\\"\\\"\\n matrix = [[None]*(length1+1) for i in range(0, length2+1)]\\n for i in range(0, length2+1):\\n for j in range(0, length1+1):\\n if i == 0 or j == 0:\\n matrix[i][j] = 0\\n elif l1[j-1] == l2[i-1]:\\n matrix[i][j] = matrix[i-1][j-1] + 1\\n else:\\n matrix[i][j] = max(matrix[i][j-1], matrix[i-1][j])\\n lcs = [None for i in range(0, matrix[length2][length1])]\\n index = matrix[length2][length1]\\n m = length2 \\n n = length1\\n while(m > -1 and n > -1):\\n if l2[m-1] == l1[n-1]:\\n lcs[index-1] = l2[m-1]\\n index -= 1\\n m -= 1\\n n -= 1\\n elif matrix[m-1][n] > matrix[m][n-1]:\\n m -= 1\\n else:\\n n -= 1\\n return lcs\",\n \"def linear_merge(sorted1, sorted2):\\n first_pointer = 0\\n second_pointer = 0\\n sorted_result = []\\n\\n while second_pointer < len(sorted2) and first_pointer < len(sorted1):\\n if sorted1[first_pointer] < sorted2[second_pointer]:\\n sorted_result.append(sorted1[first_pointer])\\n first_pointer += 1\\n else:\\n sorted_result.append(sorted2[second_pointer])\\n second_pointer += 1\\n\\n while second_pointer < len(sorted2):\\n sorted_result.append(sorted2[second_pointer])\\n second_pointer += 1\\n\\n while first_pointer < len(sorted1):\\n sorted_result.append(sorted1[first_pointer])\\n first_pointer += 1\\n\\n\\n return sorted_result\",\n \"def longestCommomSubsequence(self, arrays: List[List[int]]) -> List[int]:\\n counts = Counter(val for arr in arrays for val in arr)\\n res = []\\n for val, count in counts.items():\\n if count == len(arrays): res.append(val)\\n return res\",\n \"def findLongestCommonSubstring(self, string1, string2):\\n countingArray = [[0]*len(string2) for i in range(len(string1))]\\n ##we set up an array to locate the possible substrings\\n lcss = \\\"\\\"\\n for row in range(len(countingArray)):\\n for column in range(len(countingArray[row])):\\n if string1[row] == string2[column]:\\n countingArray[row][column] += 1 ##if there's a match the common string length is at least 1\\n if not (row == 0 or column == 0):\\n countingArray[row][column] += countingArray[row-1][column-1] ##memoize the length of the common string so far\\n if countingArray[row][column] > longestLength: ##if it's longer than our current longest string, we'll plan on returning it\\n longestLength = countingArray[row][column]\\n lcss = string1[row-longestLength+1:row+1]\\n return lcss\",\n \"def find_longest_common_prefix_reduce(words:list):\\n if not words:\\n return ''\\n \\n def common_start(w1, w2):\\n shorter = w1 if len(w1) < len(w2) else w2\\n for i in range(0, len(shorter)):\\n if w1[i] != w2[i]:\\n return shorter[:i]\\n return shorter\\n \\n return reduce(common_start, words)\",\n \"def common(s1, s2):\\n cl = commonlen(s1, s2)\\n return s2[:cl]\",\n \"def _get_overlap(word1, word2):\\n max_overlap = min(len(word1), len(word2))\\n max_found = 0\\n for size in range(1, max_overlap+1):\\n suffix = word1[-size:]\\n prefix = word2[:size]\\n if suffix == prefix:\\n max_found = size\\n return max_found\",\n \"def LCS_length(str1, str2):\\n if str1 is None or str2 is None:\\n return 0\\n\\n len1 = len(str1)\\n len2 = len(str2)\\n if len1 == 0 or len2 == 0:\\n return 0\\n\\n lcs = [[0 for _ in range(len2 + 1)] for _ in range(2)]\\n for i in range(1, len1 + 1):\\n for j in range(1, len2 + 1):\\n if str1[i - 1] == str2[j - 1]:\\n lcs[i % 2][j] = lcs[(i - 1) % 2][j - 1] + 1\\n else:\\n if lcs[i % 2][j - 1] >= lcs[(i - 1) % 2][j]:\\n lcs[i % 2][j] = lcs[i % 2][j - 1]\\n else:\\n lcs[i % 2][j] = lcs[(i - 1) % 2][j]\\n\\n return lcs[len1 % 2][-1]\",\n \"def findLongestCommonSubstringManyStrings(listOfStrings):\",\n \"def fullCmpSets(s1, s2):\\n if len(s1) != len(s2):\\n return 1\\n for s1i, s2i in map(None, s1, s2):\\n f = s1i.fullCmp(s2i)\\n if f:\\n return f\",\n \"def naive(l1: ListNode, l2: ListNode) -> ListNode:\\n n = (get_length(l1), l1)\\n m = (get_length(l2), l2)\\n smaller = min(n, m, key=lambda x: x[0])[1] # choose the smaller list, of l1 and l2\\n larger = max(n, m, key=lambda x: x[0])[1]\\n seen = {}\\n while smaller: # Using the smaller list, track seen nodes using a hash table\\n seen[smaller] = True\\n smaller = smaller.next\\n while larger:\\n if larger in seen: # if any node in the larger list has been seen (overlaps with smaller list) return it\\n return larger\\n larger = larger.next\\n return None # no intersection\",\n \"def longest_common_substring_top_down(s1, s2, q=1, r=1, cache=None):\\n if cache is None:\\n cache = {}\\n if (q, r) in cache:\\n return cache[(q, r)]\\n n = len(s1)\\n m = len(s2)\\n if n == q - 1 or m == r - 1:\\n cache[(q, r)] = \\\"\\\"\\n return \\\"\\\"\\n elif s1[n - q] == s2[m - r]: #\\n ss = longest_common_substring_top_down(s1, s2, q + 1, r + 1, cache) + s1[n - q]\\n cache[(q, r)] = ss\\n return ss\\n ss1 = longest_common_substring_top_down(s1, s2, q, r + 1, cache)\\n ss2 = longest_common_substring_top_down(s1, s2, q + 1, r, cache)\\n if (len(ss1) >= len(ss2)):\\n cache[(q, r)] = ss1\\n return ss1\\n else:\\n cache[(q, r)] = ss2\\n return ss2\",\n \"def _commonParent(zi1, zi2):\\n shorter, longer = sorted([_linearize(x)[::-1] for x in zi1, zi2],\\n key=len)\\n for n in range(len(shorter)):\\n if shorter[n] != longer[n]:\\n if n == 0:\\n return None\\n return shorter[n-1]\\n return shorter[-1]\",\n \"def _lcs_dp(a, b):\\n dp = [[0 for _ in range(0, len(b) + 1)]\\n for _ in range(0, len(a) + 1)]\\n # dp[i][j]: lcs_len(a[:i], b[:j])\\n for i in range(1, len(a) + 1):\\n for j in range(1, len(b) + 1):\\n if a[i - 1] == b[j - 1]:\\n dp[i][j] = dp[i - 1][j - 1] + 1\\n else:\\n dp[i][j] = max(dp[i - 1][j], dp[i][j - 1])\\n return dp\",\n \"def overlap(s1,s2):\\n if len(s1) >= len(s2):\\n longer = s1.lower()\\n shorter = s2.lower()\\n else:\\n longer = s2.lower()\\n shorter = s1.lower()\\n s3 = shorter + longer # by default this is our combination \\n if shorter in longer: # return if shorter is contained in longer\\n return longer\\n else:\\n for i in rnage(1,len(shorter)):\\n if shorter[i:] == longer[:len(shorter[i:])]:\\n #checks if shorter is in beginning of longer\\n s3 = shorter + longer[len(shorter[i:]):]\\n break\\n for i in reversed(range(len(shorter))):\\n if shorter[:i] == longer[-len(shorter[:i]):]:\\n # checks if shorter is in ending of longer\\n if len(s3) > len(longer[:-len(shorter[:i])] + shorter:\\n s3 = longer[:-len(shorter[:i])] + shorter\\n break\\n return s3\",\n \"def dameraulevenshtein(self, seq1, seq2):\\n # codesnippet:D0DE4716-B6E6-4161-9219-2903BF8F547F\\n # Conceptually, this is based on a len(seq1) + 1 * len(seq2) + 1 matrix.\\n # However, only the current and two previous rows are needed at once,\\n # so we only store those.\\n oneago = None\\n thisrow = range(1, len(seq2) + 1) + [0]\\n for x in xrange(len(seq1)):\\n # Python lists wrap around for negative indices, so put the\\n # leftmost column at the *end* of the list. This matches with\\n # the zero-indexed strings and saves extra calculation.\\n twoago, oneago, thisrow = oneago, thisrow, [0] * len(seq2) + [x + 1]\\n for y in xrange(len(seq2)):\\n delcost = oneago[y] + 1\\n addcost = thisrow[y - 1] + 1\\n subcost = oneago[y - 1] + (seq1[x] != seq2[y])\\n thisrow[y] = min(delcost, addcost, subcost)\\n # This block deals with transpositions\\n if (x > 0 and y > 0 and seq1[x] == seq2[y - 1]\\n and seq1[x-1] == seq2[y] and seq1[x] != seq2[y]):\\n thisrow[y] = min(thisrow[y], twoago[y - 2] + 1)\\n return thisrow[len(seq2) - 1]\",\n \"def _common_prefix(sequence1, sequence2):\\n i = 0\\n for elem1, elem2 in zip(sequence1, sequence2):\\n if elem1 != elem2:\\n return i\\n i += 1\\n\\n # Return length of sequence if sequences are identical\\n return min(len(sequence1), len(sequence2))\",\n \"def getCommon(self, st1, st2):\\n fl = len(st1)\\n shorter = len(st2)\\n if fl < shorter:\\n shorter = fl\\n \\n i = 0\\n while i < shorter:\\n if st1[i] != st2[i]:\\n break\\n i += 1\\n return i\",\n \"def common_end(a, b):\\n return a[0] == b[0] or a[-1] == b[-1]\\n # return [0] == [0] or [-1] == [-1]\",\n \"def findAllCommonSubstrings(self, string1, string2):\\n countingArray = [[0]*len(string1) for i in range(len(string2))]\\n ##we set up an array to locate the possible substrings\\n candidates = set()\\n for row in range(len(countingArray)):\\n for column in range(len(countingArray[row])):\\n if string2[row] == string1[column]:\\n countingArray[row][column] += 1\\n if not (row == 0 or column == 0):\\n countingArray[row][column] += countingArray[row-1][column-1]\\n candidates.add(string2[row-countingArray[row][column]+1:row+1])\\n candidates = list(candidates)\\n candidates.sort(key=len)\\n candidates = list(reversed(candidates))\\n return candidates\",\n \"def test_lcs_nouns(id1, id2, expected_ids):\\n syn1 = germanet_data.get_synset_by_id(id1)\\n syn2 = germanet_data.get_synset_by_id(id2)\\n lcs = syn1.lowest_common_subsumer(syn2)\\n np.testing.assert_equal(sorted([l.id for l in lcs]), sorted(expected_ids))\",\n \"def shortest_unshared_between(cls, seq_1, seq_2):\\n tree = cls(seq_2 + '$', 'B').append_named_sequence(seq_1 + '$', 'A')\\n condition = lambda n, c, p: 'B' not in c.seq_ids\\n out = lambda n, c, p: p + n.label + c.label[0]\\n unshared = tree.root.bfs_paths(condition, out)\\n shortest = next(unshared)\\n common = [shortest]\\n for possible in unshared:\\n if len(possible) < len(shortest) and not possible[-1] == '$':\\n shortest = possible\\n common = [possible]\\n elif len(possible) == len(shortest) and not possible[-1] == '$':\\n common.append(possible)\\n return min(common)\",\n \"def lowest_common_subsumer(self, other):\\n lcs = set()\\n if other == self:\\n lcs.add(self)\\n return lcs\\n if other in self._direct_hypernyms or other.is_root():\\n lcs.add(other)\\n return lcs\\n if self in other._direct_hypernyms or self.is_root():\\n lcs.add(self)\\n return lcs\\n common_hypernyms = self.common_hypernyms(other)\\n dist_dict1 = self.get_distances_hypernym_dic()\\n dist_dict2 = other.get_distances_hypernym_dic()\\n dist = math.inf\\n for hypernym in common_hypernyms:\\n dist1 = dist_dict1[hypernym]\\n dist2 = dist_dict2[hypernym]\\n if dist1 + dist2 < dist:\\n lcs.clear()\\n lcs.add(hypernym)\\n dist = dist1 + dist2\\n if dist1 + dist2 == dist:\\n lcs.add(hypernym)\\n return lcs\",\n \"def dameraulevenshtein(seq1, seq2):\\n # codesnippet:D0DE4716-B6E6-4161-9219-2903BF8F547F\\n # Conceptually, this is based on a len(seq1) + 1 * len(seq2) + 1 matrix.\\n # However, only the current and two previous rows are needed at once,\\n # so we only store those.\\n oneago = None\\n thisrow = list(range(1, len(seq2) + 1)) + [0]\\n for x in range(len(seq1)):\\n # Python lists wrap around for negative indices, so put the\\n # leftmost column at the *end* of the list. This matches with\\n # the zero-indexed strings and saves extra calculation.\\n twoago, oneago, thisrow = (oneago, thisrow, [0] * len(seq2) + [x + 1])\\n for y in range(len(seq2)):\\n delcost = oneago[y] + 1\\n addcost = thisrow[y - 1] + 1\\n subcost = oneago[y - 1] + (seq1[x] != seq2[y])\\n thisrow[y] = min(delcost, addcost, subcost)\\n # This block deals with transpositions\\n if (x > 0 and y > 0 and seq1[x] == seq2[y - 1]\\n and seq1[x - 1] == seq2[y] and seq1[x] != seq2[y]):\\n thisrow[y] = min(thisrow[y], twoago[y - 2] + 1)\\n return thisrow[len(seq2) - 1]\",\n \"def dameraulevenshtein(seq1, seq2):\\n # codesnippet:D0DE4716-B6E6-4161-9219-2903BF8F547F\\n # Conceptually, this is based on a len(seq1) + 1 * len(seq2) + 1 matrix.\\n # However, only the current and two previous rows are needed at once,\\n # so we only store those.\\n oneago = None\\n thisrow = list(range(1, len(seq2) + 1)) + [0]\\n for x in range(len(seq1)):\\n # Python lists wrap around for negative indices, so put the\\n # leftmost column at the *end* of the list. This matches with\\n # the zero-indexed strings and saves extra calculation.\\n twoago, oneago, thisrow = (oneago, thisrow, [0] * len(seq2) + [x + 1])\\n for y in range(len(seq2)):\\n delcost = oneago[y] + 1\\n addcost = thisrow[y - 1] + 1\\n subcost = oneago[y - 1] + (seq1[x] != seq2[y])\\n thisrow[y] = min(delcost, addcost, subcost)\\n # This block deals with transpositions\\n if (x > 0 and y > 0 and seq1[x] == seq2[y - 1]\\n and seq1[x - 1] == seq2[y] and seq1[x] != seq2[y]):\\n thisrow[y] = min(thisrow[y], twoago[y - 2] + 1)\\n return thisrow[len(seq2) - 1]\",\n \"def scs_of_pair(a, b):\\n # compare two strings where the text a is longer than the pattern b\\n n = len(a)\\n m = len(b)\\n\\n # check the args are the right way round\\n if m > n:\\n raise ValueError(\\\"string b is longer than string a\\\")\\n\\n # slide b across a from left to right till from just overlapping till full overlap\\n overlap = 0 # stores length of the overlap\\n lconcat = \\\"\\\" # stores the curretn shortest common superstring\\n for j in range(n): \\n starta = 0 if (j+1) <= m else ((j+1) - m) \\n enda = j+1 \\n startb = (m - (j+1)) if (j+1) < m else 0 \\n endb = m \\n if a[starta:enda] == b[startb:endb]:\\n # print(\\\"overlap found\\\")\\n if len(a[starta:enda]) > overlap: # if there is a bigger overlap then save it \\n overlap = len(a[starta:enda]) \\n lconcat = b + a[enda:]\\n # print(starta, enda, startb, endb, a[starta:enda], b[startb:endb])\\n\\n # print(\\\"-\\\")\\n rconcat = \\\"\\\"\\n for j in range(m - 1):\\n starta = (n - m) + (j + 1) \\n enda = n \\n startb = 0 \\n endb = m - (j+1) \\n if a[starta:enda] == b[startb:endb]:\\n # print(\\\"overlap found\\\")\\n if len(a[starta:enda]) > overlap: # if there is a bigger overlap then save it \\n overlap = len(a[starta:enda]) \\n rconcat = a + b[endb:]\\n # print(starta, enda, startb, endb, a[starta:enda], b[startb:endb])\\n\\n # after checking for overlaps there may be 1 or no shortest common\\n # superstrings stored in both lconcat and rconcat. Choose the shortest one if it exists\\n # or the concatenation of a and b if there are no overlaps. We may have to make some\\n # arbitrary choices here.\\n\\n if not lconcat and not rconcat: # both lconcat and rconcat are empty, no overlaps\\n superstring = a + b # append b to a (could prepend here too)\\n elif lconcat and not rconcat: # lconcat contains overlap and rconcat is empty\\n superstring = lconcat\\n elif rconcat and not lconcat: # rconcat contains overlap and lconcat is empty\\n superstring = rconcat\\n elif rconcat and lconcat and (len(lconcat) <= len(rconcat)): # use lconcat if it is shorter or equal len to rconat\\n superstring = lconcat\\n elif rconcat and lconcat and (len(rconcat) < len(lconcat)): # use rconcat only if it is shorter than lconat\\n superstring = rconcat\\n return superstring\",\n \"def lcs(s1, s2):\\n n = len(s1)\\n m = len(s2)\\n # initialise 2d array with size n+1 x m+1\\n lcs_array = [[None for _ in range(m + 1)] for _ in range(n + 1)]\\n # build array of LCS counters\\n for i in range(n + 1):\\n for j in range(m + 1):\\n if i == 0 or j == 0:\\n lcs_array[i][j] = 0\\n elif s1[i - 1] == s2[j - 1]:\\n lcs_array[i][j] = lcs_array[i - 1][j - 1] + 1\\n else:\\n lcs_array[i][j] = max(lcs_array[i - 1][j], lcs_array[i][j - 1])\\n return lcs_array\",\n \"def test_lcs_adjectives(id1, id2, expected_ids):\\n syn1 = germanet_data.get_synset_by_id(id1)\\n syn2 = germanet_data.get_synset_by_id(id2)\\n lcs = syn1.lowest_common_subsumer(syn2)\\n np.testing.assert_equal(sorted([l.id for l in lcs]), sorted(expected_ids))\",\n \"def overlap(string_one: str, string_two: str):\\n len_s_one = len(string_one)\\n len_s_two = len(string_two)\\n\\n # Content of the tuple => (start_index, stop_index, string from start_index to stop_index)\\n largest_overlap = {\\\"suffix_string\\\": string_one,\\n \\\"prefix_string\\\": string_two,\\n \\\"overlap\\\": None,\\n \\\"weight\\\": 0}\\n len_overlap = 0\\n # Iterate over every suffix from string one from right to left\\n for i in range(len_s_one, 0, -1):\\n # Current suffix from string one\\n current_suffix_one = string_one[i - 1:len_s_one]\\n\\n # Iterate over every prefix of string two from left to right\\n for j in range(len_s_two + 1):\\n current_prefix_two = string_two[:j]\\n if current_suffix_one == current_prefix_two:\\n tmp_len = len(current_prefix_two)\\n if tmp_len > len_overlap:\\n len_overlap = tmp_len\\n\\n largest_overlap[\\\"suffix_start\\\"] = i - 1\\n largest_overlap[\\\"suffix_end\\\"] = len_s_one\\n\\n largest_overlap[\\\"prefix_start\\\"] = 0\\n largest_overlap[\\\"prefix_end\\\"] = j\\n\\n largest_overlap[\\\"weight\\\"] = tmp_len\\n largest_overlap[\\\"overlap\\\"] = current_suffix_one\\n return largest_overlap\",\n \"def compare(seq1, seq2):\\n if seq1 == seq2:\\n return 1\\n len_diff = len(seq1) / len(seq2)\\n if len_diff > 1:\\n len_diff = 1 / len_diff\\n\\n ngrams1 = {tuple(ng) for ng in get_all_ngrams(seq1)}\\n ngrams2 = {tuple(ng) for ng in get_all_ngrams(seq2)}\\n\\n overall = len(ngrams1 & ngrams2) / len(ngrams1 | ngrams2)\\n if overall == 1 or overall == 0:\\n return overall\\n\\n try:\\n max_match = len(max(ngrams1 & ngrams2, key=len)) / len(seq1)\\n except ValueError:\\n return 0\\n\\n return (len_diff + max_match + overall) / 3\",\n \"def get_longest_paths(nodes, graph):\\n paths = []\\n distances = []\\n possible_paths = list(combinations(nodes, r=2))\\n for node1, node2 in possible_paths:\\n try:\\n path = nx.shortest_path(graph, node1, node2, \\\"weight\\\")\\n except Exception,e:\\n path = []\\n if len(path)>1:\\n distance = get_path_distance(path, graph)\\n paths.append(path)\\n distances.append(distance)\\n paths_sorted = [x for (y,x) in sorted(zip(distances, paths), reverse=True)]\\n # longest_path = paths_sorted[0]\\n # return longest_path\\n return paths_sorted\",\n \"def lcs_pairwise(s1: str, s2: str, k: int, length: int):\\n\\n for i in range(0, len(s1) - length + 1):\\n for j in range(0, len(s2) - length + 1):\\n sub1 = s1[i: i + length]\\n sub2 = s2[j: j + length]\\n result = pairwise2.align.globalxx(sub1, sub2)\\n if result[0][2] >= length - k - 1:\\n print(str(i) + \\\" \\\" + str(j) + \\\" \\\" + str(length - result[0][2]) + \\\" \\\" +\\n sub1 + \\\" \\\" + sub2, end=\\\"\\\\t\\\")\\n else:\\n print(str(i) + \\\" \\\" + str(j) + \\\" N N N\\\", end=\\\"\\\\t\\\")\\n print(\\\"\\\")\",\n \"def _sequence_overlap(seq1: Sequence, seq2: Sequence):\\n diff = SequenceMatcher(None, seq1, seq2)\\n # Drop last matching block, since this is always a dummy entry, with length=1.\\n return diff.get_matching_blocks()[:-1]\",\n \"def findsegments(id1, seq1, id2, seq2, minlen):\\n\\n segments = \\\"\\\"\\n\\n # Initialize list of corresponding residues.\\n correspondances = []\\n for res in seq1:\\n correspondances.append([])\\n \\n # Main loop.\\n for i in range(len(seq1)-minlen):\\n seg1 = seq1[i:i+minlen]\\n for j in range(len(seq2)-minlen):\\n if j not in correspondances[i]:\\n seg2 = seq2[j:j+minlen]\\n if seg1 == seg2:\\n # Look if the segment is longer than minlen.\\n segments_equal = True\\n prev1 = seg1\\n prev2 = seg2\\n extend = 1\\n while segments_equal == True:\\n i_end = i+minlen+extend\\n j_end = j+minlen+extend\\n ext1 = seq1[i:i_end]\\n ext2 = seq2[j:j_end]\\n if i_end > len(seq1) or j_end > len(seq2):\\n seqend = True\\n else:\\n seqend = False\\n if ext1 != ext2 or seqend == True:\\n segments_equal = False\\n segments += \\\"{} \\\".format(prev1)\\n segments += \\\"{} [{}, {}] \\\".format(id1, i, i_end-2)\\n segments += \\\" \\\"\\n segments += \\\"{} [{}, {}] \\\".format(id2, j, j_end-2)\\n segments += \\\"\\\\n\\\"\\n # Add residues to correspondance list.\\n for k in range(minlen+extend-1):\\n l = i+k\\n m = j+k\\n correspondances[l].append(m)\\n prev1 = ext1\\n prev2 = ext2\\n extend += 1\\n\\n return segments\",\n \"def overlap(g, node_1, node_2):\\n inter = len(set(nx.neighbors(g, node_1)).intersection(set(nx.neighbors(g, node_2))))\\n return float(inter)\",\n \"def real_overlap(from_sequence, to_sequence):\\n sequence_overlap = difflib.SequenceMatcher(None, from_sequence, to_sequence)\\n start = 0\\n start_pos_from = -1\\n start_pos_to = -1\\n size = -1\\n while start_pos_to != 0 or not start_pos_from+size == len(from_sequence):\\n start_pos_from, start_pos_to, size = sequence_overlap.find_longest_match(start, \\\\\\n len(from_sequence), 0, len(to_sequence))\\n if not start_pos_to == 0 or not start_pos_from+size == len(from_sequence):\\n start = start_pos_from+1\\n\\n return size\",\n \"def nlp_merge_common_matches(matches):\\n\\n merged_matches = []\\n\\n for idx_1, start_1, end_1 in matches:\\n\\n curr_idx = idx_1\\n curr_start = start_1\\n curr_end = end_1\\n\\n for idx_2, start_2, end_2 in matches:\\n\\n if (start_2 < curr_start and end_2 > curr_end) or (start_2 <= curr_start and end_2 > curr_end) or (\\n start_2 < curr_start and end_2 >= curr_end):\\n curr_idx = idx_2\\n curr_start = start_2\\n curr_end = end_2\\n\\n merged_matches.append((curr_idx, curr_start, curr_end))\\n\\n return list(set(merged_matches))\",\n \"def longestCommonPrefix(self, strs: List[str]) -> str:\\r\\n common = \\\"\\\"\\r\\n if not strs:\\r\\n return common\\r\\n shortest_str = min(strs, key=len)\\r\\n for i in range(len(shortest_str)):\\r\\n char = shortest_str[i]\\r\\n for item in strs:\\r\\n if item[i] != char:\\r\\n return common\\r\\n common += char\\r\\n return common\",\n \"def dameraulevenshtein(seq1, seq2):\\n # Conceptually, this is based on a len(seq1) + 1 * len(seq2) + 1 matrix.\\n # However, only the current and two previous rows are needed at once,\\n # so we only store those.\\n oneago = None\\n thisrow = list(range(1, len(seq2) + 1)) + [0]\\n for x in range(len(seq1)):\\n # Python lists wrap around for negative indices, so put the\\n # leftmost column at the *end* of the list. This matches with\\n # the zero-indexed strings and saves extra calculation.\\n twoago, oneago, thisrow = oneago, thisrow, [0] * len(seq2) + [x + 1]\\n for y in range(len(seq2)):\\n delcost = oneago[y] + 1\\n addcost = thisrow[y - 1] + 1\\n subcost = oneago[y - 1] + (seq1[x] != seq2[y])\\n thisrow[y] = min(delcost, addcost, subcost)\\n # This block deals with transpositions\\n if (x > 0 and y > 0 and seq1[x] == seq2[y - 1]\\n and seq1[x-1] == seq2[y] and seq1[x] != seq2[y]):\\n thisrow[y] = min(thisrow[y], twoago[y - 2] + 1)\\n return thisrow[len(seq2) - 1]\",\n \"def find_largest_overlaps(string_one, string_two):\\n two_overlaps_suffix_one = overlap(string_one, string_two)\\n one_overlaps_suffix_two = overlap(string_two, string_one)\\n\\n return two_overlaps_suffix_one, one_overlaps_suffix_two\",\n \"def optimal_string_alignment_distance(s1, s2):\\n\\n utils.check_for_none(s1, s2)\\n utils.check_for_type(str, s1, s2)\\n\\n # s1 = utils.unicode_normalize(s1)\\n # s2 = utils.unicode_normalize(s2)\\n\\n n1, n2 = len(s1), len(s2)\\n\\n dp = [[0] * (n2 + 1) for _ in range(n1 + 1)]\\n\\n for i in range(0, n1 + 1):\\n dp[i][0] = i\\n for j in range(0, n2 + 1):\\n dp[0][j] = j\\n\\n for i in range(1, n1 + 1):\\n for j in range(1, n2 + 1):\\n cost = 0 if s1[i - 1] == s2[j - 1] else 1\\n\\n dp[i][j] = min(dp[i][j - 1] + 1,\\n dp[i - 1][j] + 1,\\n dp[i - 1][j - 1] + cost)\\n\\n if i > 1 and j > 1 and s1[i - 1] == s2[j - 2] and s1[i - 2] == s2[j - 1]:\\n dp[i][j] = min(dp[i][j], dp[i - 2][j - 2] + cost)\\n\\n return dp[n1][n2]\",\n \"def sm_longest_match(s1,s2):\\n anslist=[]\\n match = SM(None, s1, s2).find_longest_match(0, len(s1), 0, len(s2))\\n match_pat = s1[match.a: match.a + match.size]\\n while match.size > 1:\\n anslist.append( (match_pat, match.a) )\\n\\n #replace match pattern from string\\n s1=s1.replace(match_pat,'')\\n s2 = s2.replace(match_pat, '')\\n\\n match = SM(None, s1, s2).find_longest_match(0, len(s1), 0, len(s2))\\n\\n match_pat = s1[match.a: match.a + match.size]\\n\\n return anslist\",\n \"def m_longest_common_subsequence_3(iterable):\\n lst = list(iterable)\\n\\n lcs = lst[0]\\n for string in lst[1:]:\\n lcs = all_lcs(lcs, string).pop() # TODO select a LCS instead of popping the last one\\n\\n return lcs\",\n \"def lcs_len(x, y):\\r\\n \\r\\n if len(x) == 0 or len(y) == 0:\\r\\n return 0\\r\\n \\r\\n xx = x[:-1] # xx = sequence x without its last element \\r\\n yy = y[:-1]\\r\\n \\r\\n if x[-1] == y[-1]: # if last elements of x and y are equal\\r\\n return lcs_len(xx, yy) + 1\\r\\n else:\\r\\n return max(lcs_len(xx, y), lcs_len(x, yy))\",\n \"def find_longest_common_prefix(words:list):\\n trie = Trie(words)\\n\\n head = trie.head\\n\\n prefix = []\\n\\n while len(head) == 1 and trie.eof not in head:\\n key, value = head.popitem()\\n prefix.append(key)\\n head = value\\n \\n return \\\"\\\".join(prefix)\",\n \"def get_overlap(a, b):\\n return max(0, min(a[1], b[1]) - max(a[0], b[0]))\",\n \"def longest_common_substring_backtrack(s1, s2, i, j, count):\\n if i == len(s1) or j == len(s2):\\n return 0\\n\\n if s1[i-1] == s2[j-1]:\\n count = 1 + longest_common_substring_backtrack(s1, s2, i+1, j+1, count)\\n\\n else:\\n count = max(count,\\n max(longest_common_substring_backtrack(s1, s2, i+1, j, count),\\n longest_common_substring_backtrack(s1, s2, i, j+1, count)))\\n\\n return count\",\n \"def compare_two_grids( treecode1, treecode2 ):\\n import numpy as np\\n\\n common_blocks = 0\\n\\n for i in range(treecode1.shape[0]):\\n # we look for this tree code in the second array\\n code1 = treecode1[i,:]\\n\\n for j in range(treecode2.shape[0]):\\n code2 = treecode2[j,:]\\n if np.linalg.norm( code2-code1 ) < 1.0e-13:\\n # found code1 in the second array\\n common_blocks += 1\\n break\\n\\n print( \\\"Nblocks1=%i NBlocks2=%i common blocks=%i\\\" % (treecode1.shape[0], treecode2.shape[0], common_blocks) )\\n\\n return common_blocks / treecode1.shape[0]\",\n \"def lcs_similarity(s1, s2):\\n max_len = 0\\n i = 0\\n\\n while s1[i] == s2[i]:\\n max_len += 1\\n i += 1\\n if len(s1) == i or len(s2) == i:\\n break\\n\\n if len(s1) < len(s2):\\n return float(max_len) / len(s2)\\n else:\\n return float(max_len) / len(s1)\",\n \"def longest_common_substring_memoization(s1, s2, i, j, count, cache):\\n\\n if i == len(s1) or j == len(s2):\\n return 0\\n\\n if cache[i][j] != -1:\\n return cache[i][j]\\n\\n if s1[i-1] == s2[j-1]:\\n count = 1 + longest_common_substring_memoization(s1, s2, i+1, j+1, count, cache)\\n\\n else:\\n count = max(count,\\n max(longest_common_substring_memoization(s1, s2, i+1, j, count, cache),\\n longest_common_substring_memoization(s1, s2, i, j+1, count, cache)))\\n\\n cache[i][j] = count\\n return cache[i][j]\",\n \"def solve(self, cipher):\\r\\n a, b = cipher\\r\\n m = len(a)\\r\\n n = len(b)\\r\\n dp = [[0 for _ in xrange(n+1)] for _ in xrange(m+1)]\\r\\n for i in xrange(1, m+1):\\r\\n for j in xrange(1, n+1):\\r\\n if a[i-1]==b[j-1]:\\r\\n dp[i][j] = dp[i-1][j-1]+1\\r\\n else:\\r\\n dp[i][j] = max(dp[i][j-1], dp[i-1][j]) # superset\\r\\n return dp[-1][-1]\",\n \"def common_count(self, node_1, node_2):\\n return int(len(set(nx.neighbors(self.graph, node_1)).intersection(set(nx.neighbors(self.graph, node_2)))))\",\n \"def commonCharacterCount(s1, s2):\\n return sum(min(s1.count(x),s2.count(x)) for x in set(s1))\",\n \"def overlap_len(range1, range2):\\n return min(range1[1], range2[1]) - max(range1[0], range2[0])\",\n \"def test_lcs_verbs(id1, id2, expected_ids):\\n syn1 = germanet_data.get_synset_by_id(id1)\\n syn2 = germanet_data.get_synset_by_id(id2)\\n lcs = syn1.lowest_common_subsumer(syn2)\\n np.testing.assert_equal(sorted([l.id for l in lcs]), sorted(expected_ids))\",\n \"def lcs(a, b):\\n # This is an adaptation of the standard LCS dynamic programming algorithm\\n # tweaked for lower memory consumption.\\n # Sequence a is laid out along the rows, b along the columns.\\n # Minimize number of columns to minimize required memory\\n if len(a) < len(b):\\n a, b = b, a\\n # Sequence b now has the minimum length\\n # Quit early if one sequence is empty\\n if len(b) == 0:\\n return 0\\n # Use a single buffer to store the counts for the current row, and\\n # overwrite it on each pass\\n row = [0] * len(b)\\n for ai in a:\\n left = 0\\n diag = 0\\n for j, bj in enumerate(b):\\n up = row[j]\\n if ai == bj:\\n value = diag + 1\\n else:\\n value = max(left, up)\\n row[j] = value\\n left = value\\n diag = up\\n # Return the last cell of the last row\\n return left\",\n \"def common_suffix(s1, s2):\\n if not s1 or not s2:\\n return None\\n # revert the seqs and get a common prefix\\n common = common_prefix(s1[::-1], s2[::-1])\\n # revert back\\n if common:\\n return common[::-1]\\n else:\\n return common\",\n \"def mergeSeq(left, right):\\n i = j = 0\\n result = []\\n while i < len(left) and j < len(right):\\n if left[i] <= right[j]:\\n result.append(left[i])\\n i += 1\\n else:\\n result.append(right[j])\\n j += 1\\n\\n result += left[i:]\\n result += right[j:]\\n return result\",\n \"def find_lowest_common_decendent(graph, a, b):\\n\\n assert nx.is_directed_acyclic_graph(graph), \\\"Graph has to be acyclic and directed.\\\"\\n\\n # get ancestors of both (intersection)\\n common_ancestors = list(nx.descendants(graph, a) & nx.descendants(graph, b))\\n\\n # get sum of path lengths\\n sum_of_path_lengths = np.zeros((len(common_ancestors)))\\n for ii, c in enumerate(common_ancestors):\\n sum_of_path_lengths[ii] = nx.shortest_path_length(graph, a, c) \\\\\\n + nx.shortest_path_length(graph, b, c)\\n\\n # print common_ancestors\\n # print sum_of_path_lengths\\n\\n # return minima\\n try:\\n minima, = np.where(sum_of_path_lengths == np.min(sum_of_path_lengths))\\n return [common_ancestors[ii] for ii in minima]\\n except ValueError:\\n return -1\",\n \"def longestStrChain_wrong(self, words) -> int:\\n\\n # sort list based on length\\n words_dict = {}\\n for i in words:\\n l = len(i)\\n if l not in words_dict.keys():\\n words_dict[l] = [i]\\n else:\\n words_dict[l].append(i)\\n word_sort = sorted([(i, j) for i, j in words_dict.items()], key=lambda x: x[0])\\n #print(word_sort)\\n\\n roots = [Node(i) for i in word_sort[0][1]]\\n pre_roots = roots\\n cur_roots = []\\n for _, word_list in word_sort[1:]:\\n cur_roots = []\\n for i in pre_roots:\\n child = [Node(x) for x in word_list if self.is_predecessor(i.val, x)]\\n i.child = child\\n cur_roots += child\\n pre_roots = cur_roots\\n print(f'layer={_}, list: {word_list}, cur_roots={[x.val for x in cur_roots]}')\\n\\n return self.run_list(roots)\",\n \"def commonlen(s1, s2):\\n # given \\\"hi\\\", \\\"hip\\\"\\n # izip_longest(\\\"hi\\\", \\\"hip\\\") -> ('h','h'), ('i','i'), (None, 'p')\\n # enumerate -> (0,('h','h')), (1,('i','i')), (2,(None, 'p'))\\n # dropwhile(lambda (i,(x,y)): x == 5 -> (2,(None,'p')) ...\\n try:\\n return itertools.dropwhile(\\n lambda (i, (x, y)): x == y, enumerate(zip(s1, s2))).next()[0]\\n except StopIteration:\\n # strings are identical return the len of one of them\\n return len(s1)\",\n \"def damerau_levenshtein_distance(s1, s2):\\n\\n utils.check_for_none(s1, s2)\\n utils.check_for_type(str, s1, s2)\\n\\n # s1 = utils.unicode_normalize(s1)\\n # s2 = utils.unicode_normalize(s2)\\n\\n n1, n2 = len(s1), len(s2)\\n infinite = n1 + n2\\n\\n char_arr = defaultdict(int)\\n dp = [[0] * (n2 + 2) for _ in range(n1 + 2)]\\n\\n dp[0][0] = infinite\\n for i in range(0, n1 + 1):\\n dp[i + 1][0] = infinite\\n dp[i + 1][1] = i\\n for i in range(0, n2 + 1):\\n dp[0][i + 1] = infinite\\n dp[1][i + 1] = i\\n\\n for i in range(1, n1 + 1):\\n db = 0\\n for j in range(1, n2 + 1):\\n i1 = char_arr[s2[j - 1]]\\n j1 = db\\n cost = 1\\n if s1[i - 1] == s2[j - 1]:\\n cost = 0\\n db = j\\n\\n dp[i + 1][j + 1] = min(dp[i][j] + cost,\\n dp[i + 1][j] + 1,\\n dp[i][j + 1] + 1,\\n dp[i1][j1] + (i - i1 - 1) + 1 + (j - j1 - 1))\\n char_arr[s1[i - 1]] = i\\n\\n return dp[n1 + 1][n2 + 1]\",\n \"def shortest(self, word1, word2):\\n a, b = self.d[word1], self.d[word2]\\n m, n, i, j, res = len(a), len(b), 0, 0, float('inf')\\n while i < m and j < n:\\n res = min(res, abs(a[i] - b[j]))\\n if a[i] > b[j]:\\n j += 1\\n else:\\n i += 1\\n return res\",\n \"def common_token_len(self, w1, d1, w2, d2):\\n w1_tk = set(self.__stem_Tokens(w1))\\n w2_tk = set(self.__stem_Tokens(w2))\\n common_len = len(w1_tk.intersection(w2_tk))\\n return common_len\",\n \"def _find_common_tail(self, l1, l2):\\n i = -1\\n try:\\n while l1[i] == l2[i]:\\n i -= 1\\n except IndexError:\\n # One list is the tail of the other\\n pass\\n # i now gives the last differing element\\n assert i < -1\\n return i+1\",\n \"def remove_common(first: list, second: list):\\n return list(set(first)-set(second))\",\n \"def calculate_overlap(self, r1, r2):\\n\\n # We know that reads that can be glued,\\n # share at least half of their length.\\n # Make sure one is not shorter than\\n # the half of another.\\n\\n if len(r1) / 2 + len(r1) % 2 <= len(r2) \\\\\\n and len(r2) / 2 + len(r2) % 2 <= len(r1):\\n\\n # prepare second halves for overlap pre-check\\n\\n tail1 = r1[len(r1) / 2:]\\n tail2 = r2[len(r2) / 2:]\\n \\n # case 1: r1 contains r2 completely\\n #\\n # For example,\\n #\\n # ATCGCCGGAT\\n # TCGCCGGA\\n \\n pos = r1.find(r2)\\n if pos != -1:\\n self.reads[r1].overlaps[r2] = pos + len(r2) - len(r1)\\n \\n # case 2: r2 contains r1 completely\\n #\\n # For example,\\n #\\n # TCGCCGGA\\n # ATCGCCGGAT\\n \\n pos = r2.find(r1)\\n if pos != -1:\\n self.reads[r2].overlaps[r1] = pos + len(r1) - len(r2)\\n \\n # case 3: end of r1 overlaps with beginning of r2\\n #\\n # For example,\\n #\\n # ATCGCCGGAT\\n # TCGCCGGATGC\\n #\\n # First check that at least half of r1 is in r2\\n # If there is a match, calculate the expected length \\n # of overlap and check if they indeed overlap.\\n\\n \\n pos = r2.find(tail1)\\n if pos != -1:\\n overlap = pos + len(tail1)\\n if r1[-overlap:] == r2[:overlap]:\\n self.reads[r1].overlaps[r2] = len(r2) - overlap\\n \\n # case 4: end of r2 overlaps with beginning of r1\\n #\\n # For example,\\n #\\n # CGCCGGATCC\\n # TCGCCGGAT\\n #\\n # First check that at least half of r2 is in r1\\n # If there is a match, calculate the expected length \\n # of overlap and check if they indeed overlap.\\n \\n pos = r1.find(tail2)\\n if pos != -1: \\n overlap = pos + len(tail2)\\n if r2[-overlap:] == r1[:overlap]:\\n self.reads[r2].overlaps[r1] = len(r1) - overlap\",\n \"def get_similarity(s1, s2):\\n t0 = sorted(list(set(s1.split(' ')).intersection(set(s2.split(' ')))))\\n t1 = sorted(list(set(t0 + s1.split(' '))))\\n t2 = sorted(list(set(t0 + s2.split(' '))))\\n\\n r01 = SequenceMatcher(None, t0, t1).ratio()\\n r02 = SequenceMatcher(None, t0, t2).ratio()\\n r12 = SequenceMatcher(None, t1, t2).ratio()\\n return max(r01, r02, r12)\",\n \"def compSeq(s1, s2, lineL=50):\\n lineN = int(np.ceil(min(len(s1), len(s2))/lineL))\\n count = 0\\n samecount = 0\\n outStr = ''\\n for linei in range(lineN):\\n if (linei+1) * lineL < min(len(s1), len(s2)):\\n end = (linei+1) * lineL\\n else:\\n end = min(len(s1), len(s2))\\n outStr += 'Pos %d - %d\\\\n' % (linei*lineL+1, end-1+1)\\n for sitei in range(linei*lineL, end):\\n outStr += s1[sitei]\\n outStr += '\\\\n'\\n for sitei in range(linei*lineL, end):\\n out = ' ' if s1[sitei] == s2[sitei] else '|'\\n outStr += out\\n count += 1\\n samecount += 1 if s1[sitei]==s2[sitei] else 0\\n outStr += '\\\\n'\\n for sitei in range(linei*lineL, end):\\n out = '.' if s1[sitei] == s2[sitei] else s2[sitei]\\n outStr += s2[sitei]\\n outStr += '\\\\n\\\\n'\\n outStr += 'Seq1 (%d) and Seq2 (%d) are %1.1f%% similar\\\\n\\\\n' % (len(s1), len(s2), 1e2*samecount/count)\\n print(outStr)\",\n \"def _recon_lcs(x, y):\\n i, j = len(x), len(y)\\n table = _lcs(x, y)\\n\\n def _recon(i, j):\\n \\\"\\\"\\\"private recon calculation\\\"\\\"\\\"\\n if i == 0 or j == 0:\\n return []\\n elif x[i - 1] == y[j - 1]:\\n return _recon(i - 1, j - 1) + [(x[i - 1], i)]\\n elif table[i - 1, j] > table[i, j - 1]:\\n return _recon(i - 1, j)\\n else:\\n return _recon(i, j - 1)\\n\\n recon_tuple = tuple(map(lambda x: x[0], _recon(i, j)))\\n return recon_tuple\",\n \"def overlapping_ranges(\\n ranges_1: Sequence[Tuple[int, int]],\\n ranges_2: Sequence[Tuple[int, int]],\\n) -> List[Tuple[int, int]]:\\n return [\\n (max(first[0], second[0]), min(first[1], second[1]))\\n for first in ranges_1\\n for second in ranges_2\\n if max(first[0], second[0]) < min(first[1], second[1])\\n ]\",\n \"def compute_keysets(left_seq, right_seq):\\n assert isinstance(left_seq, type(right_seq)), (left_seq, right_seq)\\n assert type(left_seq) in NONTERMINALS, left_seq\\n\\n if type(left_seq) is dict:\\n left_keyset = set(left_seq.keys())\\n right_keyset = set(right_seq.keys())\\n else:\\n left_keyset = set(range(len(left_seq)))\\n right_keyset = set(range(len(right_seq)))\\n\\n overlap = left_keyset.intersection(right_keyset)\\n left_only = left_keyset - right_keyset\\n right_only = right_keyset - left_keyset\\n\\n return overlap, left_only, right_only\",\n \"def find_overlap_range(x1, lenght1, x2, length2):\\n\\n\\n highest_start_point = max(x1, x2)\\n lowest_end_point = min(x1 + lenght1, x2 + length2)\\n \\n if highest_start_point >= lowest_end_point:\\n return None\\n \\n overlap_length = lowest_end_point - highest_start_point\\n \\n return (highest_start_point, overlap_length)\",\n \"def rgenerate(allele1, allele2, min_length, max_length):\\n from .models import Primer\\n\\n if len(allele1) != len(allele2):\\n raise ValueError('Aligned alleles must be the same length.')\\n\\n allele1 = str(allele1)\\n allele2 = str(allele2)\\n candidates = []\\n\\n for size in range(min_length, max_length+1):\\n allele1_span = (0, size)\\n allele2_span = (0, size)\\n\\n for i in range(len(allele1)-size):\\n if allele1[i:i+size] == allele2[i:i+size]:\\n candidates.append(Primer(sequence=allele1[i:i+size],\\n allele1_span=allele1_span,\\n allele2_span=allele2_span,\\n strand=1))\\n\\n if allele1[i] != '-':\\n allele1_span = (allele1_span[0]+1, allele1_span[1]+1)\\n\\n if allele2[i] != '-':\\n allele2_span = (allele2_span[0]+1, allele2_span[1]+1)\\n\\n return candidates\",\n \"def sorted_intersect(self, list1, list2):\\n ### Begin your code\\n result = []\\n p1 = 0\\n p2 = 0\\n s1 = int(math.sqrt(len(list1)))\\n s2 = int(math.sqrt(len(list2)))\\n while (p1 < len(list1) and p2 < len(list2)):\\n if list1[p1] == list2[p2]:\\n result.append(list1[p1])\\n p1 = p1 + 1\\n p2 = p2 + 1\\n elif list1[p1] < list2[p2]:\\n if (p1 + s1 >= len(list1) or list1[p1 + s1] > list2[p2]):\\n p1 = p1 + 1\\n else:\\n p1 = p1 + s1\\n else:\\n if (p2 + s2 >= len(list2) or list2[p2 + s2] > list2[p2]):\\n p2 = p2 + 1\\n else:\\n p2 = p2 + s2\\n # print(result)\\n return result\\n ### End your code\",\n \"def commonality(left_struc, right_struc):\\n assert type(left_struc) is type(right_struc), (left_struc, right_struc)\\n assert left_struc and right_struc, (left_struc, right_struc)\\n if type(left_struc) is dict:\\n (overlap, left, right) = compute_keysets(left_struc, right_struc)\\n com = float(len(overlap))\\n tot = len(overlap.union(left, right))\\n else:\\n assert type(left_struc) in (list, tuple), left_struc\\n com = 0.0\\n for elem in left_struc:\\n if elem in right_struc:\\n com += 1\\n tot = max(len(left_struc), len(right_struc))\\n\\n return com / tot\",\n \"def get_synset_overlap(sentence_a, sentence_b):\\n def synsets(word):\\n sense_lemmas = []\\n for pos in ('n'):#,'a'):\\n for i in xrange(5):\\n try:\\n sense_lemmas += [lemma.name \\n for lemma in wn.synset('{0}.{1}.0{2}'.format(word, pos, i)).lemmas]\\n except WordNetError: \\n pass\\n return sense_lemmas\\n\\n a_set = set(lemma for word in sentence_a for lemma in synsets(word))\\n b_set = set(lemma for word in sentence_b for lemma in synsets(word))\\n score = len(a_set&b_set)/float(len(a_set|b_set))\\n \\n return score\",\n \"def compare_words(word1, word2):\\n word1 = word1.lower()\\n word2 = word2.lower()\\n seg_scores = []\\n if len(word1) >= len(word2):\\n for i in range(0, len(word1) - len(word2) + 1):\\n seg_scores.append(find_difference(word1[i:i+len(word2)], word2))\\n else:\\n for i in range(0, len(word2) - len(word1) + 1):\\n seg_scores.append(find_difference(word2[i:i+len(word1)], word1))\\n return round(min(seg_scores) + abs(len(word1) - len(word2))/float(len(max([word1, word2]))),2)\",\n \"def test_maximum_common_subgraph(graph1, graph2, attrs):\\n expected = vermouth.graph_utils.categorical_maximum_common_subgraph(graph1, graph2, attrs)\\n\\n found = vermouth.graph_utils.maximum_common_subgraph(graph1, graph2, attrs)\\n\\n note((\\\"Attributes that must match\\\", attrs))\\n note((\\\"Graph 1 nodes\\\", graph1.nodes(data=True)))\\n note((\\\"Graph 1 edges\\\", graph1.edges))\\n note((\\\"Graph 2 nodes\\\", graph2.nodes(data=True)))\\n note((\\\"Graph 2 edges\\\", graph2.edges))\\n # We don't find all MCS'es. See comment in\\n # vermouth.graph_utils.maximum_common_subgraph\\n found = make_into_set(found)\\n expected = make_into_set(expected)\\n\\n if found == expected:\\n event(\\\"Exact match\\\")\\n assert found <= expected\",\n \"def lcs_dp(strA, strB):\\n rows = len(strA) + 1\\n cols = len(strB) + 1\\n dp_table = [[0 for j in range(cols)] for i in range(rows)]\\n\\n for row in range(1, rows):\\n for col in range(1, cols):\\n if strA[row - 1] == strB[col - 1]:\\n dp_table[row][col] = dp_table[row - 1][col - 1] + 1\\n else:\\n dp_table[row][col] = max(dp_table[row][col - 1], dp_table[row - 1][col])\\n return dp_table[rows-1][cols-1]\",\n \"def merge(first, second, reverse):\\r\\n final = [0]*(len(first)+len(second))\\r\\n i = 0\\r\\n j = 0\\r\\n if reverse:\\r\\n while i+j < len(final):\\r\\n if (j >= len(second)) or ((i < len(first)) and (first[i] > second[j])):\\r\\n final[i+j] = first[i]\\r\\n i += 1\\r\\n else:\\r\\n final[i+j] = second[j]\\r\\n j += 1\\r\\n else:\\r\\n while i+j < len(final):\\r\\n if (j >= len(second)) or ((i < len(first)) and (first[i] < second[j])):\\r\\n final[i+j] = first[i]\\r\\n i += 1\\r\\n else:\\r\\n final[i+j] = second[j]\\r\\n j += 1\\r\\n return final\",\n \"def _recon_lcs(x, y):\\n i, j = len(x), len(y)\\n table = _lcs(x, y)\\n\\n def _recon(i, j):\\n \\\"\\\"\\\"private recon calculation\\\"\\\"\\\"\\n if i == 0 or j == 0:\\n return []\\n elif x[i - 1] == y[j - 1]:\\n return _recon(i - 1, j - 1) + [(x[i - 1], i)]\\n elif table[i - 1, j] > table[i, j - 1]:\\n return _recon(i - 1, j)\\n else:\\n return _recon(i, j - 1)\\n\\n recon_tuple = tuple(map(lambda x: x[0], _recon(i, j)))\\n return recon_tuple\",\n \"def merge(arr1, arr2):\\n i = 0\\n j = 0\\n sol = []\\n while i < len(arr1) and j < len(arr2):\\n if arr1[i] <= arr2[j]:\\n sol.append(arr1[i])\\n i += 1\\n else:\\n sol.append(arr2[j])\\n j += 1\\n if i < len(arr1):\\n sol.extend(arr1[i:])\\n if j < len(arr2):\\n sol.extend(arr2[j:])\\n return sol\",\n \"def lcs_recursion(str1, str2):\\n if len(str1) == 0 or len(str2) == 0:\\n return \\\"\\\"\\n if str1[0] == str2[0]:\\n return str1[0] + lcs_recursion(str1[1:], str2[1:])\\n else:\\n r1 = lcs_recursion(str1,str2[1:])\\n r2 = lcs_recursion(str1[1:],str2)\\n r = r1 if len(r1) > len(r2) else r2\\n return r\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.7247269","0.71503085","0.69920135","0.6895138","0.68178797","0.6648128","0.64169645","0.63929033","0.6190487","0.6148989","0.6120559","0.6112058","0.6086676","0.6060063","0.6056009","0.5992014","0.5970511","0.59483576","0.5925975","0.5925972","0.59207815","0.586819","0.5860247","0.5823824","0.5787988","0.57032466","0.5682568","0.56608975","0.56586295","0.5657077","0.5643914","0.5635257","0.56245893","0.56044084","0.5598824","0.55985296","0.55981684","0.5586851","0.5576294","0.5570442","0.5570442","0.5565154","0.5560244","0.55568284","0.55402195","0.5523614","0.5522172","0.5518216","0.55054134","0.54980963","0.54912466","0.54902226","0.54784596","0.5475136","0.54565907","0.54508245","0.54458237","0.54383683","0.54368275","0.5430448","0.5430423","0.542899","0.5418215","0.54010016","0.53859264","0.5379279","0.53786844","0.53509545","0.5340342","0.5337548","0.5333642","0.5329048","0.53084975","0.5302469","0.53002805","0.5298814","0.5297903","0.5278877","0.52780175","0.52757066","0.5274968","0.52687913","0.5267748","0.5267648","0.52659935","0.52582973","0.52559257","0.52429086","0.5238278","0.52381027","0.522362","0.52223796","0.521377","0.5202428","0.52014285","0.52011114","0.51947343","0.51913536","0.5187205","0.5183042"],"string":"[\n \"0.7247269\",\n \"0.71503085\",\n \"0.69920135\",\n \"0.6895138\",\n \"0.68178797\",\n \"0.6648128\",\n \"0.64169645\",\n \"0.63929033\",\n \"0.6190487\",\n \"0.6148989\",\n \"0.6120559\",\n \"0.6112058\",\n \"0.6086676\",\n \"0.6060063\",\n \"0.6056009\",\n \"0.5992014\",\n \"0.5970511\",\n \"0.59483576\",\n \"0.5925975\",\n \"0.5925972\",\n \"0.59207815\",\n \"0.586819\",\n \"0.5860247\",\n \"0.5823824\",\n \"0.5787988\",\n \"0.57032466\",\n \"0.5682568\",\n \"0.56608975\",\n \"0.56586295\",\n \"0.5657077\",\n \"0.5643914\",\n \"0.5635257\",\n \"0.56245893\",\n \"0.56044084\",\n \"0.5598824\",\n \"0.55985296\",\n \"0.55981684\",\n \"0.5586851\",\n \"0.5576294\",\n \"0.5570442\",\n \"0.5570442\",\n \"0.5565154\",\n \"0.5560244\",\n \"0.55568284\",\n \"0.55402195\",\n \"0.5523614\",\n \"0.5522172\",\n \"0.5518216\",\n \"0.55054134\",\n \"0.54980963\",\n \"0.54912466\",\n \"0.54902226\",\n \"0.54784596\",\n \"0.5475136\",\n \"0.54565907\",\n \"0.54508245\",\n \"0.54458237\",\n \"0.54383683\",\n \"0.54368275\",\n \"0.5430448\",\n \"0.5430423\",\n \"0.542899\",\n \"0.5418215\",\n \"0.54010016\",\n \"0.53859264\",\n \"0.5379279\",\n \"0.53786844\",\n \"0.53509545\",\n \"0.5340342\",\n \"0.5337548\",\n \"0.5333642\",\n \"0.5329048\",\n \"0.53084975\",\n \"0.5302469\",\n \"0.53002805\",\n \"0.5298814\",\n \"0.5297903\",\n \"0.5278877\",\n \"0.52780175\",\n \"0.52757066\",\n \"0.5274968\",\n \"0.52687913\",\n \"0.5267748\",\n \"0.5267648\",\n \"0.52659935\",\n \"0.52582973\",\n \"0.52559257\",\n \"0.52429086\",\n \"0.5238278\",\n \"0.52381027\",\n \"0.522362\",\n \"0.52223796\",\n \"0.521377\",\n \"0.5202428\",\n \"0.52014285\",\n \"0.52011114\",\n \"0.51947343\",\n \"0.51913536\",\n \"0.5187205\",\n \"0.5183042\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.75042135"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":89894,"cells":{"query":{"kind":"string","value":"Converts matched pairs of indices in sorted_small_nodes and sorted_large_nodes into matched pairs of nodeids."},"document":{"kind":"string","value":"def get_matched_nodeids_from_orderids(sorted_small_nodes, sorted_large_nodes, matched_orderids):\n orderid2nodeid_func = lambda order_pair: (sorted_small_nodes[order_pair[0]].nodeid, sorted_large_nodes[order_pair[1]].nodeid)\n return list(map(orderid2nodeid_func, matched_orderids))"},"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 get_matching_nodeids(small_dmrs, large_dmrs, all_surface=False):\n sorted_small_nodes = sort_nodes(small_dmrs.nodes)\n sorted_large_nodes = sort_nodes(large_dmrs.nodes)\n\n longest_matches = find_longest_matches(sorted_small_nodes, sorted_large_nodes) # list (of lists) of tuples (id_from_sub, id)\n\n all_matched_nodeids = []\n for match in longest_matches:\n matched_large_orderids = list(zip(*match))[1] # [(order ids from small dmrs), (order ids from the\n paired_nodeids = get_matched_nodeids_from_orderids(sorted_small_nodes, sorted_large_nodes, match)\n if all_surface:\n extra_overlap_nodeids = find_extra_surface_overlap(matched_large_nodeids, sorted_large_nodes)\n paired_nodeids.extend([(None, nodeid) for nodeid in extra_overlap_nodeids])\n all_matched_nodeids.append(paired_nodeids)\n\n return all_matched_nodeids","def compare_nodes(G,all_match_pairs,match_pair,traversed,node1,node2, ports_weight):\n logger.debug(f\"comparing {node1},{node2}, traversed {traversed}\")\n nbrs1 = sorted(set(G.neighbors(node1)) - set(traversed))\n #remove dummies\n nbrs1 = sorted(set([nbr for nbr in nbrs1 if G.get_edge_data(node1, nbr)['weight'] !=7]))\n nbrs2 = sorted(set(G.neighbors(node2)) - set(traversed))\n #remove dummies\n nbrs2 = sorted(set([nbr for nbr in nbrs2 if G.get_edge_data(node2, nbr)['weight'] !=7]))\n logger.debug(f\"node1:{node1},property: {G.nodes[node1]},neigbors1: {nbrs1}\")\n logger.debug(f\"node2:{node2},property: {G.nodes[node2]},neigbors2: {nbrs2}\")\n if not nbrs1 or not nbrs2:\n if compare_two_nodes(G, node1, node2, ports_weight):\n match_pair[node1] = node2\n logger.debug(f\"no new neihbours, returning recursion {match_pair}\")\n return\n elif len(nbrs1)> 10:\n if \"start_point\" in match_pair.keys():\n match_pair[\"start_point\"]+=[node1,node2]\n else:\n match_pair[\"start_point\"]=[node1,node2]\n logger.debug(f\"skipping high fanout nets due to large computation, {node1} {nbrs1}\")\n traversed.append(node1)\n return\n elif len(nbrs2)> 10:\n if \"start_point\" in match_pair.keys():\n match_pair[\"start_point\"]+=[node1,node2]\n else:\n match_pair[\"start_point\"]=[node1,node2]\n traversed.append(node2)\n logger.debug(f\"skipping high fanout nets due to large computation, {node2} {nbrs2}\")\n return\n\n if node1 == node2:\n if node1 in match_pair.keys() or node1 in match_pair.values():\n logger.debug(\"avoid existing pair wise symmetry\")\n return\n logger.debug(f\"single node {node1}, nbrs {nbrs1}, nbr_weight {[G.get_edge_data(node1,nbr) for nbr in nbrs1]}\")\n SD_nbrs= [nbr for nbr in nbrs1 if G.get_edge_data(node1, nbr)['weight'] !=2]\n ## TBD: filter based on primitive constraints\n ## Right now will try to figure out S/D paths\n if len(SD_nbrs) ==0:\n logger.debug(f\"No SD paths found to traverse\")\n match_pair[node1]=node1\n elif len(SD_nbrs) ==1:\n logger.debug(f\"traversing single S/D path {SD_nbrs}\")\n match_pair[node1]=node1\n traversed.append(node1)\n compare_nodes(G,all_match_pairs,match_pair,traversed,SD_nbrs[0],SD_nbrs[0],ports_weight)\n else:\n logger.debug(f\" multiple nodes diverging {SD_nbrs}\")\n logger.debug(f\"nbr weights: {SD_nbrs} {[G.get_edge_data(node1, nbr)['weight'] for nbr in SD_nbrs ]}\")\n match_pair[node1]=node1\n traversed.append(node1)\n new_sp=sorted(set(SD_nbrs)-set(traversed))\n all_match_pairs_local={}\n for nbr1,nbr2 in combinations(new_sp, 2):\n logger.debug(f\"recursive pair call from single branch {nbr1} {nbr2}\")\n new_pair={}\n compare_nodes(G,all_match_pairs,new_pair,traversed.copy(),nbr1,nbr2,ports_weight)\n if new_pair:\n #new_pair[nbr1]=nbr2\n all_match_pairs_local[nbr1+'_'+nbr2] = new_pair\n all_match_pairs_local={k: v for k, v in all_match_pairs_local.items() if len(v)>0}\n if len(all_match_pairs_local)==1:\n match_pair.update( all_match_pairs_local[list(all_match_pairs_local.keys())[0]])\n logger.debug(f\"found inline pair: {pprint.pformat(match_pair, indent=4)}\")\n else:\n for nbr1 in new_sp:\n if (nbr1+'_'+nbr1 not in all_match_pairs.keys()):\n logger.debug(f\"recursive single branch call from single branch {nbr1} {nbr1}\")\n new_pair={}\n compare_nodes(G,all_match_pairs,new_pair,traversed.copy(),nbr1,nbr1,ports_weight)\n #filtering multiple axis of symmetries with same block, ideally they should be handled by array generation\n if new_pair:\n all_match_pairs[nbr1+'_'+nbr1] = new_pair\n logger.debug(f\"updating match pairs: {pprint.pformat(all_match_pairs, indent=4)}\")\n\n\n elif nbrs1 == nbrs2:\n logger.debug(f\"traversing converging branch\")\n match_pair[node1]=node2\n traversed+=[node1,node2]\n nbrs1=sorted(set(nbrs1)-set([node1,node2]))\n logger.debug(f\"all non traversed neighbours: {nbrs1}\")\n if len(nbrs1)==1:\n nbr1=nbr2=nbrs1[0]\n logger.debug(f\"keeping single converged branch inline {nbr1} {nbr2}\")\n compare_nodes(G,all_match_pairs,match_pair,traversed.copy(),nbr1,nbr2,ports_weight)\n else:\n for nbr1,nbr2 in combinations_with_replacement(nbrs1,2):\n logger.debug(f\"recursive call from converged branch {nbr1} {nbr2}\")\n if nbr1+'_'+nbr2 not in all_match_pairs.keys():\n new_pair={}\n compare_nodes(G,all_match_pairs,new_pair,traversed.copy(),nbr1,nbr2,ports_weight)\n #filtering multiple axis of symmetries with same block, ideally they should be handled by array generation\n if new_pair:\n all_match_pairs[nbr1+'_'+nbr2] = new_pair\n logger.debug(f\"updating match pairs: {pprint.pformat(all_match_pairs, indent=4)}\")\n\n\n elif compare_two_nodes(G,node1,node2,ports_weight):\n nbrs1 = sorted(set([nbr for nbr in nbrs1 if G.get_edge_data(node1, nbr)['weight'] !=2]))\n nbrs2 = sorted(set([nbr for nbr in nbrs2 if G.get_edge_data(node2, nbr)['weight'] !=2]))\n match_pair[node1]=node2\n traversed+=[node1,node2]\n logger.debug(f\"Traversing parallel branches from {node1},{node2} {nbrs1}, {nbrs2}\")\n nbrs1_wt = [G.get_edge_data(node1, nbr)['weight'] for nbr in nbrs1]\n nbrs2_wt = [G.get_edge_data(node2, nbr)['weight'] for nbr in nbrs2]\n unique_match=find_unique_matching_branches(G,nbrs1,nbrs2,ports_weight)\n if len(nbrs1)==0 or len(nbrs2)==0:\n logger.debug(f\"no new SD neihbours, returning recursion {match_pair}\")\n elif len(nbrs1) ==1 and len(nbrs2)==1:\n logger.debug(f\"traversing binary branch\")\n compare_nodes(G,all_match_pairs,match_pair,traversed,nbrs1.pop(),nbrs2.pop(),ports_weight)\n elif unique_match:\n logger.debug(f'traversing unique matches {unique_match}')\n match_pair[node1]=node2\n traversed+=[node1,node2]\n for nbr1,nbr2 in unique_match.items():\n logger.debug(f\"recursive call from binary {node1}:{node2} to {nbr1}:{nbr2}\")\n compare_nodes(G,all_match_pairs,match_pair,traversed.copy(),nbr1,nbr2,ports_weight)\n elif len(nbrs1_wt)>len(set(nbrs1_wt))>1 and len(nbrs2_wt)>len(set(nbrs2_wt))>1:\n logger.debug(f\"setting new start points {node1} {node2}\")\n match_pair[node1]=node2\n if \"start_point\" in match_pair.keys():\n match_pair[\"start_point\"]+=[node1,node2]\n else:\n match_pair[\"start_point\"]=[node1,node2]\n else:\n match_pair = {}\n logger.debug(f\"end all traversal from binary branch {node1} {node2}\")\n\n else:\n match_pair = {}\n logger.debug(f\"end of recursion branch, matches {match_pair}\")","def selectCompatibleIndices(bigTimes, smallTimes):\r\n indices = []\r\n for idx, _ in enumerate(smallTimes):\r\n distances = (bigTimes - smallTimes[idx])**2\r\n def getValue(k):\r\n return distances[k]\r\n thisIndices = sorted(range(len(distances)), key=getValue)\r\n indices.append(thisIndices[0])\r\n return np.array(indices)","def find_extra_surface_nodeids(orderids, sorted_large_nodes):\n extra_nodeids = []\n first_overlap_orderid = orderids[0]\n min_cfrom = sorted_nodes[first_overlap_orderid].cfrom\n\n # Check if any earlier nodes also in the region.\n while True:\n prev_cfrom = sorted_nodes[first_overlap_orderid-1].cfrom\n if prev_cfrom == min_cfrom:\n first_overlap_orderid -= 1\n extra_nodeids.append(sorted_nodes[first_overlap_orderid].nodeid)\n else:\n break\n\n # Find the last node in the region.\n last_overlap_orderid = matched_orderids[-1]\n max_cto = sorted_nodes[last_overlap_orderid].cto\n for i in range(first_overlap_orderid, len(sorted_nodes)):\n if sorted_nodes[i].cfrom > max_cto:\n break\n else:\n if i not in orderids:\n extra_nodeids.append(sorted_nodes[i].nodeid)\n cto = sorted_nodes[i].cto\n if cto >= max_cto:\n max_cto = cto\n if i > last_overlap_orderid:\n last_overlap_orderid = i\n\n return extra_nodeids","def _pair_indices(self):\n indices_src = []\n indices_dst = []\n for i in range(self.walk_len):\n for j in range(max(i - self.l, 0), i):\n indices_src.append(i)\n indices_dst.append(j)\n for j in range(i + 1, min(i + self.r + 1, self.walk_len)):\n indices_src.append(i)\n indices_dst.append(j)\n return indices_src, indices_dst","def splitNodes(matching):\n outer = set(range(self.n))\n inner = set([])\n for (u, v) in matching:\n if u in outer:\n outer.remove(u)\n if v in outer:\n outer.remove(v)\n inner.add(u)\n inner.add(v)\n return list(inner), list(outer)","def __find_similar_pairs(self):\n size = len(self.__indexclusters)\n candidates = []\n for i in range(size):\n for j in range(i+1, size):\n simi = self.__cluster_simi(i, j)\n #print simi, self.__indexclusters[i],self.__indexclusters[j]\n if simi >= self.__threshold:\n candidates.append((simi, i, j))\n candidates.sort(reverse = True, key = lambda x: x[0])\n\n\n # filter overlapped pairs\n to_remove = set()\n appeared = set()\n for index, cand in enumerate(candidates):\n if cand[1] not in appeared and cand[2] not in appeared:\n appeared.add(cand[1])\n appeared.add(cand[2])\n else:\n to_remove.add(index)\n\n #print 'ahha'\n #print [(cand[1], cand[2]) for index, cand in enumerate(candidates) if index not in to_remove]\n\n return [(cand[1], cand[2]) for index, cand in enumerate(candidates)\n if index not in to_remove]","def pairs_from_knn(ind):\n \n NN = ind.shape[1]\n source_nodes = np.repeat(ind[:,0], NN-1).reshape(-1,1)\n target_nodes = ind[:,1:].reshape(-1,1)\n pairs = np.hstack((source_nodes, target_nodes))\n pairs = remove_duplicate_pairs(pairs)\n return pairs","def find_longest_matches(sorted_nodes1, sorted_nodes2):\n root = TreeNode(-1,-1)\n fill_tree(root, sorted_nodes1, sorted_nodes2)\n match = find_treepaths(root, [])\n\n # Remove (-1, -1) superroot.\n if isinstance(match[0], list): # More than one match of the same length.\n res = []\n for m in match:\n res.append([node.to_tuple() for node in m[1:]])\n return res\n else:\n return [[node.to_tuple() for node in match[1:]]]","def _gen_matches(target_units, source_units, stoplist_set, features_size):\n for hits2positions in gen_hits2positions(\n target_units, source_units, stoplist_set, features_size):\n overhits2positions = {\n k: np.array(v) for k, v in hits2positions.items()\n if len(v) >= 2}\n for (t_ind, s_ind), positions in overhits2positions.items():\n yield (t_ind, s_ind, positions)","def map_nodes(dist1, dist2, lcnt, op, mode=None):\n # TODO: Modify the functions citing this function, so that we can avoid use \"mode\" in this function.\n # The only difference is the format of dist2\n \n tmp = 0\n map_dict = []\n for i in range(0, lcnt):\n map_dict.append(i)\n \n if mode == None:\n if len(dist1)==len(dist2):\n dist_M = np.zeros((len(dist1), len(dist2)))\n for i in range(0, len(dist1)):\n for j in range(0, len(dist2)):\n dist_M[i,j] = np.linalg.norm(dist1[i]-dist2[j])\n row_ind, col_ind = linear_sum_assignment(dist_M)\n for i in range(0, len(col_ind)):\n map_dict.append(col_ind[i]+lcnt)\n else:\n for i in range(0, len(dist1)):\n idx = find_min_square_dist(dist1[i], dist2, op, map_dict, lcnt)\n map_dict.append(idx+lcnt)\n else:\n if len(dist1)==len(dist2)-lcnt:\n dist1 = dist1[lcnt:len(dist1),:]\n dist_M = np.zeros((len(dist1), len(dist2)))\n for i in range(0, len(dist1)):\n for j in range(0, len(dist2)):\n dist_M[i,j] = np.linalg.norm(dist1[i]-dist2[j])\n row_ind, col_ind = linear_sum_assignment(dist_M)\n for i in range(0, len(col_ind)):\n map_dict.append(col_ind[i]+lcnt)\n else:\n for i in range(0, len(dist1)):\n idx = find_min_square_dist(dist1[i], dist2, op, map_dict, lcnt)\n map_dict.append(idx)\n\n return map_dict","def __get_merge_nodelist(induced_ordering):\n duplicate = list(induced_ordering) # create a copy of the list containing the induced ordering\n return {duplicate.pop(), duplicate.pop()} # return the vertices corresponding to the s-t cut","def assign_nodes_to_edges(nodes, edges):\n\n from scipy.spatial import cKDTree\n \n edges_arr = np.vstack(edges)\n kdt_nodes = cKDTree(nodes)\n\n # closest node id and discard computed distances ('_,')\n _, pairs = kdt_nodes.query(x=edges_arr, k=1)\n # refactor list of successive ids for start and end of edges into 2D array\n pairs = np.vstack((pairs[::2], pairs[1::2])).T\n\n new_edges = []\n for pair in pairs[:,:]:\n new_edges.append(np.array(nodes[pair]))\n \n return new_edges, pairs","def node_ids(self):\n # From: https://stackoverflow.com/questions/17415086/combine-consecutive-numbers-into-range-tuples\n groups = groupby(self.nodes.keys(), key=lambda item, c=count():item-next(c))\n temp = [list(g) for k, g in groups]\n return \"+\".join(\"{}-{}\".format(x[0], x[-1]) for x in temp)","def __add_neighbours(p1, p2, n1, n2, idx1, idx2, mapping=None, dist1=None,\n dist2=None, dist_tol=0, pairs=None):\n\n if mapping is None:\n mapping = np.zeros((p1.numnodes, p2.numnodes))\n\n for i in range(p1.numnodes):\n for j in range(p2.numnodes):\n weighted_freq, _ = compare_nodes(p1.nodes[i], p2.nodes[j])\n if weighted_freq > 0.0:\n mapping[i][j] = weighted_freq\n if dist1 is None:\n dist1 = distances(p1)\n dist1[p1.edges > 0] = p1.edges[p1.edges > 0]\n\n if dist2 is None:\n dist2 = distances(p2)\n dist2[p2.edges > 0] = p2.edges[p2.edges > 0]\n\n if pairs is None:\n pairs = []\n\n def is_compatible(pair1, pair2):\n if (pair1[0] == pair2[0]) or (pair1[1] == pair1[1]):\n return False\n if (p1.edges[pair1[0], pair2[0]] != 0) and \\\n (p2.edges[pair1[1], pair2[1]] != 0):\n dist_diff = math.fabs((p1.edges[pair1[0], pair2[0]] -\n p2.edges[pair1[1], pair2[1]]))\n if dist_diff <= dist_tol:\n return True\n else:\n return False\n else:\n return True\n\n for i1, i2 in zip(idx1, idx2):\n neighbours1 = []\n for node in reversed(np.where(p1.edges[i1, n1] > 0)[0]):\n neighbours1.append(n1[node])\n n1.remove(n1[node])\n\n neighbours2 = []\n for node in reversed(np.where(p2.edges[i2, n2] > 0)[0]):\n neighbours2.append(n2[node])\n n2.remove(n2[node])\n\n # find compatible neighbours\n for neigh1 in neighbours1:\n for neigh2 in neighbours2:\n if (mapping[neigh1, neigh2] > 0):\n dist_diff = np.abs(dist1[idx1, neigh1] -\n dist2[idx2, neigh2])\n\n # there is edge between nodes in at least one of phars\n connected = np.where(p1.edges[idx1, neigh1] +\n p2.edges[idx2, neigh2])\n max_cost = np.max(dist_diff[connected])\n if (max_cost <= dist_tol):\n pairs.append((neigh1, neigh2))\n\n score = np.sum(mapping[idx1, idx2])\n dist_diff = np.abs(dist1[idx1][:, idx1] - dist2[idx2][:, idx2])\n connected = np.where(p1.edges[idx1][:, idx1] + p2.edges[idx2][:, idx2])\n\n if len(connected[0]) > 0:\n assert np.max(dist_diff[connected]) <= dist_tol, \"cost too high\"\n cost = np.sum(dist_diff[connected]) / 2.0\n\n aln = [idx1[:], idx2[:]]\n\n for i, pair in enumerate(pairs):\n compatible = [p for p in pairs[i+1:] if is_compatible(pair, p)]\n\n s, c, (aln1, aln2) = __add_neighbours(p1, p2, n1[:], n2[:],\n idx1+[pair[0]], idx2+[pair[1]],\n mapping, dist1, dist2, dist_tol,\n compatible)\n\n if (s - c > score - cost) or (s - c == score - cost and s > score):\n score = s\n cost = c\n aln = [aln1[:], aln2[:]]\n\n return score, cost, aln","def gen_hits2positions(\n target_units, source_units, stoplist_set, features_size):\n target_feature_matrix, target_breaks = _construct_unit_feature_matrix(\n target_units, stoplist_set, features_size)\n stepsize = 500\n for su_start in range(0, len(source_units), stepsize):\n feature_source_matrix, source_breaks = _construct_feature_unit_matrix(\n source_units[su_start:su_start+stepsize],\n stoplist_set,\n features_size)\n # for every position of each target unit, this matrix multiplication\n # picks up which source unit positions shared at least one common\n # feature\n match_matrix = target_feature_matrix.dot(feature_source_matrix)\n # this data structure keeps track of which target unit position matched\n # with which source unit position\n coo = match_matrix.tocoo()\n yield _bin_hits_to_unit_indices(\n coo.row, coo.col, target_breaks, source_breaks, su_start)","def ordered_indices(self):\r\n '''we need random order'''\r\n if self.shuffle:\r\n indices = np.random.permutation(len(self))\r\n else:\r\n indices = np.arange(len(self))\r\n '''\r\n if self.tgt_sizes is not None:\r\n indices = indices[np.argsort(self.tgt_sizes[indices], kind='mergesort')]\r\n return indices[np.argsort(self.src_sizes[indices], kind='mergesort')]\r\n '''\r\n return indices","def _get_common_neighbour_node_pairs(self):\n node_pairs = []\n for node1 in self.graph.nodes():\n for node2 in self.graph.nodes():\n if node1 != node2:\n neighbour_count = self.neighbour_counts[(node1, node2)]\n if neighbour_count >= 1:\n node_pairs.append((node1, node2))\n return node_pairs","def rearange_nodes_links_old(idx, nodes, links):\n nodes = nodes[idx,:]\n for i in range(0, len(links)):\n links[i, 0] = idx.index(links[i, 0])\n links[i, 1] = idx.index(links[i, 1])\n for i in range (0, len(links)):\n links[i] = sorted(links[i])\n \n # Sort links according to the source.\n links = links[links[:,0].argsort()]\n idx = update_idx_links(links[:,0], links[:,1])\n links = links[idx]\n return nodes, links","def rearange_nodes_links(idx, nodes, links):\n # TODO: Modify functions citing this function, so that we can combine this version with the former one.\n idx = update_idx(list(idx), nodes[:, 2])\n idx = list(np.array(idx).argsort())\n nodes = nodes[idx,:]\n for i in range(0, len(links)):\n links[i, 0] = idx.index(links[i, 0])\n links[i, 1] = idx.index(links[i, 1])\n for i in range (0, len(links)):\n links[i] = sorted(links[i])\n\n # Sort links according to the source.\n links = links[links[:,0].argsort()]\n idx = update_idx_links(links[:,0], links[:,1])\n links = links[idx]\n return nodes, links","def get_idx_from_latlon(self, latitudes, longitudes, unique=False):\n try:\n lat_idx = [np.argmin(np.abs(self.lat - lat)) for lat in latitudes]\n lon_idx = [np.argmin(np.abs(self.lon - lon)) for lon in longitudes]\n if unique:\n ijdx = np.vstack({(i, j) for i, j in zip(lat_idx, lon_idx)})\n lat_idx = ijdx[:, 0].tolist()\n lon_idx = ijdx[:, 1].tolist()\n except TypeError:\n lat_idx = np.argmin(np.abs(self.lat - latitudes))\n lon_idx = np.argmin(np.abs(self.lon - longitudes))\n\n return lat_idx, lon_idx","def greedy_match(cost_matrix):\n num_detections, num_tracks = cost_matrix.shape\n distance_1d = cost_matrix.reshape(-1)\n index_1d = np.argsort(distance_1d)\n index_2d = np.stack([index_1d // num_tracks, index_1d % num_tracks], axis=1).astype(int, copy=False)\n\n matched_indices = []\n matched_firsts = set()\n matched_seconds = set()\n\n for (first_id, second_id) in index_2d:\n if first_id not in matched_firsts and second_id not in matched_seconds:\n matched_seconds.add(second_id)\n matched_firsts.add(first_id)\n matched_indices.append([first_id, second_id])\n return np.array(matched_indices)","def get_idxs_in_correct_order(idx1, idx2):\n if idx1 < idx2: return idx1, idx2\n else: return idx2, idx1","def make_mapping(items):\n compid, nodes = items\n nodes = list(nodes)\n base_node = min(nodes)\n return [(node,base_node) for node in nodes if node != base_node]","def neighbours(assignment): \n for index_1, index_2 in itertools.combinations(range(len(assignment)), 2):\n new_assign = list(assignment)\n new_assign[index_1], new_assign[index_2] = new_assign[index_2], new_assign[index_1]\n yield tuple(new_assign)","def split_at_nodes(shp):\n nodes = find_nodes(shp)\n nodeIds = list(nodes)\n nodeIds.sort()\n nodeIds = dict([(node,i) for i,node in enumerate(nodeIds)])\n \n for road in shp:\n vrts = road.vertices\n midVrts = set(road.vertices[1:-1]) #we know end points are nodes\n midNodes = midVrts.intersection(nodes) # find any nodes in the middle of the feature.\n midIdx = [vrts.index(node) for node in midNodes] # Get their indices\n midIdx.sort()\n if midIdx:\n #print vrts\n starts = [0]+midIdx\n stops = [x+1 for x in midIdx]+[None]\n for start,stop in zip(starts,stops):\n feat = pysal.cg.Chain(vrts[start:stop])\n rec = (nodeIds[feat.vertices[0]],nodeIds[feat.vertices[-1]],False)\n yield feat,rec\n else:\n rec = (nodeIds[road.vertices[0]],nodeIds[road.vertices[-1]],False)\n yield road,rec","def _create_nodes(\n self, lanelet: Lanelet, left_way_id: str, right_way_id: str\n ) -> Tuple[List[str], List[str]]:\n left_nodes, right_nodes = [], []\n start_index = 0\n end_index = len(lanelet.left_vertices)\n pot_first_left_node, pot_first_right_node = self._get_shared_first_nodes_from_other_lanelets(\n lanelet\n )\n pot_last_left_node, pot_last_right_node = self._get_shared_last_nodes_from_other_lanelets(\n lanelet\n )\n if pot_first_left_node:\n start_index = 1\n if pot_last_left_node:\n end_index = -1\n\n if left_way_id:\n first_left_node, last_left_node = self._get_first_and_last_nodes_from_way(\n left_way_id, lanelet.adj_left_same_direction\n )\n else:\n first_left_node = pot_first_left_node\n last_left_node = pot_last_left_node\n left_nodes = self._create_nodes_from_vertices(\n lanelet.left_vertices[start_index:end_index]\n )\n if right_way_id:\n first_right_node, last_right_node = self._get_first_and_last_nodes_from_way(\n right_way_id, lanelet.adj_right_same_direction\n )\n else:\n first_right_node = pot_first_right_node\n last_right_node = pot_last_right_node\n right_nodes = self._create_nodes_from_vertices(\n lanelet.right_vertices[start_index:end_index]\n )\n\n if first_left_node:\n left_nodes.insert(0, first_left_node)\n if first_right_node:\n right_nodes.insert(0, first_right_node)\n\n if last_left_node:\n left_nodes.append(last_left_node)\n if last_right_node:\n right_nodes.append(last_right_node)\n\n return left_nodes, right_nodes","def _match_identical_nodes(self):\n\n for job_name_b in self._topo_b_nodes:\n for job_name_a in self._unresolved_a_nodes:\n if self._is_node_identical(job_name_a, job_name_b):\n self._identical_nodes[job_name_b] = job_name_a\n self._unresolved_a_nodes.remove(job_name_a)\n self._unresolved_b_nodes.remove(job_name_b)\n break","def get_all_possible_os_pairings(indices_list):\n pairs = []\n itr = 0\n\n for links in indices_list:\n\n for item in links:\n for i in range(itr,len(links)):\n\n if item == links[i]:\n continue\n else:\n pair = item, links[i]\n pairs.append(pair)\n return pairs","def adjacent_pairs(self, nodes: Tuple[int], k: int) -> List[Tuple[int, int]]:\n n = len(nodes)\n return [(u, nodes[j % n])\n for i, u in enumerate(nodes)\n for j in range(i + 1, i + 1 + k // 2)]","def compare_search(sizes=[1e1, 1e2, 1e3, 1e4, 1e5, 1e6, 1e7]):\n\tprint(sizes)\n\treturn [(size,\n\t\t\t time_search(linear_search, list(range(int(size))), -1),\n\t\t\t time_search(binary_search, list(range(int(size))), -1)) for size in sizes]","def nid2partid(self, nids):\n nids = utils.toindex(nids)\n ret = np.searchsorted(self._node_map, nids.tonumpy(), side='right')\n ret = utils.toindex(ret)\n return ret.tousertensor()","def _get_index_mapper_list(graph, next_graph, cur_node_start_idx, next_node_start_idx):\n cur_idx = []\n next_idx = []\n\n next_graph_tag = next_graph.ndata['tag']\n ally_node_index = get_filtered_node_index_by_type(graph, NODE_ALLY)\n for cn_index in graph.nodes()[ally_node_index]:\n curr_tag = graph.ndata['tag'][cn_index]\n next_graph_index = (next_graph_tag == curr_tag).nonzero().squeeze().int()\n if next_graph_index.nelement() == 0:\n pass\n elif next_graph_index.nelement() == 1:\n cur_idx.append((cn_index + cur_node_start_idx).tolist())\n next_idx.append((next_graph_index + next_node_start_idx).tolist())\n else:\n raise RuntimeError(\"Existing multiple units with same tag in next graph\")\n return cur_idx, next_idx","def sort_nodes(self, min_return=5):\n nodes = self._all_nodes()\n sorted_nodes, sorted_scores = self.scorer.sort(nodes)\n\n if len(nodes) <= min_return:\n return sorted_nodes, sorted_scores\n\n seen_hashes = set()\n best_nodes = []\n best_scores = []\n last_score = 1e16\n for score, node in zip(sorted_scores, sorted_nodes):\n if len(best_nodes) >= min_return and score < last_score:\n break\n route_actions, _ = self.search_tree.route_to_node(node)\n route_hash = self._routehash(route_actions)\n\n if route_hash in seen_hashes:\n continue\n seen_hashes.add(route_hash)\n best_nodes.append(node)\n best_scores.append(score)\n last_score = score\n\n return best_nodes, best_scores","def get_node_pair_pattern(node1, node2):\n if int(node1.nid) > int(node2.nid):\n return f'{node2.nid} - {node1.nid}'\n else:\n return f'{node1.nid} - {node2.nid}'","def find_mutual_nn(self):\n best_match_src = self.scores.argmax(1) # Best match for each source word\n best_match_trg = self.scores.argmax(0) # Best match for each source word\n\n # ONELIENER\n # paired_idx = [(i,best_match_src[i]) for i in range(self.ns) if best_match_trg[best_match_src[i]] == i]\n # paired_words = [(self.src_words[i],self.trg_words[j]) for (i,j) in paired_idx]\n paired = []\n for i in range(self.ns):\n m = best_match_src[i]\n if best_match_trg[m] == i:\n paired.append((i,m))\n\n paired_toks = []\n if self.src_words and self.trg_words:\n paired_toks = [(self.src_words[i],self.trg_words[j]) for (i,j) in paired]\n else:\n paired_toks = paired\n return paired_toks","def match3(img1, img2, coordinates1, coordinates2, PATCH_SIZE, threshold=0.7):\n\n\t#creating patches for all points from img1 and img2\n\tcoord1_patches = [make_patch(coordinate, PATCH_SIZE, img1) for coordinate in coordinates1]\n\tcoord2_patches = [make_patch(coordinate, PATCH_SIZE, img2) for coordinate in coordinates2]\n\n\t# creating a matrix with dissimilarity measures for all pairs\n\tall_matches = np.zeros((len(coordinates1), len(coordinates2)))\n\n\tfor (x, y), _ in np.ndenumerate(all_matches):\n\t\tall_matches[x,y] = count_difference(coord1_patches[x], coord2_patches[y])\n\n\t#looking for best left-to-right and right-to-left matches\n\tmatches = []\n\t#left-to-right\n\tfor i, coord1 in enumerate(coordinates1):\n\t\tbest_ltr_match = np.argmin(all_matches[i, :]) #best left-to-right match for coord1\n\t\tbest_rtl_match = np.argmin(all_matches[:, best_ltr_match]) #best match for a best match\n\t\tif (i == best_rtl_match): #hurray, there is a super match\n\n\t\t\tmatches.append([coord1, coordinates2[best_ltr_match], all_matches[i, best_ltr_match]])\n\t\n\treturn matches","def tree_idx2(treeG,k1,J1,J2):\n g = treeG[J1]['clusters'][k1]\n if(J1>J2+1):\n for j in np.arange(J2+1, J1)[::-1]:\n g1 = []\n for i in np.arange(0,len(g),1):\n g1 = np.array(np.append(g1,treeG[j]['clusters'][g[i]]), dtype = int)\n g = g1\n y = g\n return y","def hard_examples_mining(dist_mat, identity_mat, return_idxes=False):\n # the implementation here is a little tricky, dist_mat contains pairwise distance between probe image and other\n # images in current mini-batch. As we want to select positive examples of the same person, we add a constant\n # negative offset on other images before sorting. As a result, images of the **same** person will rank first.\n sorted_dist_mat, sorted_idxes = torch.sort(dist_mat + (-1e7) * (1 - identity_mat), dim=1,\n descending=True)\n dist_ap = sorted_dist_mat[:, 0]\n hard_positive_idxes = sorted_idxes[:, 0]\n\n # the implementation here is similar to above code, we add a constant positive offset on images of same person\n # before sorting. Besides, we sort in ascending order. As a result, images of **different** persons will rank first.\n sorted_dist_mat, sorted_idxes = torch.sort(dist_mat + 1e7 * identity_mat, dim=1,\n descending=False)\n dist_an = sorted_dist_mat[:, 0]\n hard_negative_idxes = sorted_idxes[:, 0]\n if return_idxes:\n return dist_ap, dist_an, hard_positive_idxes, hard_negative_idxes\n return dist_ap, dist_an","def _node_ids(self, nodes=None):\n if not nodes:\n nodes = self.nodes\n if isinstance(nodes[0], integer_types):\n return nodes\n return [node.nid for node in nodes]","def create_match_instance_pairs(plant_match_in):\r\n\t## collect all plant name match instances indices\r\n\tjust_indices = [int(indices) for plant_match_in_set in plant_match_in for indices in plant_match_in_set[1]]\r\n\t\r\n\tassert len(just_indices) == len(set(just_indices)) # check there are no exact duplicates in indices\r\n\r\n\tsorted_index = list(sorted(just_indices)) # sort indices small-large\r\n\tprint(f'Length of corpus bigrams BEFORE ambiguous matches removed: {len(sorted_index)}')\r\n\t#print(sorted_index)\r\n\r\n\t# remove all ambiguous matches that are within 1 word of each other\r\n\tprint('Ambiguous plant name matches: ')\r\n\tfor i, index in enumerate(sorted_index): # iterate over all indices in sorted list\r\n\t\t\r\n\t\tif index == sorted_index[i-1]+1: # indices is within 1 of previous indices in list\r\n\t\t\tprint(index, sorted_index[i-1])\r\n\t\t\tsorted_index.remove(index) # remove indices from list\r\n\t\t\tsorted_index.remove(sorted_index[i-1]) # AND remove previous indices from list\r\n\tprint(f'Length of corpus bigrams AFTER ambiguous matches removed: {len(sorted_index)}')\r\n\r\n\t# create indices dict with 'B', 'I' values\r\n\tpaired_finds = {}\r\n\tfor match_index in sorted_index: # iterate over unambiguous match indices list\r\n\t\t\t\t\t\r\n\t\t\tpaired_finds[match_index] = ('B') # WITH value of 'B'\r\n\t\t\t\r\n\t\t\tpaired_finds[match_index+1] = ('I') # WITH value of 'I'\r\n\r\n\treturn paired_finds","def differentNodesForNode(ntupleSet,nodeList,verbose=False):\n nodesPerNode = dict(zip(nodeList,[[] for n in range(len(nodeList))]))\n for ntuple in ntupleSet:\n for nodeInTuple in ntuple:\n nodesPerNode[nodeInTuple].extend(ntuple)\n \n for a,v in nodesPerNode.iteritems():\n nodesPerNode[a] = set(v)\n \n return nodesPerNode","def solve_part1(start):\n inputs = load_inputs(False)\n two_matches = []\n tiles = inputs.keys()\n for elem in tiles:\n matches = defaultdict(list)\n for elem2 in tiles:\n if elem != elem2 and compare_tile(inputs[elem], inputs[elem2]):\n l = matches[elem]\n l.append(elem2)\n\n if len(matches[elem]) == 2:\n print matches\n two_matches.append(elem)\n\n return reduce((lambda x, y: int(x) * int(y)), two_matches)","def prepare_pairs(self, pairs, input_lang, output_lang, tree=False):\n\t\tprepared_pairs = []\n\n\t\tfor pair in pairs:\n\t\t\tinput_seq, eq_segs, nums = pair.input_seq, pair.output_seq, pair.nums\n\t\t\tnum_stack = []\n\t\t\tfor word in eq_segs:\n\t\t\t\ttemp_num = []\n\t\t\t\tflag_not = True\n\t\t\t\tif word not in output_lang.index2word:\n\t\t\t\t\tflag_not = False\n\t\t\t\t\tfor num_index, num in enumerate(nums):\n\t\t\t\t\t\tif num == word:\n\t\t\t\t\t\t\ttemp_num.append(num_index)\n\n\t\t\t\tif not flag_not and len(temp_num) != 0:\n\t\t\t\t\tnum_stack.append(temp_num)\n\t\t\t\tif not flag_not and len(temp_num) == 0:\n\t\t\t\t\tnum_stack.append([_ for _ in range(len(nums))])\n\n\t\t\tnum_stack.reverse()\n\n\t\t\tinput_cell = indexes_from_sentence(input_lang, input_seq)\n\t\t\toutput_cell = indexes_from_sentence(output_lang, eq_segs, tree)\n\n\t\t\tpair.input_tokens = input_cell\n\t\t\tpair.output_tokens = output_cell\n\t\t\tpair.num_stack = num_stack\n\t\t\tpair.build_graph()\n\n\t\t\tprepared_pairs.append(pair)\n\n\t\treturn prepared_pairs","def _create_pairs(self, sample_ratio):\n # Broadcast target/source labels into mesh grid\n # `source` -> (N, 1) broadcast to (N, M)\n # `target` -> (1, M) broadcast to (N, M)\n target, source = np.meshgrid(self.y['tgt'], self.y['src'])\n\n # Find index pairs (i_S, i_T) for where src_y == tgt_y\n intra_pair_idxs = np.argwhere(source == target)\n\n # Find index pairs (i_S, i_T) for where src_y != tgt_y\n inter_pair_idxs = np.argwhere(source != target)\n\n # Randomly sample the interclass pairs to meet desired ratio\n if sample_ratio > 0:\n n_interclass = sample_ratio * len(intra_pair_idxs)\n np.random.shuffle(inter_pair_idxs)\n inter_pair_idxs = inter_pair_idxs[:n_interclass]\n\n # Sort as to allow shuffling to be performed by the DataLoader\n inter_pair_idxs = inter_pair_idxs[\n np.lexsort((inter_pair_idxs[:, 1], inter_pair_idxs[:, 0]))\n ]\n\n return intra_pair_idxs, inter_pair_idxs","def expander(i_start, j_end, length):\n\n # create list of paired i indices\n i_s = list(np.arange(i_start, i_start + length))\n\n # create list of corresponding j indices:\n j_s = list(np.arange(j_end, j_end + length))\n\n # form list of tuple pairs\n pairs = list(zip(i_s, j_s))\n\n return pairs","def graph_generation(nodes: np.ndarray, edges: np.ndarray):\n result_nodes = []\n result_edges = []\n\n last_index = nodes[-1, 0]\n\n done = False\n # print(nodes)\n for p in range(nodes.shape[0]):\n for q in range(nodes.shape[0]):\n if list(nodes[p, 1:-2]) == (list(nodes[q, 1:-2])) and nodes[p, nodes.shape[1] - 2] < \\\n nodes[q, nodes.shape[1] - 2]:\n tmp_node = np.append(nodes[p, 1:], np.append(nodes[q, nodes.shape[1] - 2],\n np.append(nodes[q, nodes.shape[1] - 1],\n np.append(nodes[p, 0],\n nodes[q, 0]))))\n if not done:\n result_nodes = [tmp_node]\n done = True\n else:\n result_nodes = np.concatenate((result_nodes, [tmp_node]))\n\n result_nodes = result_nodes[np.argsort(\n result_nodes[:, [e for e in range(1, result_nodes.shape[1] - 2) if e % 2 != 0]].sum(axis=1)), :]\n\n result_nodes = np.c_[range(last_index + 1, last_index + 1 + result_nodes.shape[0]), result_nodes]\n # print(result_nodes)\n\n done = False\n for e in range(edges.shape[0]):\n for f in range(edges.shape[0]):\n for p in range(result_nodes.shape[0]):\n for q in range(result_nodes.shape[0]):\n if (edges[e, 0] == result_nodes[p, -2] and edges[e, 1] == result_nodes[q, -2] and edges[\n f, 0] == result_nodes[p, -1] and edges[f, 1] == result_nodes[q, -1]) \\\n or (edges[e, 0] == result_nodes[p, -2] and edges[e, 1] == result_nodes[q, -2] and\n result_nodes[p, -1] == result_nodes[q, -1]) \\\n or (edges[e, 0] == result_nodes[p, -1] and edges[e, 1] == result_nodes[q, -1] and\n result_nodes[p, -2] == result_nodes[q, -2]):\n if not done:\n result_edges = [[result_nodes[p, 0], result_nodes[q, 0]]]\n done = True\n else:\n result_edges = np.concatenate(\n (result_edges, [[result_nodes[p, 0], result_nodes[q, 0]]]), axis=0)\n # print(edges)\n\n # print(result_edges)\n unique_result_edges = list(Counter(str(e) for e in result_edges).keys())\n # print(unique_result_edges)\n final_edges = []\n for k in range(len(unique_result_edges)):\n for j in range(result_edges.shape[0]):\n if str(result_edges[j]) == unique_result_edges[k]:\n if k == 0:\n final_edges = result_edges[j]\n break\n else:\n final_edges = np.concatenate((final_edges, result_edges[j]))\n break\n final_edges = np.reshape(final_edges, (int(final_edges.shape[0] / 2), 2))\n # print(final_edges.shape[0])\n done = False\n edge_to_remove = []\n for j in range(final_edges.shape[0]):\n for k in range(j + 1, final_edges.shape[0]):\n if final_edges[j, 1] == final_edges[k, 0]:\n if not done:\n edge_to_remove = [[final_edges[j, 0], final_edges[k, 1]]]\n done = True\n else:\n edge_to_remove = np.concatenate((edge_to_remove, [[final_edges[j, 0], final_edges[k, 1]]]))\n # print(edge_to_remove)\n\n idx_to_remove = []\n done = False\n for j in range(edge_to_remove.shape[0]):\n for k in range(final_edges.shape[0]):\n if list(edge_to_remove[j]) == list(final_edges[k]):\n if not done:\n idx_to_remove = k\n done = True\n else:\n idx_to_remove = np.append(idx_to_remove, k)\n final_edges = np.delete(final_edges, idx_to_remove, axis=0)\n # print(final_edges)\n result_nodes = np.delete(result_nodes, [-1, -2], 1)\n # print(result_nodes)\n return result_nodes, final_edges","def create_index(filenames: list, raw_data_dir: str,\n processed_data_dir: str) -> None:\n entities, relations = set(), set()\n\n for filename in filenames:\n file_path = path.join(raw_data_dir, filename)\n with open(file_path, 'r') as file:\n for line in file.readlines():\n mid1, relation, mid2 = line.strip().split('\\t')\n entities.add(mid1)\n entities.add(mid2)\n relations.add(relation)\n\n logger = logging.getLogger(__name__)\n logger.info(\"Found %i different entities\", len(entities))\n logger.info(\"Found %i different relations\", len(relations))\n\n entity_to_id = {entity: i for (i, entity) in enumerate(sorted(entities))}\n relation_to_id = {relation: i for (i, relation) in\n enumerate(sorted(relations))}\n\n id_to_entity = {i: entity for entity, i in entity_to_id.items()}\n id_to_relation = {i: relation for relation, i in relation_to_id.items()}\n\n e2i_path = processed_data_dir + \"/entity_to_id.pickle\"\n filename_relation_to_id = processed_data_dir + \"/relation_to_id.pickle\"\n i2e_path = processed_data_dir + \"/id_to_entity.pickle\"\n filename_id_to_relation = processed_data_dir + \"/id_to_relation.pickle\"\n\n os.makedirs(processed_data_dir, exist_ok=True)\n\n with open(e2i_path, \"wb\") as handle1:\n pickle.dump(entity_to_id, handle1, protocol=pickle.HIGHEST_PROTOCOL)\n\n with open(filename_relation_to_id, \"wb\") as handle2:\n pickle.dump(relation_to_id, handle2, protocol=pickle.HIGHEST_PROTOCOL)\n\n with open(i2e_path, \"wb\") as handle3:\n pickle.dump(id_to_entity, handle3, protocol=pickle.HIGHEST_PROTOCOL)\n\n with open(filename_id_to_relation, \"wb\") as handle4:\n pickle.dump(id_to_relation, handle4, protocol=pickle.HIGHEST_PROTOCOL)","def neighbors((min_i, min_j), (max_i, max_j), (i, j)):\n if j + 1 <= max_j:\n yield (i, j + 1)\n if j - 1 >= min_j:\n yield (i, j - 1)\n if i + 1 <= max_i:\n yield (i + 1, j)\n if i - 1 >= min_i:\n yield (i - 1, j)","def testPairs(G, aggr_nodes, prefix1='2_0', prefix2='2_1', table=None):\n aggr1 = [x for x in aggr_nodes[1:80:8] if prefix1 in x]\n aggr2 = [x for x in aggr_nodes[0:80:8] if prefix2 in x]\n\n n = len(aggr1)\n \n test_pairs = []\n for i in range(0, n):\n for j in range(0, n):\n if (aggr1[i] in table and aggr2[j] in table \n and (aggr1[i], aggr2[j]) in G.edges()\n ):\n test_pairs.append((aggr1[i], aggr2[j]))\n \n return test_pairs","def get_closest_match(indices1, indices2):\n \n if len(indices1) == 1 and len(indices2) == 1:\n return indices1[0], indices2[0]\n \n closest_match = (indices1[0], indices2[0])\n min_dist = np.abs(closest_match[0][0] - closest_match[1][0])\n for pair in itertools.product(indices1, indices2):\n dist = np.abs(pair[0][0] - pair[1][0])\n if dist < min_dist:\n closest_match = pair\n min_dist = dist\n \n return closest_match","def tracklet_fast(g1: nx.graph, g2: nx.graph, seg_img1: np.ndarray, seg_img2: np.ndarray, maxtrackid: int, time: int, \n linelist: list, tracksavedir: str, cellcenter1: np.ndarray, cellcenter2: np.ndarray) \\\n -> (int, list):\n f1 = {}\n f2 = {}\n dict_associate = {}\n loc1 = g1.degree(weight=\"weight\")\n loc2 = g2.degree(weight=\"weight\")\n new_seg_img2 = np.zeros(seg_img2.shape)\n\n for ele1 in loc1:\n cell = ele1[0]\n f1[cell] = [cellcenter1[cell], ele1[1]]\n\n for ele2 in loc2:\n cell = ele2[0]\n f2[cell] = [cellcenter2[cell], ele2[1]]\n\n for cell in f2.keys():\n tmp_center = f2[cell][0]\n min_distance = seg_img2.shape[0]**2 + seg_img2.shape[1]**2 + seg_img2.shape[2]**2\n\n for ref_cell in f1.keys():\n ref_tmp_center = f1[ref_cell][0]\n distance = (tmp_center[0]-ref_tmp_center[0])**2 + (tmp_center[1] -\n ref_tmp_center[1])**2 + (tmp_center[2]-ref_tmp_center[2])**2\n if distance < min_distance:\n dict_associate[cell] = ref_cell\n min_distance = distance\n\n inverse_dict_ass = {}\n\n for cell in dict_associate:\n if dict_associate[cell] in inverse_dict_ass:\n inverse_dict_ass[dict_associate[cell]].append(cell)\n else:\n inverse_dict_ass[dict_associate[cell]] = [cell]\n\n maxtrackid = max(maxtrackid, max(inverse_dict_ass.keys()))\n\n for cell in inverse_dict_ass.keys():\n if len(inverse_dict_ass[cell]) > 1:\n for cellin2 in inverse_dict_ass[cell]:\n maxtrackid = maxtrackid + 1\n new_seg_img2[seg_img2 == cellin2] = maxtrackid\n string = '{} {} {} {}'.format(maxtrackid, time+1, time+1, cell)\n linelist.append(string)\n else:\n cellin2 = inverse_dict_ass[cell][0]\n new_seg_img2[seg_img2 == cellin2] = cell\n i = 0\n\n for line in linelist:\n i = i+1\n if i == cell:\n list_tmp = line.split()\n new_string = '{} {} {} {}'.format(list_tmp[0], list_tmp[1], time+1, list_tmp[3])\n linelist[i-1] = new_string\n\n with concurrent.futures.ThreadPoolExecutor(max_workers=2) as executor:\n thread1 = executor.submit(save_img_as_tiff, seg_img1, time, tracksavedir)\n thread2 = executor.submit(save_img_as_tiff, new_seg_img2, time+1, tracksavedir)\n\n return maxtrackid, linelist","def test_sort_ids(self):\r\n\r\n mapping = {\"1\": [\"0\", \"2\", \"5\", \"6\"],\r\n \"3\": [],\r\n \"4\": [],\r\n \"11\": [1, 2, 3, 4, 5, 6, 7, 8, 9],\r\n \"8\": [\"7\"]}\r\n\r\n self.assertEqual(sort_ids([\"1\", \"3\", \"4\", \"8\", \"11\"], mapping),\r\n [\"11\", \"1\", \"8\", \"4\", \"3\"])","def test_sort_ids(self):\r\n\r\n mapping = {\"1\": [\"0\", \"2\", \"5\", \"6\"],\r\n \"3\": [],\r\n \"4\": [],\r\n \"11\": [1, 2, 3, 4, 5, 6, 7, 8, 9],\r\n \"8\": [\"7\"]}\r\n\r\n self.assertEqual(sort_ids([\"1\", \"3\", \"4\", \"8\", \"11\"], mapping),\r\n [\"11\", \"1\", \"8\", \"4\", \"3\"])","def min_cost_matching(\n distance_metric, max_distance, tracks, detections, track_indices=None,\n detection_indices=None):\n if track_indices is None:\n track_indices = np.arange(len(tracks))\n if detection_indices is None:\n detection_indices = np.arange(len(detections))\n\n if len(detection_indices) == 0 or len(track_indices) == 0:\n return [], track_indices, detection_indices # Nothing to match.\n\n cost_matrix = distance_metric(\n tracks, detections, track_indices, detection_indices)\n cost_matrix[cost_matrix > max_distance] = max_distance + 1e-5\n indices = linear_sum_assignment(cost_matrix)\n indices = np.asarray(indices)\n indices = np.transpose(indices)\n\n matches, unmatched_tracks, unmatched_detections = [], [], []\n for col, detection_idx in enumerate(detection_indices):\n if col not in indices[:, 1]:\n unmatched_detections.append(detection_idx)\n for row, track_idx in enumerate(track_indices):\n if row not in indices[:, 0]:\n unmatched_tracks.append(track_idx)\n for row, col in indices:\n track_idx = track_indices[row]\n detection_idx = detection_indices[col]\n if cost_matrix[row, col] > max_distance:\n unmatched_tracks.append(track_idx)\n unmatched_detections.append(detection_idx)\n else:\n matches.append((track_idx, detection_idx))\n return matches, unmatched_tracks, unmatched_detections","def _update_nodes_ids(self, change=None):\n self._nodes_filter.val_range = self.nodes_range\n self.nodes_ids = self._nodes_filter.val_ids\n self._update_edges_filtered(change)","def remap_ids(self, id_map: Dict[int, int]) -> None:\n super().remap_ids(id_map)\n nds = self.nodes\n for i, nd_id in enumerate(nds):\n nds[i] = id_map.get(nd_id, 0)","def canonical_order(match):\n\n # match[0][0:3] contains the ID numbers of the 4 atoms in the match\n atom0 = match[0][0]\n atom1 = match[0][1]\n atom2 = match[0][2]\n atom3 = match[0][3]\n # match[1][0:2] contains the ID numbers of the the 3 bonds\n bond0 = match[1][0]\n bond1 = match[1][1]\n bond2 = match[1][2]\n if atom0 < atom3:\n # return ((atom0, atom1, atom2, atom3), (bond0, bond1, bond2)) same\n # as:\n return match\n else:\n return ((atom3, atom2, atom1, atom0), (bond2, bond1, bond0))","def unpruned_atom_pairs(\n molecules: List[masm.Molecule], idx_map: List[Tuple[int, int]], distance_bounds: Tuple[int, int]\n) -> Set[Tuple[int, int]]:\n\n def structure_idx(c: int, i: int) -> int:\n return idx_map.index((c, i))\n\n pairs: Set[Tuple[int, int]] = set()\n\n for component, molecule in enumerate(molecules):\n for i in molecule.graph.atoms():\n distances = np.array(masm.distance(i, molecule.graph))\n partners = np.nonzero((distances <= max(distance_bounds)) & (distances >= min(distance_bounds)))[0]\n\n # Back-transform to structure indices and add to set\n s_i = structure_idx(component, i)\n s_partners = [structure_idx(component, j) for j in partners]\n pairs |= set(make_sorted_pair(s_i, s_j) for s_j in s_partners)\n\n return pairs","def remove_xmatch_multiples(index_primary, index_secondary, d2d, d3d, retain_best_match=True,\n verbose=False):\n n_entries = len(index_primary)\n n_unique_entries = len(np.unique(index_primary))\n if verbose:\n print('xmatch: cleanMultipleCrossMatches: there are {0:d} unique entries in the primary '\n 'catalog'.format(n_unique_entries))\n\n if n_entries != n_unique_entries:\n # get array of unique indices (here like identifier) and the corresponding occurrence count\n unique_array, return_counts = np.unique(index_primary, return_counts=True)\n\n # indices in unique array of stars with multiple crossmatches\n index_in_unique_array = np.where(return_counts > 1)[0]\n number_of_stars_with_multiplematches = len(index_in_unique_array)\n if verbose:\n if retain_best_match:\n print('xmatch: result contains {} multiple matches affecting {} entries, '\n 'keeping closest match'.format(number_of_stars_with_multiplematches,\n n_entries - n_unique_entries))\n else:\n print('xmatch: result contains {} multiple matches affecting {} entries, removing '\n 'them all'.format(number_of_stars_with_multiplematches,\n n_entries - n_unique_entries))\n\n # identifiers (i.e. numbers in index_primary) of stars with multiple crossmatches\n multi_matches = unique_array[index_in_unique_array]\n\n # index in index_primary where multiple matches occur\n index_multiple_match = np.where(np.in1d(index_primary, multi_matches))[0]\n if verbose:\n print(d2d[index_multiple_match], index_primary[index_multiple_match], index_secondary[index_multiple_match])\n\n good_index_in_index_primary = np.zeros(number_of_stars_with_multiplematches)\n for ii, jj in enumerate(multi_matches):\n tmp_idx0 = np.where(index_primary[index_multiple_match] == jj)[0]\n tmp_idx1 = np.argmin(d2d[index_multiple_match][tmp_idx0])\n good_index_in_index_primary[ii] = index_primary[index_multiple_match][tmp_idx0[tmp_idx1]]\n\n if retain_best_match:\n index_to_remove = np.setdiff1d(index_multiple_match, good_index_in_index_primary)\n else:\n index_to_remove = index_multiple_match\n\n mask = np.ones(len(index_primary), dtype=bool)\n mask[index_to_remove] = False\n index_primary = index_primary[mask]\n index_secondary = index_secondary[mask]\n d2d = d2d[mask]\n d3d = d3d[mask]\n if len(index_primary) != len(np.unique(index_primary)):\n print('xmatch: Multiple match cleanup procedure failed')\n # get array of unique indices (here like identifier) and the corresponding occurrence count\n unique_array, return_counts = np.unique(index_primary, return_counts=True)\n\n # indices in unique array of stars with multiple crossmatches\n index_in_unique_array = np.where(return_counts > 1)[0]\n number_of_stars_with_multiplematches = len(index_in_unique_array)\n print('xmatch: result still contains {} multiple matches'.format(\n number_of_stars_with_multiplematches))\n\n return index_primary, index_secondary, d2d, d3d","def extractPathsFromExploded (cls, exploded_paths_dict, min_dist_pairs,\n id_connector_character):\n min_length_paths = defaultdict(lambda: defaultdict(lambda: None))\n for original_starting_node, d in min_dist_pairs.iteritems():\n for original_ending_node, tup in d.iteritems():\n exploded_path = exploded_paths_dict[tup[0]][tup[1]]\n # get only the exploded IDs, which come from node ID-s\n path_with_only_node_ids = filter(\n lambda lid, sep=id_connector_character: sep in lid, exploded_path)\n # transform them back to the original ID-s\n path_with_original_node_ids = map(\n lambda lid, sep=id_connector_character: lid.split(sep)[1],\n path_with_only_node_ids)\n # the startgin and ending node ID may not be in place\n if path_with_original_node_ids[0] != original_starting_node:\n path_with_original_node_ids.insert(0, original_starting_node)\n if path_with_original_node_ids[-1] != original_ending_node:\n path_with_original_node_ids.append(original_ending_node)\n\n # a transit infra appears twice in the path after each other, because\n # there was an inbound and an outbound port.\n path_with_original_node_ids_no_duplicates = [\n path_with_original_node_ids[0]]\n for n in path_with_original_node_ids:\n if n != path_with_original_node_ids_no_duplicates[-1]:\n path_with_original_node_ids_no_duplicates.append(n)\n path_with_original_node_ids_no_duplicates_str = map(\n lambda node_id: NFFGToolBox.try_to_convert(node_id),\n path_with_original_node_ids_no_duplicates)\n min_length_paths[NFFGToolBox.try_to_convert(original_starting_node)][\n NFFGToolBox.try_to_convert(original_ending_node)] = \\\n path_with_original_node_ids_no_duplicates_str\n\n # convert embedded default dicts\n for k in min_length_paths:\n min_length_paths[k] = dict(min_length_paths[k])\n return dict(min_length_paths)","def _candidate_ranking(self, big_final_dict):\n self.logger.info(\"Disambiguated Entity Link\")\n big_list = []\n\n for dict in big_final_dict:\n for dict_value in dict.values():\n temp = []\n for i in dict_value:\n x = (i.split(\"http://dbpedia.org/resource/\"))\n y = list(filter(None, x))\n yy = (y[0].split('_'))\n strg = ''\n for x in yy:\n strg = strg + x + ' '\n strg = strg[:-1]\n temp.append(strg)\n big_list.append(temp)\n\n big_arr2 = []\n for small_list in big_list:\n arr2 = []\n for i in small_list:\n arr2.append(re.sub(r'[^\\w\\s]', '', (i)))\n\n big_arr2.append(arr2)\n\n input_text_cleaned = re.sub(r'[^\\w\\s]', '', self.text)\n arr1 = input_text_cleaned.split() # remove stop words\n arr1 = [w for w in arr1 if w.lower() not in self.english_stopwords]\n\n self.ranked_entities = []\n for arr2 in big_arr2:\n a = numpy.zeros(shape=(len(arr2), len(arr1)))\n for i in range(len(arr1)):\n for j in range(len(arr2)):\n if arr1[i] in arr2[j]:\n a[j][i] = 1\n else:\n a[j][i] = 0\n\n rows = len(a)\n cols = len(a[0])\n highest = []\n\n for x in range(0, rows):\n rowtotal = 0\n for y in range(0, cols):\n rowtotal = rowtotal + int(a[x][y])\n highest.append(rowtotal)\n\n highest_value = highest.index(max(highest))\n ranked_entity = arr2[highest_value]\n self.logger.info(\n 'Ambiguous word:' + ranked_entity + ' ' + 'Disambiguation link' + ' ' + 'https://en.wikipedia.org/wiki/' + (\n ranked_entity).replace(' ', '_'))\n self.ranked_entities.append(\n [ranked_entity, 'https://en.wikipedia.org/wiki/' + (ranked_entity).replace(' ', '_')])\n return self.ranked_entities","def get_indices(min_lat, max_lat, min_lon, max_lon, lons, lats):\n\n distances1, distances2, indices = [], [], []\n index = 1\n for point in lats:\n s1 = max_lat - point\n s2 = min_lat - point\n distances1.append((np.dot(s1, s1), point, index))\n distances2.append((np.dot(s2, s2), point, index - 1))\n index = index + 1\n\n distances1.sort()\n distances2.sort()\n indices.append(distances1[0])\n indices.append(distances2[0])\n\n distances1, distances2 = [], []\n index = 1\n for point in lons:\n s1 = max_lon - point\n s2 = min_lon - point\n distances1.append((np.dot(s1, s1), point, index))\n distances2.append((np.dot(s2, s2), point, index - 1))\n index = index + 1\n\n distances1.sort()\n distances2.sort()\n indices.append(distances1[0])\n indices.append(distances2[0])\n\n # max_lat_indices, min_lat_indices, max_lon_indices, min_lon_indices.\n res = np.zeros((4), dtype=np.float64)\n res[0] = indices[3][2]\n res[1] = indices[2][2]\n res[2] = indices[1][2]\n res[3] = indices[0][2]\n return res","def tree_idx(tree,j1,J1,J2):\n j = j1\n for k in np.arange(J1+1,J2+1,1):\n j = tree[k]['IDX'][j]\n \n j2 = j\n return j2","def _find_paired_nodes(self, graph):\n paired_list = []\n for line in nx.generate_edgelist(graph):\n if ('basepair' in line):\n if not (int(line.split(' ')[0]) in paired_list):\n paired_list.append(int(line.split(' ')[0]))\n if not (int(line.split(' ')[1]) in paired_list):\n paired_list.append(int(line.split(' ')[1]))\n return paired_list","def differentNTuplesForNode(ntupleSet,nodeList,verbose=False):\n ntuplesPerNode = dict(zip(nodeList,[[] for n in range(len(nodeList))]))\n for ntuple in ntupleSet:\n ntuple.sort()\n joinedTuple = \"\".join(ntuple)\n for nodeInTuple in ntuple:\n ntuplesPerNode[nodeInTuple].append(joinedTuple)\n \n for a,v in ntuplesPerNode.iteritems():\n ntuplesPerNode[a] = set(v)\n \n return ntuplesPerNode","def map(self, start = \"<START>\", end = \"<END>\", unknown = \"<UNKNOWN>\"):\n return [(self._seq2Indices(s, self.sourceVocab, start = start, end = end, unknown = unknown),\n self._seq2Indices(t, self.targetVocab, start = start, end = end, unknown = unknown)\n ) for s, t in zip(self.source, self.target)]","def nlp_merge_common_matches(matches):\n\n merged_matches = []\n\n for idx_1, start_1, end_1 in matches:\n\n curr_idx = idx_1\n curr_start = start_1\n curr_end = end_1\n\n for idx_2, start_2, end_2 in matches:\n\n if (start_2 < curr_start and end_2 > curr_end) or (start_2 <= curr_start and end_2 > curr_end) or (\n start_2 < curr_start and end_2 >= curr_end):\n curr_idx = idx_2\n curr_start = start_2\n curr_end = end_2\n\n merged_matches.append((curr_idx, curr_start, curr_end))\n\n return list(set(merged_matches))","def findings_2_idx(findings, corner_2_idx, funcx, funcy):\n idx = []\n for finding in findings:\n x, y = finding\n mesh = np.array(np.meshgrid(funcx(x), funcy(y))).swapaxes(1,2).reshape(2,-1).T\n idx.extend([corner_2_idx(c) for c in mesh])\n\n return np.unique(idx)","def switch_distance(pair_1, pair_2):\r\n\th1_1=pair_1[0]\r\n\th2_1=pair_2[0]\r\n\th2_2=pair_2[1]\r\n\tcnt_1=0\r\n\tcnt_2=0\r\n\t# print h2_1, h1_1\r\n\tfor i in xrange(0,len(pair_1[0])):\r\n\t\tif h2_1[i]!=h1_1[i]:\r\n\t\t\th2_1, h2_2=switch(h2_1, h2_2, i)\r\n\t\t\t# print h2_1, h2_2, i\r\n\t\t\tcnt_1+=1\r\n\tprint h2_1, h1_1\r\n\th1_1=pair_1[0]\r\n\th2_1=pair_2[0]\r\n\th2_2=pair_2[1]\r\n\tfor i in xrange(0,len(pair_1[0])):\r\n\t\tif h2_2[i]!=h1_1[i]:\r\n\t\t\th2_1, h2_2=switch(h2_1, h2_2, i)\r\n\t\t\t# print h2_1, h2_2, i\r\n\t\t\tcnt_2+=1\r\n\t# print cnt_1, cnt_2\r\n\treturn cnt_1 if cnt_1<cnt_2 else cnt_2","def prepare_initial_nodes(x_start, x_end, nodes_y):\n nodes_x = [float(x_start + ((x_end - x_start) / (len(nodes_y) - 1)) * i) for i in range(0, len(nodes_y))]\n nodes_y = [float(y) for y in nodes_y]\n print(nodes_x)\n print(nodes_y)\n nodes = list(zip(nodes_x, nodes_y))\n return nodes","def update_id2idx(self):\n self._id2idx = {}\n for n, cell in enumerate(self._cell_list):\n self._id2idx[cell.id()] = n","def compute_distance_pairs(cities):\n global distances_pair\n for city_from in cities:\n distances_pair.append([0 for r in range(city_from.index)]) # create\n for city_to in cities[:city_from.index]:\n distances_pair[city_from.index][city_to.index] = city_from.compute_distance_to_city_in_km(city_to)","def linear_merge(sorted1, sorted2):\n first_pointer = 0\n second_pointer = 0\n sorted_result = []\n\n while second_pointer < len(sorted2) and first_pointer < len(sorted1):\n if sorted1[first_pointer] < sorted2[second_pointer]:\n sorted_result.append(sorted1[first_pointer])\n first_pointer += 1\n else:\n sorted_result.append(sorted2[second_pointer])\n second_pointer += 1\n\n while second_pointer < len(sorted2):\n sorted_result.append(sorted2[second_pointer])\n second_pointer += 1\n\n while first_pointer < len(sorted1):\n sorted_result.append(sorted1[first_pointer])\n first_pointer += 1\n\n\n return sorted_result","def get_matches(self, first, second):\n matches = self._match_table.dropna(0)[\n [first.position.id, second.position.id]].astype(int).values\n return matches","def all_pairs(items, sort=False):\n if sort:\n items = sorted(items)\n for i, ni in enumerate(items):\n for j, nj in enumerate(items):\n if j > i: yield ni, nj","def find_near_nodes(self, new_node):\n number_nodes = len(self.node_list) + 1\n r = self.connect_circle_dist * math.sqrt(\n (math.log(number_nodes) / number_nodes)\n )\n\n # if expand_dist exists, search vertices in a range no more than expand_dist\n if hasattr(self, \"expand_dis\"):\n r = min(r, self.expand_dis)\n dist_list = [\n (node.x - new_node.x) ** 2 + (node.y - new_node.y) ** 2\n for node in self.node_list\n ]\n near_indexes = [dist_list.index(i) for i in dist_list if i <= r ** 2]\n return near_indexes","def match(a1, a2):\n inds_1, inds_2 = [], []\n i, j = 0, 0\n for s in range(0, len(a1)):\n increment = lambda a, x, ind: x+1 if a[ind] != \"-\" else x\n if a1[s] is a2[s] and a1[s] != \"-\":\n inds_1.append(i)\n inds_2.append(j)\n i = increment(a1,i,s)\n j = increment(a2,j,s)\n return inds_1, inds_2","def rearrange_indices(self):\n num_fixed_words = 2\n other_words = [w for w in self.word2index if w not in self.equivariant_words]\n for idx, word in enumerate(self.equivariant_words):\n w_idx = idx + num_fixed_words\n self.word2index[word] = w_idx\n self.index2word[w_idx] = word\n for idx, word in enumerate(sorted(other_words)):\n w_idx = idx + num_fixed_words + self.num_equivariant_words\n self.word2index[word] = w_idx\n self.index2word[w_idx] = word","def nn_match(descs1, descs2):\n # diff = descs1[:, None, :] - descs2[None, :, :]\n # diff = np.linalg.norm(diff, ord=2, axis=2)\n # indices = np.argmin(diff, axis=1)\n\n flann = cv2.FlannBasedMatcher_create()\n matches = flann.match(descs1.astype(np.float32), descs2.astype(np.float32))\n indices = [x.trainIdx for x in matches]\n\n return indices","def expand_ranges(ranges):\n for low, high in low_high_pairs:\n for j in range(low, high+1):\n yield j","def coor2idx(x, y):\r\n a = round(x/4000,0)*4000\r\n b = (round_down(y/4000,0)+0.5)*4000\r\n i = int((a - 24000)/4000) + 1\r\n j = int((b - 22000)/4000) + 1\r\n return i, j","def pair_iterator(self, src_indices, tgt_indices, batch_size, data):\n\n def _select_from_pool(indices):\n \"\"\"Selects batch_size indices from the provided list.\"\"\"\n num_indices = len(indices)\n if num_indices > 0:\n idxs = self.rng.randint(0, high=num_indices, size=(batch_size,))\n indices_batch = indices[idxs]\n features_batch = data.get_features(indices_batch)\n labels_batch = data.get_labels(indices_batch)\n else:\n features_shape = [0] + list(data.features_shape)\n indices_batch = np.zeros(shape=(0,), dtype=np.int64)\n features_batch = np.zeros(shape=features_shape, dtype=np.float32)\n labels_batch = np.zeros(shape=(0,), dtype=np.int64)\n return indices_batch, features_batch, labels_batch\n\n while True:\n indices_src, features_src, labels_src = _select_from_pool(src_indices)\n indices_tgt, features_tgt, labels_tgt = _select_from_pool(tgt_indices)\n yield (indices_src, indices_tgt, features_src, features_tgt, labels_src,\n labels_tgt)","def get_sources_and_targets(index_pairings):\n\n source_target_dictionary = {}\n links_list = []\n \n itr = 0\n \n for pair in index_pairings:\n source = pair[0]\n target = pair[1]\n\n source_target_dictionary = {\"source\":source, \"target\":target}\n links_list.append(source_target_dictionary)\n\n return links_list","def get_chunk_ids_from_node_ids(self, node_ids: Iterable[np.uint64]\n ) -> np.ndarray:\n # TODO: measure and improve performance(?)\n return np.array(list(map(lambda x: self.get_chunk_id(node_id=x),\n node_ids)), dtype=np.uint64)","def _create_two_group_jackknife_indexes(x0, x1, is_paired):\n\n if is_paired and len(x0) == len(x1):\n out = list(zip([j for j in create_jackknife_indexes(x0)],\n [i for i in create_jackknife_indexes(x1)]\n )\n )\n else:\n jackknife_c = list(zip([j for j in create_jackknife_indexes(x0)],\n [i for i in create_repeated_indexes(x1)]\n )\n )\n\n jackknife_t = list(zip([i for i in create_repeated_indexes(x0)],\n [j for j in create_jackknife_indexes(x1)]\n )\n )\n out = jackknife_c + jackknife_t\n del jackknife_c\n del jackknife_t\n\n return out","def sort_indices(self, list_of_indexes):\n return sorted(list_of_indexes, key=lambda index: tuple(int(i) for i in index.split(\".\")))","def match_min2(coords1,coords2,tail1=(),tail2=()):\n nc=len(coords1)\n np1=len(coords1[0])\n np2=len(coords2[0])\n a1=array(coords1)\n a2=array(coords2)\n nt1=len(tail1)\n for i in range(nt1): \n if len(tail1[i])!= np1: raise 'Not the same lenght as coordinates 1'\n nt2=len(tail2)\n for i in range(nt2): \n if len(tail2[i])!= np2: raise 'Not the same lenght as coordinates 2'\n match=zeros(np1, int)-1\n dist_min=zeros(np1)*1.\n x2=zeros(np1)*1.\n y2=zeros(np1)*1.\n for j in range(np1):\n #dist=add.reduce((a1[:,j,NewAxis]-a2[:,:])**2)\n a1j = a1[:,j]\n dist=add.reduce((reshape(a1j, (len(a1j), 1)) - a2)**2)\n i_min=argmin(dist)\n dist_min[j]=dist[i_min]\n x2[j],y2[j]=a2[0,i_min],a2[1,i_min]\n match[j]=i_min\n \n salida=list(a1)\n salida.append(x2)\n salida.append(y2)\n\n for i in range(nt1):salida.append(tail1[i])\n \n for i in range(nt2):\n if type(tail2[i][0])==type('si'):\n t=[]\n for j in match: t.append(tail2[i][j])\n else:\n t=take(tail2[i],match)\n salida.append(t)\n\n salida.append(dist_min)\n return tuple(salida)","def get_pairwise_matches(pos1, descs1, pos2, descs2, up_to=30):\n assert pos1.shape[0] * pos2.shape[0] < 1e8, \\\n \"Too many points: increase cornerness threshold\"\n assert pos1.shape[0] > 10 and pos1.shape[0] > 10, \\\n \"Not enough points: lower cornerness threshold\"\n # get the similarities between all descriptors\n sims = np.dot(descs1, descs2.T)\n # get the best matches\n mi2 = sims.argmax(axis=1).squeeze()\n ms = sims.max(axis=1).squeeze()\n bmi1 = ms.argsort()[::-1][:up_to]\n bmi2 = mi2[bmi1]\n # return their positions\n bp1 = pos1[bmi1]\n bp2 = pos2[bmi2]\n return bp1, bp2","def _intersecting_index(ar1, ar2):\n try:\n _, comm1, comm2 = np.intersect1d(ar1, ar2, return_indices=True)\n # return_indices option needs numpy 1.15.0\n except TypeError:\n comm1 = []\n comm2 = []\n for idx, i in enumerate(ar1):\n for jdx, j in enumerate(ar2):\n if i == j:\n comm1.append(idx)\n comm2.append(jdx)\n break\n comm1 = np.sort(comm1)\n comm2 = np.sort(comm2)\n\n return comm1, comm2","def find_inlet_nodes(nodes, inlets_shp, gdobj):\r\n\r\n # Check that CRSs match; reproject inlet points if not\r\n inlets_gpd = gpd.read_file(inlets_shp)\r\n mask_crs = CRS(gdobj.GetProjection())\r\n if inlets_gpd.crs != mask_crs:\r\n inlets_gpd = inlets_gpd.to_crs(mask_crs)\r\n logger.info('Provided inlet points file does not have the same CRS as provided mask. Reprojecting.')\r\n\r\n # Convert all nodes to xy coordinates for distance search\r\n nodes_xy = gu.idx_to_coords(nodes['idx'], gdobj)\r\n\r\n # Map provided inlet nodes to actual network nodes\r\n inlets = []\r\n for inlet_geom in inlets_gpd.geometry.values:\r\n # Distances between inlet node and all nodes in network\r\n xy = inlet_geom.xy\r\n dists = np.sqrt((xy[0][0]-nodes_xy[0])**2 + (xy[1][0]-nodes_xy[1])**2)\r\n inlets.append(nodes['id'][np.argmin(dists)])\r\n\r\n # Append inlets to nodes dict\r\n nodes['inlets'] = inlets\r\n\r\n return nodes","def _get_indices_2(image_set, min_groups, num_labels=2, num_protected=2):\r\n indices = [[[] for _ in range(num_protected)] for _ in range(num_labels)]\r\n for i, (_, label, _, index) in enumerate(image_set):\r\n indices[label][int(image_set.samples[i][0].split(\"/\")[-1] in min_groups[label])].append(index)\r\n\r\n return indices","def match_min(coords1,coords2,tail1=(),tail2=()):\n nc=len(coords1)\n np1=len(coords1[0])\n np2=len(coords2[0])\n a1=array(coords1)\n a2=array(coords2)\n nt1=len(tail1)\n for i in range(nt1): \n if len(tail1[i])!= np1: raise 'Not the same lenght as coordinates 1'\n nt2=len(tail2)\n for i in range(nt2): \n if len(tail2[i])!= np2: raise 'Not the same lenght as coordinates 2'\n match=zeros(np1, int)-1\n\n dist_min=zeros(np1)*1.\n\n for j in range(np1):\n #dist=sqrt(add.reduce((a1[:,j,NewAxis]-a2[:,:])**2))\n a1j = a1[:,j]\n dist=add.reduce((reshape(a1j, (len(a1j), 1)) - a2)**2)\n i_min=argmin(dist)\n dist_min[j]=dist[i_min]\n match[j]=i_min\n\n salida=list(a1)\n for i in range(nt1):salida.append(tail1[i])\n \n for i in range(nt2):\n if type(tail2[i][0])==type('si'):\n t=[]\n for j in match: t.append(tail2[i][j])\n else:\n t=take(tail2[i],match)\n salida.append(t)\n\n salida.append(dist_min)\n return tuple(salida)","def match_nodes(source_node, target_node):\n\n node_position = cmds.xform(source_node, q=True, ws=True, t=True)\n node_rotation = cmds.xform(source_node, q=True, ws=True, ro=True)\n cmds.xform(target_node, ws=True, t=node_position)\n cmds.xform(target_node, ws=True, ro=node_rotation)","def get_move_indexes(i, j):\n return (i, j), (j, n - 1 - i), (n - 1 - i, n - 1 - j), (n - 1 - j, i)","def build_verticies(list_of_tuples):\n result = defaultdict(list)\n for (from_node, to_node), cost in list_of_tuples:\n from_action = Action(to_node, cost)\n result[from_node].append(from_action)\n to_action = Action(from_node, cost)\n result[to_node].append(to_action)\n\n return result","def findSubsetIndices(min_lat,max_lat,min_lon,max_lon,lats,lons):\n res=np.zeros((4),dtype=np.float64)\n minLon=min_lon; maxLon=max_lon\n\n distances1 = []; distances2 = []\n indices=[]; index=1\n\n for point in lats:\n s1 = max_lat-point # (vector subtract)\n s2 = min_lat-point # (vector subtract)\n distances1.append((np.dot(s1, s1), point, index))\n distances2.append((np.dot(s2, s2), point, index-1))\n index=index+1\n\n distances1.sort()\n distances2.sort()\n indices.append(distances1[0])\n indices.append(distances2[0])\n\n distances1 = []; distances2 = []; index=1\n\n for point in lons:\n s1 = maxLon-point # (vector subtract)\n s2 = minLon-point # (vector subtract)\n distances1.append((np.dot(s1, s1), point, index))\n distances2.append((np.dot(s2, s2), point, index-1))\n index=index+1\n\n distances1.sort()\n distances2.sort()\n indices.append(distances1[0])\n indices.append(distances2[0])\n\n # Save final product: max_lat_indices,min_lat_indices,max_lon_indices,min_lon_indices\n minJ=indices[1][2]\n maxJ=indices[0][2]\n minI=indices[3][2]\n maxI=indices[2][2]\n\n res[0]=minI; res[1]=maxI; res[2]=minJ; res[3]=maxJ\n return res","def _store_nodes(\n self,\n node_hashes: Tuple[Hash32, ...],\n nodes: NodeDataBundles,\n urgent: bool) -> Tuple[NodeDataBundles, bool]:\n\n new_nodes = tuple(\n (node_hash, node) for node_hash, node in nodes\n if node_hash not in self._db\n )\n\n if new_nodes:\n # batch all DB writes into one, for performance\n with self._db.atomic_batch() as batch:\n for node_hash, node in new_nodes:\n batch[node_hash] = node\n\n # Don't bother checking if the nodes were found another way\n found_independent = False\n elif urgent:\n # Check if the nodes were found another way, if they are urgently needed\n for requested_hash in node_hashes:\n if requested_hash in self._db:\n found_independent = True\n break\n else:\n found_independent = False\n else:\n # Don't bother checking if the nodes were found another way, if they are predictive\n found_independent = False\n\n return new_nodes, found_independent","def map_secondary_2_primary_ANs(ids_2_map, Secondary_2_Primary_IDs_dict=None, read_from_flat_files=False):\n if Secondary_2_Primary_IDs_dict is None:\n ### don't read this from flat files (VERY slow) if there is a DB and low_memory then use DB\n Secondary_2_Primary_IDs_dict = get_Secondary_2_Primary_IDs_dict_from_sec(ids_2_map, read_from_flat_files)\n Secondary_2_Primary_IDs_dict_userquery = {}\n for id_ in ids_2_map:\n try:\n prim = Secondary_2_Primary_IDs_dict[id_]\n except KeyError:\n prim = False\n if prim:\n Secondary_2_Primary_IDs_dict_userquery[id_] = prim\n return Secondary_2_Primary_IDs_dict_userquery","def merge_nodes(self, node_ids):\n node_ids = sorted(node_ids)\n\n # Make sure no duplicate node_ids.\n for i in range(len(node_ids) - 1):\n assert node_ids[i] != node_ids[i + 1], \"Duplicate node IDs.\"\n\n # Make sure nodes are the same type.\n for i in range(1, len(node_ids)):\n n1 = self.nodes[node_ids[0]]\n n2 = self.nodes[node_ids[i]]\n assert n1.__class__ == n2.__class__, \"%s %s\" % (\n n1.__class__, n2.__class__)\n\n # Keep the first node, and delete the rest.\n\n # Make transitions to any node_ids point to the first one.\n node_id = node_ids[0]\n prev_ids = []\n for nid in node_ids[1:]:\n x = _get_parents_of(self, nid)\n prev_ids.extend(x)\n transitions = self.transitions.copy()\n for prev_id in prev_ids:\n x = transitions[prev_id]\n if node_id not in x:\n x = x + [node_id]\n transitions[prev_id] = x\n\n # Make the first node point to all the next_nodes of the other\n # node_ids.\n nid0 = node_ids[0]\n for nidi in node_ids[1:]:\n x = transitions.get(nid0, []) + transitions.get(nidi, [])\n x = sorted({}.fromkeys(x))\n transitions[nid0] = x\n\n x = Network(self.nodes, transitions)\n x = x.delete_nodes(node_ids[1:])\n return x"],"string":"[\n \"def get_matching_nodeids(small_dmrs, large_dmrs, all_surface=False):\\n sorted_small_nodes = sort_nodes(small_dmrs.nodes)\\n sorted_large_nodes = sort_nodes(large_dmrs.nodes)\\n\\n longest_matches = find_longest_matches(sorted_small_nodes, sorted_large_nodes) # list (of lists) of tuples (id_from_sub, id)\\n\\n all_matched_nodeids = []\\n for match in longest_matches:\\n matched_large_orderids = list(zip(*match))[1] # [(order ids from small dmrs), (order ids from the\\n paired_nodeids = get_matched_nodeids_from_orderids(sorted_small_nodes, sorted_large_nodes, match)\\n if all_surface:\\n extra_overlap_nodeids = find_extra_surface_overlap(matched_large_nodeids, sorted_large_nodes)\\n paired_nodeids.extend([(None, nodeid) for nodeid in extra_overlap_nodeids])\\n all_matched_nodeids.append(paired_nodeids)\\n\\n return all_matched_nodeids\",\n \"def compare_nodes(G,all_match_pairs,match_pair,traversed,node1,node2, ports_weight):\\n logger.debug(f\\\"comparing {node1},{node2}, traversed {traversed}\\\")\\n nbrs1 = sorted(set(G.neighbors(node1)) - set(traversed))\\n #remove dummies\\n nbrs1 = sorted(set([nbr for nbr in nbrs1 if G.get_edge_data(node1, nbr)['weight'] !=7]))\\n nbrs2 = sorted(set(G.neighbors(node2)) - set(traversed))\\n #remove dummies\\n nbrs2 = sorted(set([nbr for nbr in nbrs2 if G.get_edge_data(node2, nbr)['weight'] !=7]))\\n logger.debug(f\\\"node1:{node1},property: {G.nodes[node1]},neigbors1: {nbrs1}\\\")\\n logger.debug(f\\\"node2:{node2},property: {G.nodes[node2]},neigbors2: {nbrs2}\\\")\\n if not nbrs1 or not nbrs2:\\n if compare_two_nodes(G, node1, node2, ports_weight):\\n match_pair[node1] = node2\\n logger.debug(f\\\"no new neihbours, returning recursion {match_pair}\\\")\\n return\\n elif len(nbrs1)> 10:\\n if \\\"start_point\\\" in match_pair.keys():\\n match_pair[\\\"start_point\\\"]+=[node1,node2]\\n else:\\n match_pair[\\\"start_point\\\"]=[node1,node2]\\n logger.debug(f\\\"skipping high fanout nets due to large computation, {node1} {nbrs1}\\\")\\n traversed.append(node1)\\n return\\n elif len(nbrs2)> 10:\\n if \\\"start_point\\\" in match_pair.keys():\\n match_pair[\\\"start_point\\\"]+=[node1,node2]\\n else:\\n match_pair[\\\"start_point\\\"]=[node1,node2]\\n traversed.append(node2)\\n logger.debug(f\\\"skipping high fanout nets due to large computation, {node2} {nbrs2}\\\")\\n return\\n\\n if node1 == node2:\\n if node1 in match_pair.keys() or node1 in match_pair.values():\\n logger.debug(\\\"avoid existing pair wise symmetry\\\")\\n return\\n logger.debug(f\\\"single node {node1}, nbrs {nbrs1}, nbr_weight {[G.get_edge_data(node1,nbr) for nbr in nbrs1]}\\\")\\n SD_nbrs= [nbr for nbr in nbrs1 if G.get_edge_data(node1, nbr)['weight'] !=2]\\n ## TBD: filter based on primitive constraints\\n ## Right now will try to figure out S/D paths\\n if len(SD_nbrs) ==0:\\n logger.debug(f\\\"No SD paths found to traverse\\\")\\n match_pair[node1]=node1\\n elif len(SD_nbrs) ==1:\\n logger.debug(f\\\"traversing single S/D path {SD_nbrs}\\\")\\n match_pair[node1]=node1\\n traversed.append(node1)\\n compare_nodes(G,all_match_pairs,match_pair,traversed,SD_nbrs[0],SD_nbrs[0],ports_weight)\\n else:\\n logger.debug(f\\\" multiple nodes diverging {SD_nbrs}\\\")\\n logger.debug(f\\\"nbr weights: {SD_nbrs} {[G.get_edge_data(node1, nbr)['weight'] for nbr in SD_nbrs ]}\\\")\\n match_pair[node1]=node1\\n traversed.append(node1)\\n new_sp=sorted(set(SD_nbrs)-set(traversed))\\n all_match_pairs_local={}\\n for nbr1,nbr2 in combinations(new_sp, 2):\\n logger.debug(f\\\"recursive pair call from single branch {nbr1} {nbr2}\\\")\\n new_pair={}\\n compare_nodes(G,all_match_pairs,new_pair,traversed.copy(),nbr1,nbr2,ports_weight)\\n if new_pair:\\n #new_pair[nbr1]=nbr2\\n all_match_pairs_local[nbr1+'_'+nbr2] = new_pair\\n all_match_pairs_local={k: v for k, v in all_match_pairs_local.items() if len(v)>0}\\n if len(all_match_pairs_local)==1:\\n match_pair.update( all_match_pairs_local[list(all_match_pairs_local.keys())[0]])\\n logger.debug(f\\\"found inline pair: {pprint.pformat(match_pair, indent=4)}\\\")\\n else:\\n for nbr1 in new_sp:\\n if (nbr1+'_'+nbr1 not in all_match_pairs.keys()):\\n logger.debug(f\\\"recursive single branch call from single branch {nbr1} {nbr1}\\\")\\n new_pair={}\\n compare_nodes(G,all_match_pairs,new_pair,traversed.copy(),nbr1,nbr1,ports_weight)\\n #filtering multiple axis of symmetries with same block, ideally they should be handled by array generation\\n if new_pair:\\n all_match_pairs[nbr1+'_'+nbr1] = new_pair\\n logger.debug(f\\\"updating match pairs: {pprint.pformat(all_match_pairs, indent=4)}\\\")\\n\\n\\n elif nbrs1 == nbrs2:\\n logger.debug(f\\\"traversing converging branch\\\")\\n match_pair[node1]=node2\\n traversed+=[node1,node2]\\n nbrs1=sorted(set(nbrs1)-set([node1,node2]))\\n logger.debug(f\\\"all non traversed neighbours: {nbrs1}\\\")\\n if len(nbrs1)==1:\\n nbr1=nbr2=nbrs1[0]\\n logger.debug(f\\\"keeping single converged branch inline {nbr1} {nbr2}\\\")\\n compare_nodes(G,all_match_pairs,match_pair,traversed.copy(),nbr1,nbr2,ports_weight)\\n else:\\n for nbr1,nbr2 in combinations_with_replacement(nbrs1,2):\\n logger.debug(f\\\"recursive call from converged branch {nbr1} {nbr2}\\\")\\n if nbr1+'_'+nbr2 not in all_match_pairs.keys():\\n new_pair={}\\n compare_nodes(G,all_match_pairs,new_pair,traversed.copy(),nbr1,nbr2,ports_weight)\\n #filtering multiple axis of symmetries with same block, ideally they should be handled by array generation\\n if new_pair:\\n all_match_pairs[nbr1+'_'+nbr2] = new_pair\\n logger.debug(f\\\"updating match pairs: {pprint.pformat(all_match_pairs, indent=4)}\\\")\\n\\n\\n elif compare_two_nodes(G,node1,node2,ports_weight):\\n nbrs1 = sorted(set([nbr for nbr in nbrs1 if G.get_edge_data(node1, nbr)['weight'] !=2]))\\n nbrs2 = sorted(set([nbr for nbr in nbrs2 if G.get_edge_data(node2, nbr)['weight'] !=2]))\\n match_pair[node1]=node2\\n traversed+=[node1,node2]\\n logger.debug(f\\\"Traversing parallel branches from {node1},{node2} {nbrs1}, {nbrs2}\\\")\\n nbrs1_wt = [G.get_edge_data(node1, nbr)['weight'] for nbr in nbrs1]\\n nbrs2_wt = [G.get_edge_data(node2, nbr)['weight'] for nbr in nbrs2]\\n unique_match=find_unique_matching_branches(G,nbrs1,nbrs2,ports_weight)\\n if len(nbrs1)==0 or len(nbrs2)==0:\\n logger.debug(f\\\"no new SD neihbours, returning recursion {match_pair}\\\")\\n elif len(nbrs1) ==1 and len(nbrs2)==1:\\n logger.debug(f\\\"traversing binary branch\\\")\\n compare_nodes(G,all_match_pairs,match_pair,traversed,nbrs1.pop(),nbrs2.pop(),ports_weight)\\n elif unique_match:\\n logger.debug(f'traversing unique matches {unique_match}')\\n match_pair[node1]=node2\\n traversed+=[node1,node2]\\n for nbr1,nbr2 in unique_match.items():\\n logger.debug(f\\\"recursive call from binary {node1}:{node2} to {nbr1}:{nbr2}\\\")\\n compare_nodes(G,all_match_pairs,match_pair,traversed.copy(),nbr1,nbr2,ports_weight)\\n elif len(nbrs1_wt)>len(set(nbrs1_wt))>1 and len(nbrs2_wt)>len(set(nbrs2_wt))>1:\\n logger.debug(f\\\"setting new start points {node1} {node2}\\\")\\n match_pair[node1]=node2\\n if \\\"start_point\\\" in match_pair.keys():\\n match_pair[\\\"start_point\\\"]+=[node1,node2]\\n else:\\n match_pair[\\\"start_point\\\"]=[node1,node2]\\n else:\\n match_pair = {}\\n logger.debug(f\\\"end all traversal from binary branch {node1} {node2}\\\")\\n\\n else:\\n match_pair = {}\\n logger.debug(f\\\"end of recursion branch, matches {match_pair}\\\")\",\n \"def selectCompatibleIndices(bigTimes, smallTimes):\\r\\n indices = []\\r\\n for idx, _ in enumerate(smallTimes):\\r\\n distances = (bigTimes - smallTimes[idx])**2\\r\\n def getValue(k):\\r\\n return distances[k]\\r\\n thisIndices = sorted(range(len(distances)), key=getValue)\\r\\n indices.append(thisIndices[0])\\r\\n return np.array(indices)\",\n \"def find_extra_surface_nodeids(orderids, sorted_large_nodes):\\n extra_nodeids = []\\n first_overlap_orderid = orderids[0]\\n min_cfrom = sorted_nodes[first_overlap_orderid].cfrom\\n\\n # Check if any earlier nodes also in the region.\\n while True:\\n prev_cfrom = sorted_nodes[first_overlap_orderid-1].cfrom\\n if prev_cfrom == min_cfrom:\\n first_overlap_orderid -= 1\\n extra_nodeids.append(sorted_nodes[first_overlap_orderid].nodeid)\\n else:\\n break\\n\\n # Find the last node in the region.\\n last_overlap_orderid = matched_orderids[-1]\\n max_cto = sorted_nodes[last_overlap_orderid].cto\\n for i in range(first_overlap_orderid, len(sorted_nodes)):\\n if sorted_nodes[i].cfrom > max_cto:\\n break\\n else:\\n if i not in orderids:\\n extra_nodeids.append(sorted_nodes[i].nodeid)\\n cto = sorted_nodes[i].cto\\n if cto >= max_cto:\\n max_cto = cto\\n if i > last_overlap_orderid:\\n last_overlap_orderid = i\\n\\n return extra_nodeids\",\n \"def _pair_indices(self):\\n indices_src = []\\n indices_dst = []\\n for i in range(self.walk_len):\\n for j in range(max(i - self.l, 0), i):\\n indices_src.append(i)\\n indices_dst.append(j)\\n for j in range(i + 1, min(i + self.r + 1, self.walk_len)):\\n indices_src.append(i)\\n indices_dst.append(j)\\n return indices_src, indices_dst\",\n \"def splitNodes(matching):\\n outer = set(range(self.n))\\n inner = set([])\\n for (u, v) in matching:\\n if u in outer:\\n outer.remove(u)\\n if v in outer:\\n outer.remove(v)\\n inner.add(u)\\n inner.add(v)\\n return list(inner), list(outer)\",\n \"def __find_similar_pairs(self):\\n size = len(self.__indexclusters)\\n candidates = []\\n for i in range(size):\\n for j in range(i+1, size):\\n simi = self.__cluster_simi(i, j)\\n #print simi, self.__indexclusters[i],self.__indexclusters[j]\\n if simi >= self.__threshold:\\n candidates.append((simi, i, j))\\n candidates.sort(reverse = True, key = lambda x: x[0])\\n\\n\\n # filter overlapped pairs\\n to_remove = set()\\n appeared = set()\\n for index, cand in enumerate(candidates):\\n if cand[1] not in appeared and cand[2] not in appeared:\\n appeared.add(cand[1])\\n appeared.add(cand[2])\\n else:\\n to_remove.add(index)\\n\\n #print 'ahha'\\n #print [(cand[1], cand[2]) for index, cand in enumerate(candidates) if index not in to_remove]\\n\\n return [(cand[1], cand[2]) for index, cand in enumerate(candidates)\\n if index not in to_remove]\",\n \"def pairs_from_knn(ind):\\n \\n NN = ind.shape[1]\\n source_nodes = np.repeat(ind[:,0], NN-1).reshape(-1,1)\\n target_nodes = ind[:,1:].reshape(-1,1)\\n pairs = np.hstack((source_nodes, target_nodes))\\n pairs = remove_duplicate_pairs(pairs)\\n return pairs\",\n \"def find_longest_matches(sorted_nodes1, sorted_nodes2):\\n root = TreeNode(-1,-1)\\n fill_tree(root, sorted_nodes1, sorted_nodes2)\\n match = find_treepaths(root, [])\\n\\n # Remove (-1, -1) superroot.\\n if isinstance(match[0], list): # More than one match of the same length.\\n res = []\\n for m in match:\\n res.append([node.to_tuple() for node in m[1:]])\\n return res\\n else:\\n return [[node.to_tuple() for node in match[1:]]]\",\n \"def _gen_matches(target_units, source_units, stoplist_set, features_size):\\n for hits2positions in gen_hits2positions(\\n target_units, source_units, stoplist_set, features_size):\\n overhits2positions = {\\n k: np.array(v) for k, v in hits2positions.items()\\n if len(v) >= 2}\\n for (t_ind, s_ind), positions in overhits2positions.items():\\n yield (t_ind, s_ind, positions)\",\n \"def map_nodes(dist1, dist2, lcnt, op, mode=None):\\n # TODO: Modify the functions citing this function, so that we can avoid use \\\"mode\\\" in this function.\\n # The only difference is the format of dist2\\n \\n tmp = 0\\n map_dict = []\\n for i in range(0, lcnt):\\n map_dict.append(i)\\n \\n if mode == None:\\n if len(dist1)==len(dist2):\\n dist_M = np.zeros((len(dist1), len(dist2)))\\n for i in range(0, len(dist1)):\\n for j in range(0, len(dist2)):\\n dist_M[i,j] = np.linalg.norm(dist1[i]-dist2[j])\\n row_ind, col_ind = linear_sum_assignment(dist_M)\\n for i in range(0, len(col_ind)):\\n map_dict.append(col_ind[i]+lcnt)\\n else:\\n for i in range(0, len(dist1)):\\n idx = find_min_square_dist(dist1[i], dist2, op, map_dict, lcnt)\\n map_dict.append(idx+lcnt)\\n else:\\n if len(dist1)==len(dist2)-lcnt:\\n dist1 = dist1[lcnt:len(dist1),:]\\n dist_M = np.zeros((len(dist1), len(dist2)))\\n for i in range(0, len(dist1)):\\n for j in range(0, len(dist2)):\\n dist_M[i,j] = np.linalg.norm(dist1[i]-dist2[j])\\n row_ind, col_ind = linear_sum_assignment(dist_M)\\n for i in range(0, len(col_ind)):\\n map_dict.append(col_ind[i]+lcnt)\\n else:\\n for i in range(0, len(dist1)):\\n idx = find_min_square_dist(dist1[i], dist2, op, map_dict, lcnt)\\n map_dict.append(idx)\\n\\n return map_dict\",\n \"def __get_merge_nodelist(induced_ordering):\\n duplicate = list(induced_ordering) # create a copy of the list containing the induced ordering\\n return {duplicate.pop(), duplicate.pop()} # return the vertices corresponding to the s-t cut\",\n \"def assign_nodes_to_edges(nodes, edges):\\n\\n from scipy.spatial import cKDTree\\n \\n edges_arr = np.vstack(edges)\\n kdt_nodes = cKDTree(nodes)\\n\\n # closest node id and discard computed distances ('_,')\\n _, pairs = kdt_nodes.query(x=edges_arr, k=1)\\n # refactor list of successive ids for start and end of edges into 2D array\\n pairs = np.vstack((pairs[::2], pairs[1::2])).T\\n\\n new_edges = []\\n for pair in pairs[:,:]:\\n new_edges.append(np.array(nodes[pair]))\\n \\n return new_edges, pairs\",\n \"def node_ids(self):\\n # From: https://stackoverflow.com/questions/17415086/combine-consecutive-numbers-into-range-tuples\\n groups = groupby(self.nodes.keys(), key=lambda item, c=count():item-next(c))\\n temp = [list(g) for k, g in groups]\\n return \\\"+\\\".join(\\\"{}-{}\\\".format(x[0], x[-1]) for x in temp)\",\n \"def __add_neighbours(p1, p2, n1, n2, idx1, idx2, mapping=None, dist1=None,\\n dist2=None, dist_tol=0, pairs=None):\\n\\n if mapping is None:\\n mapping = np.zeros((p1.numnodes, p2.numnodes))\\n\\n for i in range(p1.numnodes):\\n for j in range(p2.numnodes):\\n weighted_freq, _ = compare_nodes(p1.nodes[i], p2.nodes[j])\\n if weighted_freq > 0.0:\\n mapping[i][j] = weighted_freq\\n if dist1 is None:\\n dist1 = distances(p1)\\n dist1[p1.edges > 0] = p1.edges[p1.edges > 0]\\n\\n if dist2 is None:\\n dist2 = distances(p2)\\n dist2[p2.edges > 0] = p2.edges[p2.edges > 0]\\n\\n if pairs is None:\\n pairs = []\\n\\n def is_compatible(pair1, pair2):\\n if (pair1[0] == pair2[0]) or (pair1[1] == pair1[1]):\\n return False\\n if (p1.edges[pair1[0], pair2[0]] != 0) and \\\\\\n (p2.edges[pair1[1], pair2[1]] != 0):\\n dist_diff = math.fabs((p1.edges[pair1[0], pair2[0]] -\\n p2.edges[pair1[1], pair2[1]]))\\n if dist_diff <= dist_tol:\\n return True\\n else:\\n return False\\n else:\\n return True\\n\\n for i1, i2 in zip(idx1, idx2):\\n neighbours1 = []\\n for node in reversed(np.where(p1.edges[i1, n1] > 0)[0]):\\n neighbours1.append(n1[node])\\n n1.remove(n1[node])\\n\\n neighbours2 = []\\n for node in reversed(np.where(p2.edges[i2, n2] > 0)[0]):\\n neighbours2.append(n2[node])\\n n2.remove(n2[node])\\n\\n # find compatible neighbours\\n for neigh1 in neighbours1:\\n for neigh2 in neighbours2:\\n if (mapping[neigh1, neigh2] > 0):\\n dist_diff = np.abs(dist1[idx1, neigh1] -\\n dist2[idx2, neigh2])\\n\\n # there is edge between nodes in at least one of phars\\n connected = np.where(p1.edges[idx1, neigh1] +\\n p2.edges[idx2, neigh2])\\n max_cost = np.max(dist_diff[connected])\\n if (max_cost <= dist_tol):\\n pairs.append((neigh1, neigh2))\\n\\n score = np.sum(mapping[idx1, idx2])\\n dist_diff = np.abs(dist1[idx1][:, idx1] - dist2[idx2][:, idx2])\\n connected = np.where(p1.edges[idx1][:, idx1] + p2.edges[idx2][:, idx2])\\n\\n if len(connected[0]) > 0:\\n assert np.max(dist_diff[connected]) <= dist_tol, \\\"cost too high\\\"\\n cost = np.sum(dist_diff[connected]) / 2.0\\n\\n aln = [idx1[:], idx2[:]]\\n\\n for i, pair in enumerate(pairs):\\n compatible = [p for p in pairs[i+1:] if is_compatible(pair, p)]\\n\\n s, c, (aln1, aln2) = __add_neighbours(p1, p2, n1[:], n2[:],\\n idx1+[pair[0]], idx2+[pair[1]],\\n mapping, dist1, dist2, dist_tol,\\n compatible)\\n\\n if (s - c > score - cost) or (s - c == score - cost and s > score):\\n score = s\\n cost = c\\n aln = [aln1[:], aln2[:]]\\n\\n return score, cost, aln\",\n \"def gen_hits2positions(\\n target_units, source_units, stoplist_set, features_size):\\n target_feature_matrix, target_breaks = _construct_unit_feature_matrix(\\n target_units, stoplist_set, features_size)\\n stepsize = 500\\n for su_start in range(0, len(source_units), stepsize):\\n feature_source_matrix, source_breaks = _construct_feature_unit_matrix(\\n source_units[su_start:su_start+stepsize],\\n stoplist_set,\\n features_size)\\n # for every position of each target unit, this matrix multiplication\\n # picks up which source unit positions shared at least one common\\n # feature\\n match_matrix = target_feature_matrix.dot(feature_source_matrix)\\n # this data structure keeps track of which target unit position matched\\n # with which source unit position\\n coo = match_matrix.tocoo()\\n yield _bin_hits_to_unit_indices(\\n coo.row, coo.col, target_breaks, source_breaks, su_start)\",\n \"def ordered_indices(self):\\r\\n '''we need random order'''\\r\\n if self.shuffle:\\r\\n indices = np.random.permutation(len(self))\\r\\n else:\\r\\n indices = np.arange(len(self))\\r\\n '''\\r\\n if self.tgt_sizes is not None:\\r\\n indices = indices[np.argsort(self.tgt_sizes[indices], kind='mergesort')]\\r\\n return indices[np.argsort(self.src_sizes[indices], kind='mergesort')]\\r\\n '''\\r\\n return indices\",\n \"def _get_common_neighbour_node_pairs(self):\\n node_pairs = []\\n for node1 in self.graph.nodes():\\n for node2 in self.graph.nodes():\\n if node1 != node2:\\n neighbour_count = self.neighbour_counts[(node1, node2)]\\n if neighbour_count >= 1:\\n node_pairs.append((node1, node2))\\n return node_pairs\",\n \"def rearange_nodes_links_old(idx, nodes, links):\\n nodes = nodes[idx,:]\\n for i in range(0, len(links)):\\n links[i, 0] = idx.index(links[i, 0])\\n links[i, 1] = idx.index(links[i, 1])\\n for i in range (0, len(links)):\\n links[i] = sorted(links[i])\\n \\n # Sort links according to the source.\\n links = links[links[:,0].argsort()]\\n idx = update_idx_links(links[:,0], links[:,1])\\n links = links[idx]\\n return nodes, links\",\n \"def rearange_nodes_links(idx, nodes, links):\\n # TODO: Modify functions citing this function, so that we can combine this version with the former one.\\n idx = update_idx(list(idx), nodes[:, 2])\\n idx = list(np.array(idx).argsort())\\n nodes = nodes[idx,:]\\n for i in range(0, len(links)):\\n links[i, 0] = idx.index(links[i, 0])\\n links[i, 1] = idx.index(links[i, 1])\\n for i in range (0, len(links)):\\n links[i] = sorted(links[i])\\n\\n # Sort links according to the source.\\n links = links[links[:,0].argsort()]\\n idx = update_idx_links(links[:,0], links[:,1])\\n links = links[idx]\\n return nodes, links\",\n \"def get_idx_from_latlon(self, latitudes, longitudes, unique=False):\\n try:\\n lat_idx = [np.argmin(np.abs(self.lat - lat)) for lat in latitudes]\\n lon_idx = [np.argmin(np.abs(self.lon - lon)) for lon in longitudes]\\n if unique:\\n ijdx = np.vstack({(i, j) for i, j in zip(lat_idx, lon_idx)})\\n lat_idx = ijdx[:, 0].tolist()\\n lon_idx = ijdx[:, 1].tolist()\\n except TypeError:\\n lat_idx = np.argmin(np.abs(self.lat - latitudes))\\n lon_idx = np.argmin(np.abs(self.lon - longitudes))\\n\\n return lat_idx, lon_idx\",\n \"def greedy_match(cost_matrix):\\n num_detections, num_tracks = cost_matrix.shape\\n distance_1d = cost_matrix.reshape(-1)\\n index_1d = np.argsort(distance_1d)\\n index_2d = np.stack([index_1d // num_tracks, index_1d % num_tracks], axis=1).astype(int, copy=False)\\n\\n matched_indices = []\\n matched_firsts = set()\\n matched_seconds = set()\\n\\n for (first_id, second_id) in index_2d:\\n if first_id not in matched_firsts and second_id not in matched_seconds:\\n matched_seconds.add(second_id)\\n matched_firsts.add(first_id)\\n matched_indices.append([first_id, second_id])\\n return np.array(matched_indices)\",\n \"def get_idxs_in_correct_order(idx1, idx2):\\n if idx1 < idx2: return idx1, idx2\\n else: return idx2, idx1\",\n \"def make_mapping(items):\\n compid, nodes = items\\n nodes = list(nodes)\\n base_node = min(nodes)\\n return [(node,base_node) for node in nodes if node != base_node]\",\n \"def neighbours(assignment): \\n for index_1, index_2 in itertools.combinations(range(len(assignment)), 2):\\n new_assign = list(assignment)\\n new_assign[index_1], new_assign[index_2] = new_assign[index_2], new_assign[index_1]\\n yield tuple(new_assign)\",\n \"def split_at_nodes(shp):\\n nodes = find_nodes(shp)\\n nodeIds = list(nodes)\\n nodeIds.sort()\\n nodeIds = dict([(node,i) for i,node in enumerate(nodeIds)])\\n \\n for road in shp:\\n vrts = road.vertices\\n midVrts = set(road.vertices[1:-1]) #we know end points are nodes\\n midNodes = midVrts.intersection(nodes) # find any nodes in the middle of the feature.\\n midIdx = [vrts.index(node) for node in midNodes] # Get their indices\\n midIdx.sort()\\n if midIdx:\\n #print vrts\\n starts = [0]+midIdx\\n stops = [x+1 for x in midIdx]+[None]\\n for start,stop in zip(starts,stops):\\n feat = pysal.cg.Chain(vrts[start:stop])\\n rec = (nodeIds[feat.vertices[0]],nodeIds[feat.vertices[-1]],False)\\n yield feat,rec\\n else:\\n rec = (nodeIds[road.vertices[0]],nodeIds[road.vertices[-1]],False)\\n yield road,rec\",\n \"def _create_nodes(\\n self, lanelet: Lanelet, left_way_id: str, right_way_id: str\\n ) -> Tuple[List[str], List[str]]:\\n left_nodes, right_nodes = [], []\\n start_index = 0\\n end_index = len(lanelet.left_vertices)\\n pot_first_left_node, pot_first_right_node = self._get_shared_first_nodes_from_other_lanelets(\\n lanelet\\n )\\n pot_last_left_node, pot_last_right_node = self._get_shared_last_nodes_from_other_lanelets(\\n lanelet\\n )\\n if pot_first_left_node:\\n start_index = 1\\n if pot_last_left_node:\\n end_index = -1\\n\\n if left_way_id:\\n first_left_node, last_left_node = self._get_first_and_last_nodes_from_way(\\n left_way_id, lanelet.adj_left_same_direction\\n )\\n else:\\n first_left_node = pot_first_left_node\\n last_left_node = pot_last_left_node\\n left_nodes = self._create_nodes_from_vertices(\\n lanelet.left_vertices[start_index:end_index]\\n )\\n if right_way_id:\\n first_right_node, last_right_node = self._get_first_and_last_nodes_from_way(\\n right_way_id, lanelet.adj_right_same_direction\\n )\\n else:\\n first_right_node = pot_first_right_node\\n last_right_node = pot_last_right_node\\n right_nodes = self._create_nodes_from_vertices(\\n lanelet.right_vertices[start_index:end_index]\\n )\\n\\n if first_left_node:\\n left_nodes.insert(0, first_left_node)\\n if first_right_node:\\n right_nodes.insert(0, first_right_node)\\n\\n if last_left_node:\\n left_nodes.append(last_left_node)\\n if last_right_node:\\n right_nodes.append(last_right_node)\\n\\n return left_nodes, right_nodes\",\n \"def _match_identical_nodes(self):\\n\\n for job_name_b in self._topo_b_nodes:\\n for job_name_a in self._unresolved_a_nodes:\\n if self._is_node_identical(job_name_a, job_name_b):\\n self._identical_nodes[job_name_b] = job_name_a\\n self._unresolved_a_nodes.remove(job_name_a)\\n self._unresolved_b_nodes.remove(job_name_b)\\n break\",\n \"def get_all_possible_os_pairings(indices_list):\\n pairs = []\\n itr = 0\\n\\n for links in indices_list:\\n\\n for item in links:\\n for i in range(itr,len(links)):\\n\\n if item == links[i]:\\n continue\\n else:\\n pair = item, links[i]\\n pairs.append(pair)\\n return pairs\",\n \"def adjacent_pairs(self, nodes: Tuple[int], k: int) -> List[Tuple[int, int]]:\\n n = len(nodes)\\n return [(u, nodes[j % n])\\n for i, u in enumerate(nodes)\\n for j in range(i + 1, i + 1 + k // 2)]\",\n \"def compare_search(sizes=[1e1, 1e2, 1e3, 1e4, 1e5, 1e6, 1e7]):\\n\\tprint(sizes)\\n\\treturn [(size,\\n\\t\\t\\t time_search(linear_search, list(range(int(size))), -1),\\n\\t\\t\\t time_search(binary_search, list(range(int(size))), -1)) for size in sizes]\",\n \"def nid2partid(self, nids):\\n nids = utils.toindex(nids)\\n ret = np.searchsorted(self._node_map, nids.tonumpy(), side='right')\\n ret = utils.toindex(ret)\\n return ret.tousertensor()\",\n \"def _get_index_mapper_list(graph, next_graph, cur_node_start_idx, next_node_start_idx):\\n cur_idx = []\\n next_idx = []\\n\\n next_graph_tag = next_graph.ndata['tag']\\n ally_node_index = get_filtered_node_index_by_type(graph, NODE_ALLY)\\n for cn_index in graph.nodes()[ally_node_index]:\\n curr_tag = graph.ndata['tag'][cn_index]\\n next_graph_index = (next_graph_tag == curr_tag).nonzero().squeeze().int()\\n if next_graph_index.nelement() == 0:\\n pass\\n elif next_graph_index.nelement() == 1:\\n cur_idx.append((cn_index + cur_node_start_idx).tolist())\\n next_idx.append((next_graph_index + next_node_start_idx).tolist())\\n else:\\n raise RuntimeError(\\\"Existing multiple units with same tag in next graph\\\")\\n return cur_idx, next_idx\",\n \"def sort_nodes(self, min_return=5):\\n nodes = self._all_nodes()\\n sorted_nodes, sorted_scores = self.scorer.sort(nodes)\\n\\n if len(nodes) <= min_return:\\n return sorted_nodes, sorted_scores\\n\\n seen_hashes = set()\\n best_nodes = []\\n best_scores = []\\n last_score = 1e16\\n for score, node in zip(sorted_scores, sorted_nodes):\\n if len(best_nodes) >= min_return and score < last_score:\\n break\\n route_actions, _ = self.search_tree.route_to_node(node)\\n route_hash = self._routehash(route_actions)\\n\\n if route_hash in seen_hashes:\\n continue\\n seen_hashes.add(route_hash)\\n best_nodes.append(node)\\n best_scores.append(score)\\n last_score = score\\n\\n return best_nodes, best_scores\",\n \"def get_node_pair_pattern(node1, node2):\\n if int(node1.nid) > int(node2.nid):\\n return f'{node2.nid} - {node1.nid}'\\n else:\\n return f'{node1.nid} - {node2.nid}'\",\n \"def find_mutual_nn(self):\\n best_match_src = self.scores.argmax(1) # Best match for each source word\\n best_match_trg = self.scores.argmax(0) # Best match for each source word\\n\\n # ONELIENER\\n # paired_idx = [(i,best_match_src[i]) for i in range(self.ns) if best_match_trg[best_match_src[i]] == i]\\n # paired_words = [(self.src_words[i],self.trg_words[j]) for (i,j) in paired_idx]\\n paired = []\\n for i in range(self.ns):\\n m = best_match_src[i]\\n if best_match_trg[m] == i:\\n paired.append((i,m))\\n\\n paired_toks = []\\n if self.src_words and self.trg_words:\\n paired_toks = [(self.src_words[i],self.trg_words[j]) for (i,j) in paired]\\n else:\\n paired_toks = paired\\n return paired_toks\",\n \"def match3(img1, img2, coordinates1, coordinates2, PATCH_SIZE, threshold=0.7):\\n\\n\\t#creating patches for all points from img1 and img2\\n\\tcoord1_patches = [make_patch(coordinate, PATCH_SIZE, img1) for coordinate in coordinates1]\\n\\tcoord2_patches = [make_patch(coordinate, PATCH_SIZE, img2) for coordinate in coordinates2]\\n\\n\\t# creating a matrix with dissimilarity measures for all pairs\\n\\tall_matches = np.zeros((len(coordinates1), len(coordinates2)))\\n\\n\\tfor (x, y), _ in np.ndenumerate(all_matches):\\n\\t\\tall_matches[x,y] = count_difference(coord1_patches[x], coord2_patches[y])\\n\\n\\t#looking for best left-to-right and right-to-left matches\\n\\tmatches = []\\n\\t#left-to-right\\n\\tfor i, coord1 in enumerate(coordinates1):\\n\\t\\tbest_ltr_match = np.argmin(all_matches[i, :]) #best left-to-right match for coord1\\n\\t\\tbest_rtl_match = np.argmin(all_matches[:, best_ltr_match]) #best match for a best match\\n\\t\\tif (i == best_rtl_match): #hurray, there is a super match\\n\\n\\t\\t\\tmatches.append([coord1, coordinates2[best_ltr_match], all_matches[i, best_ltr_match]])\\n\\t\\n\\treturn matches\",\n \"def tree_idx2(treeG,k1,J1,J2):\\n g = treeG[J1]['clusters'][k1]\\n if(J1>J2+1):\\n for j in np.arange(J2+1, J1)[::-1]:\\n g1 = []\\n for i in np.arange(0,len(g),1):\\n g1 = np.array(np.append(g1,treeG[j]['clusters'][g[i]]), dtype = int)\\n g = g1\\n y = g\\n return y\",\n \"def hard_examples_mining(dist_mat, identity_mat, return_idxes=False):\\n # the implementation here is a little tricky, dist_mat contains pairwise distance between probe image and other\\n # images in current mini-batch. As we want to select positive examples of the same person, we add a constant\\n # negative offset on other images before sorting. As a result, images of the **same** person will rank first.\\n sorted_dist_mat, sorted_idxes = torch.sort(dist_mat + (-1e7) * (1 - identity_mat), dim=1,\\n descending=True)\\n dist_ap = sorted_dist_mat[:, 0]\\n hard_positive_idxes = sorted_idxes[:, 0]\\n\\n # the implementation here is similar to above code, we add a constant positive offset on images of same person\\n # before sorting. Besides, we sort in ascending order. As a result, images of **different** persons will rank first.\\n sorted_dist_mat, sorted_idxes = torch.sort(dist_mat + 1e7 * identity_mat, dim=1,\\n descending=False)\\n dist_an = sorted_dist_mat[:, 0]\\n hard_negative_idxes = sorted_idxes[:, 0]\\n if return_idxes:\\n return dist_ap, dist_an, hard_positive_idxes, hard_negative_idxes\\n return dist_ap, dist_an\",\n \"def _node_ids(self, nodes=None):\\n if not nodes:\\n nodes = self.nodes\\n if isinstance(nodes[0], integer_types):\\n return nodes\\n return [node.nid for node in nodes]\",\n \"def create_match_instance_pairs(plant_match_in):\\r\\n\\t## collect all plant name match instances indices\\r\\n\\tjust_indices = [int(indices) for plant_match_in_set in plant_match_in for indices in plant_match_in_set[1]]\\r\\n\\t\\r\\n\\tassert len(just_indices) == len(set(just_indices)) # check there are no exact duplicates in indices\\r\\n\\r\\n\\tsorted_index = list(sorted(just_indices)) # sort indices small-large\\r\\n\\tprint(f'Length of corpus bigrams BEFORE ambiguous matches removed: {len(sorted_index)}')\\r\\n\\t#print(sorted_index)\\r\\n\\r\\n\\t# remove all ambiguous matches that are within 1 word of each other\\r\\n\\tprint('Ambiguous plant name matches: ')\\r\\n\\tfor i, index in enumerate(sorted_index): # iterate over all indices in sorted list\\r\\n\\t\\t\\r\\n\\t\\tif index == sorted_index[i-1]+1: # indices is within 1 of previous indices in list\\r\\n\\t\\t\\tprint(index, sorted_index[i-1])\\r\\n\\t\\t\\tsorted_index.remove(index) # remove indices from list\\r\\n\\t\\t\\tsorted_index.remove(sorted_index[i-1]) # AND remove previous indices from list\\r\\n\\tprint(f'Length of corpus bigrams AFTER ambiguous matches removed: {len(sorted_index)}')\\r\\n\\r\\n\\t# create indices dict with 'B', 'I' values\\r\\n\\tpaired_finds = {}\\r\\n\\tfor match_index in sorted_index: # iterate over unambiguous match indices list\\r\\n\\t\\t\\t\\t\\t\\r\\n\\t\\t\\tpaired_finds[match_index] = ('B') # WITH value of 'B'\\r\\n\\t\\t\\t\\r\\n\\t\\t\\tpaired_finds[match_index+1] = ('I') # WITH value of 'I'\\r\\n\\r\\n\\treturn paired_finds\",\n \"def differentNodesForNode(ntupleSet,nodeList,verbose=False):\\n nodesPerNode = dict(zip(nodeList,[[] for n in range(len(nodeList))]))\\n for ntuple in ntupleSet:\\n for nodeInTuple in ntuple:\\n nodesPerNode[nodeInTuple].extend(ntuple)\\n \\n for a,v in nodesPerNode.iteritems():\\n nodesPerNode[a] = set(v)\\n \\n return nodesPerNode\",\n \"def solve_part1(start):\\n inputs = load_inputs(False)\\n two_matches = []\\n tiles = inputs.keys()\\n for elem in tiles:\\n matches = defaultdict(list)\\n for elem2 in tiles:\\n if elem != elem2 and compare_tile(inputs[elem], inputs[elem2]):\\n l = matches[elem]\\n l.append(elem2)\\n\\n if len(matches[elem]) == 2:\\n print matches\\n two_matches.append(elem)\\n\\n return reduce((lambda x, y: int(x) * int(y)), two_matches)\",\n \"def prepare_pairs(self, pairs, input_lang, output_lang, tree=False):\\n\\t\\tprepared_pairs = []\\n\\n\\t\\tfor pair in pairs:\\n\\t\\t\\tinput_seq, eq_segs, nums = pair.input_seq, pair.output_seq, pair.nums\\n\\t\\t\\tnum_stack = []\\n\\t\\t\\tfor word in eq_segs:\\n\\t\\t\\t\\ttemp_num = []\\n\\t\\t\\t\\tflag_not = True\\n\\t\\t\\t\\tif word not in output_lang.index2word:\\n\\t\\t\\t\\t\\tflag_not = False\\n\\t\\t\\t\\t\\tfor num_index, num in enumerate(nums):\\n\\t\\t\\t\\t\\t\\tif num == word:\\n\\t\\t\\t\\t\\t\\t\\ttemp_num.append(num_index)\\n\\n\\t\\t\\t\\tif not flag_not and len(temp_num) != 0:\\n\\t\\t\\t\\t\\tnum_stack.append(temp_num)\\n\\t\\t\\t\\tif not flag_not and len(temp_num) == 0:\\n\\t\\t\\t\\t\\tnum_stack.append([_ for _ in range(len(nums))])\\n\\n\\t\\t\\tnum_stack.reverse()\\n\\n\\t\\t\\tinput_cell = indexes_from_sentence(input_lang, input_seq)\\n\\t\\t\\toutput_cell = indexes_from_sentence(output_lang, eq_segs, tree)\\n\\n\\t\\t\\tpair.input_tokens = input_cell\\n\\t\\t\\tpair.output_tokens = output_cell\\n\\t\\t\\tpair.num_stack = num_stack\\n\\t\\t\\tpair.build_graph()\\n\\n\\t\\t\\tprepared_pairs.append(pair)\\n\\n\\t\\treturn prepared_pairs\",\n \"def _create_pairs(self, sample_ratio):\\n # Broadcast target/source labels into mesh grid\\n # `source` -> (N, 1) broadcast to (N, M)\\n # `target` -> (1, M) broadcast to (N, M)\\n target, source = np.meshgrid(self.y['tgt'], self.y['src'])\\n\\n # Find index pairs (i_S, i_T) for where src_y == tgt_y\\n intra_pair_idxs = np.argwhere(source == target)\\n\\n # Find index pairs (i_S, i_T) for where src_y != tgt_y\\n inter_pair_idxs = np.argwhere(source != target)\\n\\n # Randomly sample the interclass pairs to meet desired ratio\\n if sample_ratio > 0:\\n n_interclass = sample_ratio * len(intra_pair_idxs)\\n np.random.shuffle(inter_pair_idxs)\\n inter_pair_idxs = inter_pair_idxs[:n_interclass]\\n\\n # Sort as to allow shuffling to be performed by the DataLoader\\n inter_pair_idxs = inter_pair_idxs[\\n np.lexsort((inter_pair_idxs[:, 1], inter_pair_idxs[:, 0]))\\n ]\\n\\n return intra_pair_idxs, inter_pair_idxs\",\n \"def expander(i_start, j_end, length):\\n\\n # create list of paired i indices\\n i_s = list(np.arange(i_start, i_start + length))\\n\\n # create list of corresponding j indices:\\n j_s = list(np.arange(j_end, j_end + length))\\n\\n # form list of tuple pairs\\n pairs = list(zip(i_s, j_s))\\n\\n return pairs\",\n \"def graph_generation(nodes: np.ndarray, edges: np.ndarray):\\n result_nodes = []\\n result_edges = []\\n\\n last_index = nodes[-1, 0]\\n\\n done = False\\n # print(nodes)\\n for p in range(nodes.shape[0]):\\n for q in range(nodes.shape[0]):\\n if list(nodes[p, 1:-2]) == (list(nodes[q, 1:-2])) and nodes[p, nodes.shape[1] - 2] < \\\\\\n nodes[q, nodes.shape[1] - 2]:\\n tmp_node = np.append(nodes[p, 1:], np.append(nodes[q, nodes.shape[1] - 2],\\n np.append(nodes[q, nodes.shape[1] - 1],\\n np.append(nodes[p, 0],\\n nodes[q, 0]))))\\n if not done:\\n result_nodes = [tmp_node]\\n done = True\\n else:\\n result_nodes = np.concatenate((result_nodes, [tmp_node]))\\n\\n result_nodes = result_nodes[np.argsort(\\n result_nodes[:, [e for e in range(1, result_nodes.shape[1] - 2) if e % 2 != 0]].sum(axis=1)), :]\\n\\n result_nodes = np.c_[range(last_index + 1, last_index + 1 + result_nodes.shape[0]), result_nodes]\\n # print(result_nodes)\\n\\n done = False\\n for e in range(edges.shape[0]):\\n for f in range(edges.shape[0]):\\n for p in range(result_nodes.shape[0]):\\n for q in range(result_nodes.shape[0]):\\n if (edges[e, 0] == result_nodes[p, -2] and edges[e, 1] == result_nodes[q, -2] and edges[\\n f, 0] == result_nodes[p, -1] and edges[f, 1] == result_nodes[q, -1]) \\\\\\n or (edges[e, 0] == result_nodes[p, -2] and edges[e, 1] == result_nodes[q, -2] and\\n result_nodes[p, -1] == result_nodes[q, -1]) \\\\\\n or (edges[e, 0] == result_nodes[p, -1] and edges[e, 1] == result_nodes[q, -1] and\\n result_nodes[p, -2] == result_nodes[q, -2]):\\n if not done:\\n result_edges = [[result_nodes[p, 0], result_nodes[q, 0]]]\\n done = True\\n else:\\n result_edges = np.concatenate(\\n (result_edges, [[result_nodes[p, 0], result_nodes[q, 0]]]), axis=0)\\n # print(edges)\\n\\n # print(result_edges)\\n unique_result_edges = list(Counter(str(e) for e in result_edges).keys())\\n # print(unique_result_edges)\\n final_edges = []\\n for k in range(len(unique_result_edges)):\\n for j in range(result_edges.shape[0]):\\n if str(result_edges[j]) == unique_result_edges[k]:\\n if k == 0:\\n final_edges = result_edges[j]\\n break\\n else:\\n final_edges = np.concatenate((final_edges, result_edges[j]))\\n break\\n final_edges = np.reshape(final_edges, (int(final_edges.shape[0] / 2), 2))\\n # print(final_edges.shape[0])\\n done = False\\n edge_to_remove = []\\n for j in range(final_edges.shape[0]):\\n for k in range(j + 1, final_edges.shape[0]):\\n if final_edges[j, 1] == final_edges[k, 0]:\\n if not done:\\n edge_to_remove = [[final_edges[j, 0], final_edges[k, 1]]]\\n done = True\\n else:\\n edge_to_remove = np.concatenate((edge_to_remove, [[final_edges[j, 0], final_edges[k, 1]]]))\\n # print(edge_to_remove)\\n\\n idx_to_remove = []\\n done = False\\n for j in range(edge_to_remove.shape[0]):\\n for k in range(final_edges.shape[0]):\\n if list(edge_to_remove[j]) == list(final_edges[k]):\\n if not done:\\n idx_to_remove = k\\n done = True\\n else:\\n idx_to_remove = np.append(idx_to_remove, k)\\n final_edges = np.delete(final_edges, idx_to_remove, axis=0)\\n # print(final_edges)\\n result_nodes = np.delete(result_nodes, [-1, -2], 1)\\n # print(result_nodes)\\n return result_nodes, final_edges\",\n \"def create_index(filenames: list, raw_data_dir: str,\\n processed_data_dir: str) -> None:\\n entities, relations = set(), set()\\n\\n for filename in filenames:\\n file_path = path.join(raw_data_dir, filename)\\n with open(file_path, 'r') as file:\\n for line in file.readlines():\\n mid1, relation, mid2 = line.strip().split('\\\\t')\\n entities.add(mid1)\\n entities.add(mid2)\\n relations.add(relation)\\n\\n logger = logging.getLogger(__name__)\\n logger.info(\\\"Found %i different entities\\\", len(entities))\\n logger.info(\\\"Found %i different relations\\\", len(relations))\\n\\n entity_to_id = {entity: i for (i, entity) in enumerate(sorted(entities))}\\n relation_to_id = {relation: i for (i, relation) in\\n enumerate(sorted(relations))}\\n\\n id_to_entity = {i: entity for entity, i in entity_to_id.items()}\\n id_to_relation = {i: relation for relation, i in relation_to_id.items()}\\n\\n e2i_path = processed_data_dir + \\\"/entity_to_id.pickle\\\"\\n filename_relation_to_id = processed_data_dir + \\\"/relation_to_id.pickle\\\"\\n i2e_path = processed_data_dir + \\\"/id_to_entity.pickle\\\"\\n filename_id_to_relation = processed_data_dir + \\\"/id_to_relation.pickle\\\"\\n\\n os.makedirs(processed_data_dir, exist_ok=True)\\n\\n with open(e2i_path, \\\"wb\\\") as handle1:\\n pickle.dump(entity_to_id, handle1, protocol=pickle.HIGHEST_PROTOCOL)\\n\\n with open(filename_relation_to_id, \\\"wb\\\") as handle2:\\n pickle.dump(relation_to_id, handle2, protocol=pickle.HIGHEST_PROTOCOL)\\n\\n with open(i2e_path, \\\"wb\\\") as handle3:\\n pickle.dump(id_to_entity, handle3, protocol=pickle.HIGHEST_PROTOCOL)\\n\\n with open(filename_id_to_relation, \\\"wb\\\") as handle4:\\n pickle.dump(id_to_relation, handle4, protocol=pickle.HIGHEST_PROTOCOL)\",\n \"def neighbors((min_i, min_j), (max_i, max_j), (i, j)):\\n if j + 1 <= max_j:\\n yield (i, j + 1)\\n if j - 1 >= min_j:\\n yield (i, j - 1)\\n if i + 1 <= max_i:\\n yield (i + 1, j)\\n if i - 1 >= min_i:\\n yield (i - 1, j)\",\n \"def testPairs(G, aggr_nodes, prefix1='2_0', prefix2='2_1', table=None):\\n aggr1 = [x for x in aggr_nodes[1:80:8] if prefix1 in x]\\n aggr2 = [x for x in aggr_nodes[0:80:8] if prefix2 in x]\\n\\n n = len(aggr1)\\n \\n test_pairs = []\\n for i in range(0, n):\\n for j in range(0, n):\\n if (aggr1[i] in table and aggr2[j] in table \\n and (aggr1[i], aggr2[j]) in G.edges()\\n ):\\n test_pairs.append((aggr1[i], aggr2[j]))\\n \\n return test_pairs\",\n \"def get_closest_match(indices1, indices2):\\n \\n if len(indices1) == 1 and len(indices2) == 1:\\n return indices1[0], indices2[0]\\n \\n closest_match = (indices1[0], indices2[0])\\n min_dist = np.abs(closest_match[0][0] - closest_match[1][0])\\n for pair in itertools.product(indices1, indices2):\\n dist = np.abs(pair[0][0] - pair[1][0])\\n if dist < min_dist:\\n closest_match = pair\\n min_dist = dist\\n \\n return closest_match\",\n \"def tracklet_fast(g1: nx.graph, g2: nx.graph, seg_img1: np.ndarray, seg_img2: np.ndarray, maxtrackid: int, time: int, \\n linelist: list, tracksavedir: str, cellcenter1: np.ndarray, cellcenter2: np.ndarray) \\\\\\n -> (int, list):\\n f1 = {}\\n f2 = {}\\n dict_associate = {}\\n loc1 = g1.degree(weight=\\\"weight\\\")\\n loc2 = g2.degree(weight=\\\"weight\\\")\\n new_seg_img2 = np.zeros(seg_img2.shape)\\n\\n for ele1 in loc1:\\n cell = ele1[0]\\n f1[cell] = [cellcenter1[cell], ele1[1]]\\n\\n for ele2 in loc2:\\n cell = ele2[0]\\n f2[cell] = [cellcenter2[cell], ele2[1]]\\n\\n for cell in f2.keys():\\n tmp_center = f2[cell][0]\\n min_distance = seg_img2.shape[0]**2 + seg_img2.shape[1]**2 + seg_img2.shape[2]**2\\n\\n for ref_cell in f1.keys():\\n ref_tmp_center = f1[ref_cell][0]\\n distance = (tmp_center[0]-ref_tmp_center[0])**2 + (tmp_center[1] -\\n ref_tmp_center[1])**2 + (tmp_center[2]-ref_tmp_center[2])**2\\n if distance < min_distance:\\n dict_associate[cell] = ref_cell\\n min_distance = distance\\n\\n inverse_dict_ass = {}\\n\\n for cell in dict_associate:\\n if dict_associate[cell] in inverse_dict_ass:\\n inverse_dict_ass[dict_associate[cell]].append(cell)\\n else:\\n inverse_dict_ass[dict_associate[cell]] = [cell]\\n\\n maxtrackid = max(maxtrackid, max(inverse_dict_ass.keys()))\\n\\n for cell in inverse_dict_ass.keys():\\n if len(inverse_dict_ass[cell]) > 1:\\n for cellin2 in inverse_dict_ass[cell]:\\n maxtrackid = maxtrackid + 1\\n new_seg_img2[seg_img2 == cellin2] = maxtrackid\\n string = '{} {} {} {}'.format(maxtrackid, time+1, time+1, cell)\\n linelist.append(string)\\n else:\\n cellin2 = inverse_dict_ass[cell][0]\\n new_seg_img2[seg_img2 == cellin2] = cell\\n i = 0\\n\\n for line in linelist:\\n i = i+1\\n if i == cell:\\n list_tmp = line.split()\\n new_string = '{} {} {} {}'.format(list_tmp[0], list_tmp[1], time+1, list_tmp[3])\\n linelist[i-1] = new_string\\n\\n with concurrent.futures.ThreadPoolExecutor(max_workers=2) as executor:\\n thread1 = executor.submit(save_img_as_tiff, seg_img1, time, tracksavedir)\\n thread2 = executor.submit(save_img_as_tiff, new_seg_img2, time+1, tracksavedir)\\n\\n return maxtrackid, linelist\",\n \"def test_sort_ids(self):\\r\\n\\r\\n mapping = {\\\"1\\\": [\\\"0\\\", \\\"2\\\", \\\"5\\\", \\\"6\\\"],\\r\\n \\\"3\\\": [],\\r\\n \\\"4\\\": [],\\r\\n \\\"11\\\": [1, 2, 3, 4, 5, 6, 7, 8, 9],\\r\\n \\\"8\\\": [\\\"7\\\"]}\\r\\n\\r\\n self.assertEqual(sort_ids([\\\"1\\\", \\\"3\\\", \\\"4\\\", \\\"8\\\", \\\"11\\\"], mapping),\\r\\n [\\\"11\\\", \\\"1\\\", \\\"8\\\", \\\"4\\\", \\\"3\\\"])\",\n \"def test_sort_ids(self):\\r\\n\\r\\n mapping = {\\\"1\\\": [\\\"0\\\", \\\"2\\\", \\\"5\\\", \\\"6\\\"],\\r\\n \\\"3\\\": [],\\r\\n \\\"4\\\": [],\\r\\n \\\"11\\\": [1, 2, 3, 4, 5, 6, 7, 8, 9],\\r\\n \\\"8\\\": [\\\"7\\\"]}\\r\\n\\r\\n self.assertEqual(sort_ids([\\\"1\\\", \\\"3\\\", \\\"4\\\", \\\"8\\\", \\\"11\\\"], mapping),\\r\\n [\\\"11\\\", \\\"1\\\", \\\"8\\\", \\\"4\\\", \\\"3\\\"])\",\n \"def min_cost_matching(\\n distance_metric, max_distance, tracks, detections, track_indices=None,\\n detection_indices=None):\\n if track_indices is None:\\n track_indices = np.arange(len(tracks))\\n if detection_indices is None:\\n detection_indices = np.arange(len(detections))\\n\\n if len(detection_indices) == 0 or len(track_indices) == 0:\\n return [], track_indices, detection_indices # Nothing to match.\\n\\n cost_matrix = distance_metric(\\n tracks, detections, track_indices, detection_indices)\\n cost_matrix[cost_matrix > max_distance] = max_distance + 1e-5\\n indices = linear_sum_assignment(cost_matrix)\\n indices = np.asarray(indices)\\n indices = np.transpose(indices)\\n\\n matches, unmatched_tracks, unmatched_detections = [], [], []\\n for col, detection_idx in enumerate(detection_indices):\\n if col not in indices[:, 1]:\\n unmatched_detections.append(detection_idx)\\n for row, track_idx in enumerate(track_indices):\\n if row not in indices[:, 0]:\\n unmatched_tracks.append(track_idx)\\n for row, col in indices:\\n track_idx = track_indices[row]\\n detection_idx = detection_indices[col]\\n if cost_matrix[row, col] > max_distance:\\n unmatched_tracks.append(track_idx)\\n unmatched_detections.append(detection_idx)\\n else:\\n matches.append((track_idx, detection_idx))\\n return matches, unmatched_tracks, unmatched_detections\",\n \"def _update_nodes_ids(self, change=None):\\n self._nodes_filter.val_range = self.nodes_range\\n self.nodes_ids = self._nodes_filter.val_ids\\n self._update_edges_filtered(change)\",\n \"def remap_ids(self, id_map: Dict[int, int]) -> None:\\n super().remap_ids(id_map)\\n nds = self.nodes\\n for i, nd_id in enumerate(nds):\\n nds[i] = id_map.get(nd_id, 0)\",\n \"def canonical_order(match):\\n\\n # match[0][0:3] contains the ID numbers of the 4 atoms in the match\\n atom0 = match[0][0]\\n atom1 = match[0][1]\\n atom2 = match[0][2]\\n atom3 = match[0][3]\\n # match[1][0:2] contains the ID numbers of the the 3 bonds\\n bond0 = match[1][0]\\n bond1 = match[1][1]\\n bond2 = match[1][2]\\n if atom0 < atom3:\\n # return ((atom0, atom1, atom2, atom3), (bond0, bond1, bond2)) same\\n # as:\\n return match\\n else:\\n return ((atom3, atom2, atom1, atom0), (bond2, bond1, bond0))\",\n \"def unpruned_atom_pairs(\\n molecules: List[masm.Molecule], idx_map: List[Tuple[int, int]], distance_bounds: Tuple[int, int]\\n) -> Set[Tuple[int, int]]:\\n\\n def structure_idx(c: int, i: int) -> int:\\n return idx_map.index((c, i))\\n\\n pairs: Set[Tuple[int, int]] = set()\\n\\n for component, molecule in enumerate(molecules):\\n for i in molecule.graph.atoms():\\n distances = np.array(masm.distance(i, molecule.graph))\\n partners = np.nonzero((distances <= max(distance_bounds)) & (distances >= min(distance_bounds)))[0]\\n\\n # Back-transform to structure indices and add to set\\n s_i = structure_idx(component, i)\\n s_partners = [structure_idx(component, j) for j in partners]\\n pairs |= set(make_sorted_pair(s_i, s_j) for s_j in s_partners)\\n\\n return pairs\",\n \"def remove_xmatch_multiples(index_primary, index_secondary, d2d, d3d, retain_best_match=True,\\n verbose=False):\\n n_entries = len(index_primary)\\n n_unique_entries = len(np.unique(index_primary))\\n if verbose:\\n print('xmatch: cleanMultipleCrossMatches: there are {0:d} unique entries in the primary '\\n 'catalog'.format(n_unique_entries))\\n\\n if n_entries != n_unique_entries:\\n # get array of unique indices (here like identifier) and the corresponding occurrence count\\n unique_array, return_counts = np.unique(index_primary, return_counts=True)\\n\\n # indices in unique array of stars with multiple crossmatches\\n index_in_unique_array = np.where(return_counts > 1)[0]\\n number_of_stars_with_multiplematches = len(index_in_unique_array)\\n if verbose:\\n if retain_best_match:\\n print('xmatch: result contains {} multiple matches affecting {} entries, '\\n 'keeping closest match'.format(number_of_stars_with_multiplematches,\\n n_entries - n_unique_entries))\\n else:\\n print('xmatch: result contains {} multiple matches affecting {} entries, removing '\\n 'them all'.format(number_of_stars_with_multiplematches,\\n n_entries - n_unique_entries))\\n\\n # identifiers (i.e. numbers in index_primary) of stars with multiple crossmatches\\n multi_matches = unique_array[index_in_unique_array]\\n\\n # index in index_primary where multiple matches occur\\n index_multiple_match = np.where(np.in1d(index_primary, multi_matches))[0]\\n if verbose:\\n print(d2d[index_multiple_match], index_primary[index_multiple_match], index_secondary[index_multiple_match])\\n\\n good_index_in_index_primary = np.zeros(number_of_stars_with_multiplematches)\\n for ii, jj in enumerate(multi_matches):\\n tmp_idx0 = np.where(index_primary[index_multiple_match] == jj)[0]\\n tmp_idx1 = np.argmin(d2d[index_multiple_match][tmp_idx0])\\n good_index_in_index_primary[ii] = index_primary[index_multiple_match][tmp_idx0[tmp_idx1]]\\n\\n if retain_best_match:\\n index_to_remove = np.setdiff1d(index_multiple_match, good_index_in_index_primary)\\n else:\\n index_to_remove = index_multiple_match\\n\\n mask = np.ones(len(index_primary), dtype=bool)\\n mask[index_to_remove] = False\\n index_primary = index_primary[mask]\\n index_secondary = index_secondary[mask]\\n d2d = d2d[mask]\\n d3d = d3d[mask]\\n if len(index_primary) != len(np.unique(index_primary)):\\n print('xmatch: Multiple match cleanup procedure failed')\\n # get array of unique indices (here like identifier) and the corresponding occurrence count\\n unique_array, return_counts = np.unique(index_primary, return_counts=True)\\n\\n # indices in unique array of stars with multiple crossmatches\\n index_in_unique_array = np.where(return_counts > 1)[0]\\n number_of_stars_with_multiplematches = len(index_in_unique_array)\\n print('xmatch: result still contains {} multiple matches'.format(\\n number_of_stars_with_multiplematches))\\n\\n return index_primary, index_secondary, d2d, d3d\",\n \"def extractPathsFromExploded (cls, exploded_paths_dict, min_dist_pairs,\\n id_connector_character):\\n min_length_paths = defaultdict(lambda: defaultdict(lambda: None))\\n for original_starting_node, d in min_dist_pairs.iteritems():\\n for original_ending_node, tup in d.iteritems():\\n exploded_path = exploded_paths_dict[tup[0]][tup[1]]\\n # get only the exploded IDs, which come from node ID-s\\n path_with_only_node_ids = filter(\\n lambda lid, sep=id_connector_character: sep in lid, exploded_path)\\n # transform them back to the original ID-s\\n path_with_original_node_ids = map(\\n lambda lid, sep=id_connector_character: lid.split(sep)[1],\\n path_with_only_node_ids)\\n # the startgin and ending node ID may not be in place\\n if path_with_original_node_ids[0] != original_starting_node:\\n path_with_original_node_ids.insert(0, original_starting_node)\\n if path_with_original_node_ids[-1] != original_ending_node:\\n path_with_original_node_ids.append(original_ending_node)\\n\\n # a transit infra appears twice in the path after each other, because\\n # there was an inbound and an outbound port.\\n path_with_original_node_ids_no_duplicates = [\\n path_with_original_node_ids[0]]\\n for n in path_with_original_node_ids:\\n if n != path_with_original_node_ids_no_duplicates[-1]:\\n path_with_original_node_ids_no_duplicates.append(n)\\n path_with_original_node_ids_no_duplicates_str = map(\\n lambda node_id: NFFGToolBox.try_to_convert(node_id),\\n path_with_original_node_ids_no_duplicates)\\n min_length_paths[NFFGToolBox.try_to_convert(original_starting_node)][\\n NFFGToolBox.try_to_convert(original_ending_node)] = \\\\\\n path_with_original_node_ids_no_duplicates_str\\n\\n # convert embedded default dicts\\n for k in min_length_paths:\\n min_length_paths[k] = dict(min_length_paths[k])\\n return dict(min_length_paths)\",\n \"def _candidate_ranking(self, big_final_dict):\\n self.logger.info(\\\"Disambiguated Entity Link\\\")\\n big_list = []\\n\\n for dict in big_final_dict:\\n for dict_value in dict.values():\\n temp = []\\n for i in dict_value:\\n x = (i.split(\\\"http://dbpedia.org/resource/\\\"))\\n y = list(filter(None, x))\\n yy = (y[0].split('_'))\\n strg = ''\\n for x in yy:\\n strg = strg + x + ' '\\n strg = strg[:-1]\\n temp.append(strg)\\n big_list.append(temp)\\n\\n big_arr2 = []\\n for small_list in big_list:\\n arr2 = []\\n for i in small_list:\\n arr2.append(re.sub(r'[^\\\\w\\\\s]', '', (i)))\\n\\n big_arr2.append(arr2)\\n\\n input_text_cleaned = re.sub(r'[^\\\\w\\\\s]', '', self.text)\\n arr1 = input_text_cleaned.split() # remove stop words\\n arr1 = [w for w in arr1 if w.lower() not in self.english_stopwords]\\n\\n self.ranked_entities = []\\n for arr2 in big_arr2:\\n a = numpy.zeros(shape=(len(arr2), len(arr1)))\\n for i in range(len(arr1)):\\n for j in range(len(arr2)):\\n if arr1[i] in arr2[j]:\\n a[j][i] = 1\\n else:\\n a[j][i] = 0\\n\\n rows = len(a)\\n cols = len(a[0])\\n highest = []\\n\\n for x in range(0, rows):\\n rowtotal = 0\\n for y in range(0, cols):\\n rowtotal = rowtotal + int(a[x][y])\\n highest.append(rowtotal)\\n\\n highest_value = highest.index(max(highest))\\n ranked_entity = arr2[highest_value]\\n self.logger.info(\\n 'Ambiguous word:' + ranked_entity + ' ' + 'Disambiguation link' + ' ' + 'https://en.wikipedia.org/wiki/' + (\\n ranked_entity).replace(' ', '_'))\\n self.ranked_entities.append(\\n [ranked_entity, 'https://en.wikipedia.org/wiki/' + (ranked_entity).replace(' ', '_')])\\n return self.ranked_entities\",\n \"def get_indices(min_lat, max_lat, min_lon, max_lon, lons, lats):\\n\\n distances1, distances2, indices = [], [], []\\n index = 1\\n for point in lats:\\n s1 = max_lat - point\\n s2 = min_lat - point\\n distances1.append((np.dot(s1, s1), point, index))\\n distances2.append((np.dot(s2, s2), point, index - 1))\\n index = index + 1\\n\\n distances1.sort()\\n distances2.sort()\\n indices.append(distances1[0])\\n indices.append(distances2[0])\\n\\n distances1, distances2 = [], []\\n index = 1\\n for point in lons:\\n s1 = max_lon - point\\n s2 = min_lon - point\\n distances1.append((np.dot(s1, s1), point, index))\\n distances2.append((np.dot(s2, s2), point, index - 1))\\n index = index + 1\\n\\n distances1.sort()\\n distances2.sort()\\n indices.append(distances1[0])\\n indices.append(distances2[0])\\n\\n # max_lat_indices, min_lat_indices, max_lon_indices, min_lon_indices.\\n res = np.zeros((4), dtype=np.float64)\\n res[0] = indices[3][2]\\n res[1] = indices[2][2]\\n res[2] = indices[1][2]\\n res[3] = indices[0][2]\\n return res\",\n \"def tree_idx(tree,j1,J1,J2):\\n j = j1\\n for k in np.arange(J1+1,J2+1,1):\\n j = tree[k]['IDX'][j]\\n \\n j2 = j\\n return j2\",\n \"def _find_paired_nodes(self, graph):\\n paired_list = []\\n for line in nx.generate_edgelist(graph):\\n if ('basepair' in line):\\n if not (int(line.split(' ')[0]) in paired_list):\\n paired_list.append(int(line.split(' ')[0]))\\n if not (int(line.split(' ')[1]) in paired_list):\\n paired_list.append(int(line.split(' ')[1]))\\n return paired_list\",\n \"def differentNTuplesForNode(ntupleSet,nodeList,verbose=False):\\n ntuplesPerNode = dict(zip(nodeList,[[] for n in range(len(nodeList))]))\\n for ntuple in ntupleSet:\\n ntuple.sort()\\n joinedTuple = \\\"\\\".join(ntuple)\\n for nodeInTuple in ntuple:\\n ntuplesPerNode[nodeInTuple].append(joinedTuple)\\n \\n for a,v in ntuplesPerNode.iteritems():\\n ntuplesPerNode[a] = set(v)\\n \\n return ntuplesPerNode\",\n \"def map(self, start = \\\"<START>\\\", end = \\\"<END>\\\", unknown = \\\"<UNKNOWN>\\\"):\\n return [(self._seq2Indices(s, self.sourceVocab, start = start, end = end, unknown = unknown),\\n self._seq2Indices(t, self.targetVocab, start = start, end = end, unknown = unknown)\\n ) for s, t in zip(self.source, self.target)]\",\n \"def nlp_merge_common_matches(matches):\\n\\n merged_matches = []\\n\\n for idx_1, start_1, end_1 in matches:\\n\\n curr_idx = idx_1\\n curr_start = start_1\\n curr_end = end_1\\n\\n for idx_2, start_2, end_2 in matches:\\n\\n if (start_2 < curr_start and end_2 > curr_end) or (start_2 <= curr_start and end_2 > curr_end) or (\\n start_2 < curr_start and end_2 >= curr_end):\\n curr_idx = idx_2\\n curr_start = start_2\\n curr_end = end_2\\n\\n merged_matches.append((curr_idx, curr_start, curr_end))\\n\\n return list(set(merged_matches))\",\n \"def findings_2_idx(findings, corner_2_idx, funcx, funcy):\\n idx = []\\n for finding in findings:\\n x, y = finding\\n mesh = np.array(np.meshgrid(funcx(x), funcy(y))).swapaxes(1,2).reshape(2,-1).T\\n idx.extend([corner_2_idx(c) for c in mesh])\\n\\n return np.unique(idx)\",\n \"def switch_distance(pair_1, pair_2):\\r\\n\\th1_1=pair_1[0]\\r\\n\\th2_1=pair_2[0]\\r\\n\\th2_2=pair_2[1]\\r\\n\\tcnt_1=0\\r\\n\\tcnt_2=0\\r\\n\\t# print h2_1, h1_1\\r\\n\\tfor i in xrange(0,len(pair_1[0])):\\r\\n\\t\\tif h2_1[i]!=h1_1[i]:\\r\\n\\t\\t\\th2_1, h2_2=switch(h2_1, h2_2, i)\\r\\n\\t\\t\\t# print h2_1, h2_2, i\\r\\n\\t\\t\\tcnt_1+=1\\r\\n\\tprint h2_1, h1_1\\r\\n\\th1_1=pair_1[0]\\r\\n\\th2_1=pair_2[0]\\r\\n\\th2_2=pair_2[1]\\r\\n\\tfor i in xrange(0,len(pair_1[0])):\\r\\n\\t\\tif h2_2[i]!=h1_1[i]:\\r\\n\\t\\t\\th2_1, h2_2=switch(h2_1, h2_2, i)\\r\\n\\t\\t\\t# print h2_1, h2_2, i\\r\\n\\t\\t\\tcnt_2+=1\\r\\n\\t# print cnt_1, cnt_2\\r\\n\\treturn cnt_1 if cnt_1<cnt_2 else cnt_2\",\n \"def prepare_initial_nodes(x_start, x_end, nodes_y):\\n nodes_x = [float(x_start + ((x_end - x_start) / (len(nodes_y) - 1)) * i) for i in range(0, len(nodes_y))]\\n nodes_y = [float(y) for y in nodes_y]\\n print(nodes_x)\\n print(nodes_y)\\n nodes = list(zip(nodes_x, nodes_y))\\n return nodes\",\n \"def update_id2idx(self):\\n self._id2idx = {}\\n for n, cell in enumerate(self._cell_list):\\n self._id2idx[cell.id()] = n\",\n \"def compute_distance_pairs(cities):\\n global distances_pair\\n for city_from in cities:\\n distances_pair.append([0 for r in range(city_from.index)]) # create\\n for city_to in cities[:city_from.index]:\\n distances_pair[city_from.index][city_to.index] = city_from.compute_distance_to_city_in_km(city_to)\",\n \"def linear_merge(sorted1, sorted2):\\n first_pointer = 0\\n second_pointer = 0\\n sorted_result = []\\n\\n while second_pointer < len(sorted2) and first_pointer < len(sorted1):\\n if sorted1[first_pointer] < sorted2[second_pointer]:\\n sorted_result.append(sorted1[first_pointer])\\n first_pointer += 1\\n else:\\n sorted_result.append(sorted2[second_pointer])\\n second_pointer += 1\\n\\n while second_pointer < len(sorted2):\\n sorted_result.append(sorted2[second_pointer])\\n second_pointer += 1\\n\\n while first_pointer < len(sorted1):\\n sorted_result.append(sorted1[first_pointer])\\n first_pointer += 1\\n\\n\\n return sorted_result\",\n \"def get_matches(self, first, second):\\n matches = self._match_table.dropna(0)[\\n [first.position.id, second.position.id]].astype(int).values\\n return matches\",\n \"def all_pairs(items, sort=False):\\n if sort:\\n items = sorted(items)\\n for i, ni in enumerate(items):\\n for j, nj in enumerate(items):\\n if j > i: yield ni, nj\",\n \"def find_near_nodes(self, new_node):\\n number_nodes = len(self.node_list) + 1\\n r = self.connect_circle_dist * math.sqrt(\\n (math.log(number_nodes) / number_nodes)\\n )\\n\\n # if expand_dist exists, search vertices in a range no more than expand_dist\\n if hasattr(self, \\\"expand_dis\\\"):\\n r = min(r, self.expand_dis)\\n dist_list = [\\n (node.x - new_node.x) ** 2 + (node.y - new_node.y) ** 2\\n for node in self.node_list\\n ]\\n near_indexes = [dist_list.index(i) for i in dist_list if i <= r ** 2]\\n return near_indexes\",\n \"def match(a1, a2):\\n inds_1, inds_2 = [], []\\n i, j = 0, 0\\n for s in range(0, len(a1)):\\n increment = lambda a, x, ind: x+1 if a[ind] != \\\"-\\\" else x\\n if a1[s] is a2[s] and a1[s] != \\\"-\\\":\\n inds_1.append(i)\\n inds_2.append(j)\\n i = increment(a1,i,s)\\n j = increment(a2,j,s)\\n return inds_1, inds_2\",\n \"def rearrange_indices(self):\\n num_fixed_words = 2\\n other_words = [w for w in self.word2index if w not in self.equivariant_words]\\n for idx, word in enumerate(self.equivariant_words):\\n w_idx = idx + num_fixed_words\\n self.word2index[word] = w_idx\\n self.index2word[w_idx] = word\\n for idx, word in enumerate(sorted(other_words)):\\n w_idx = idx + num_fixed_words + self.num_equivariant_words\\n self.word2index[word] = w_idx\\n self.index2word[w_idx] = word\",\n \"def nn_match(descs1, descs2):\\n # diff = descs1[:, None, :] - descs2[None, :, :]\\n # diff = np.linalg.norm(diff, ord=2, axis=2)\\n # indices = np.argmin(diff, axis=1)\\n\\n flann = cv2.FlannBasedMatcher_create()\\n matches = flann.match(descs1.astype(np.float32), descs2.astype(np.float32))\\n indices = [x.trainIdx for x in matches]\\n\\n return indices\",\n \"def expand_ranges(ranges):\\n for low, high in low_high_pairs:\\n for j in range(low, high+1):\\n yield j\",\n \"def coor2idx(x, y):\\r\\n a = round(x/4000,0)*4000\\r\\n b = (round_down(y/4000,0)+0.5)*4000\\r\\n i = int((a - 24000)/4000) + 1\\r\\n j = int((b - 22000)/4000) + 1\\r\\n return i, j\",\n \"def pair_iterator(self, src_indices, tgt_indices, batch_size, data):\\n\\n def _select_from_pool(indices):\\n \\\"\\\"\\\"Selects batch_size indices from the provided list.\\\"\\\"\\\"\\n num_indices = len(indices)\\n if num_indices > 0:\\n idxs = self.rng.randint(0, high=num_indices, size=(batch_size,))\\n indices_batch = indices[idxs]\\n features_batch = data.get_features(indices_batch)\\n labels_batch = data.get_labels(indices_batch)\\n else:\\n features_shape = [0] + list(data.features_shape)\\n indices_batch = np.zeros(shape=(0,), dtype=np.int64)\\n features_batch = np.zeros(shape=features_shape, dtype=np.float32)\\n labels_batch = np.zeros(shape=(0,), dtype=np.int64)\\n return indices_batch, features_batch, labels_batch\\n\\n while True:\\n indices_src, features_src, labels_src = _select_from_pool(src_indices)\\n indices_tgt, features_tgt, labels_tgt = _select_from_pool(tgt_indices)\\n yield (indices_src, indices_tgt, features_src, features_tgt, labels_src,\\n labels_tgt)\",\n \"def get_sources_and_targets(index_pairings):\\n\\n source_target_dictionary = {}\\n links_list = []\\n \\n itr = 0\\n \\n for pair in index_pairings:\\n source = pair[0]\\n target = pair[1]\\n\\n source_target_dictionary = {\\\"source\\\":source, \\\"target\\\":target}\\n links_list.append(source_target_dictionary)\\n\\n return links_list\",\n \"def get_chunk_ids_from_node_ids(self, node_ids: Iterable[np.uint64]\\n ) -> np.ndarray:\\n # TODO: measure and improve performance(?)\\n return np.array(list(map(lambda x: self.get_chunk_id(node_id=x),\\n node_ids)), dtype=np.uint64)\",\n \"def _create_two_group_jackknife_indexes(x0, x1, is_paired):\\n\\n if is_paired and len(x0) == len(x1):\\n out = list(zip([j for j in create_jackknife_indexes(x0)],\\n [i for i in create_jackknife_indexes(x1)]\\n )\\n )\\n else:\\n jackknife_c = list(zip([j for j in create_jackknife_indexes(x0)],\\n [i for i in create_repeated_indexes(x1)]\\n )\\n )\\n\\n jackknife_t = list(zip([i for i in create_repeated_indexes(x0)],\\n [j for j in create_jackknife_indexes(x1)]\\n )\\n )\\n out = jackknife_c + jackknife_t\\n del jackknife_c\\n del jackknife_t\\n\\n return out\",\n \"def sort_indices(self, list_of_indexes):\\n return sorted(list_of_indexes, key=lambda index: tuple(int(i) for i in index.split(\\\".\\\")))\",\n \"def match_min2(coords1,coords2,tail1=(),tail2=()):\\n nc=len(coords1)\\n np1=len(coords1[0])\\n np2=len(coords2[0])\\n a1=array(coords1)\\n a2=array(coords2)\\n nt1=len(tail1)\\n for i in range(nt1): \\n if len(tail1[i])!= np1: raise 'Not the same lenght as coordinates 1'\\n nt2=len(tail2)\\n for i in range(nt2): \\n if len(tail2[i])!= np2: raise 'Not the same lenght as coordinates 2'\\n match=zeros(np1, int)-1\\n dist_min=zeros(np1)*1.\\n x2=zeros(np1)*1.\\n y2=zeros(np1)*1.\\n for j in range(np1):\\n #dist=add.reduce((a1[:,j,NewAxis]-a2[:,:])**2)\\n a1j = a1[:,j]\\n dist=add.reduce((reshape(a1j, (len(a1j), 1)) - a2)**2)\\n i_min=argmin(dist)\\n dist_min[j]=dist[i_min]\\n x2[j],y2[j]=a2[0,i_min],a2[1,i_min]\\n match[j]=i_min\\n \\n salida=list(a1)\\n salida.append(x2)\\n salida.append(y2)\\n\\n for i in range(nt1):salida.append(tail1[i])\\n \\n for i in range(nt2):\\n if type(tail2[i][0])==type('si'):\\n t=[]\\n for j in match: t.append(tail2[i][j])\\n else:\\n t=take(tail2[i],match)\\n salida.append(t)\\n\\n salida.append(dist_min)\\n return tuple(salida)\",\n \"def get_pairwise_matches(pos1, descs1, pos2, descs2, up_to=30):\\n assert pos1.shape[0] * pos2.shape[0] < 1e8, \\\\\\n \\\"Too many points: increase cornerness threshold\\\"\\n assert pos1.shape[0] > 10 and pos1.shape[0] > 10, \\\\\\n \\\"Not enough points: lower cornerness threshold\\\"\\n # get the similarities between all descriptors\\n sims = np.dot(descs1, descs2.T)\\n # get the best matches\\n mi2 = sims.argmax(axis=1).squeeze()\\n ms = sims.max(axis=1).squeeze()\\n bmi1 = ms.argsort()[::-1][:up_to]\\n bmi2 = mi2[bmi1]\\n # return their positions\\n bp1 = pos1[bmi1]\\n bp2 = pos2[bmi2]\\n return bp1, bp2\",\n \"def _intersecting_index(ar1, ar2):\\n try:\\n _, comm1, comm2 = np.intersect1d(ar1, ar2, return_indices=True)\\n # return_indices option needs numpy 1.15.0\\n except TypeError:\\n comm1 = []\\n comm2 = []\\n for idx, i in enumerate(ar1):\\n for jdx, j in enumerate(ar2):\\n if i == j:\\n comm1.append(idx)\\n comm2.append(jdx)\\n break\\n comm1 = np.sort(comm1)\\n comm2 = np.sort(comm2)\\n\\n return comm1, comm2\",\n \"def find_inlet_nodes(nodes, inlets_shp, gdobj):\\r\\n\\r\\n # Check that CRSs match; reproject inlet points if not\\r\\n inlets_gpd = gpd.read_file(inlets_shp)\\r\\n mask_crs = CRS(gdobj.GetProjection())\\r\\n if inlets_gpd.crs != mask_crs:\\r\\n inlets_gpd = inlets_gpd.to_crs(mask_crs)\\r\\n logger.info('Provided inlet points file does not have the same CRS as provided mask. Reprojecting.')\\r\\n\\r\\n # Convert all nodes to xy coordinates for distance search\\r\\n nodes_xy = gu.idx_to_coords(nodes['idx'], gdobj)\\r\\n\\r\\n # Map provided inlet nodes to actual network nodes\\r\\n inlets = []\\r\\n for inlet_geom in inlets_gpd.geometry.values:\\r\\n # Distances between inlet node and all nodes in network\\r\\n xy = inlet_geom.xy\\r\\n dists = np.sqrt((xy[0][0]-nodes_xy[0])**2 + (xy[1][0]-nodes_xy[1])**2)\\r\\n inlets.append(nodes['id'][np.argmin(dists)])\\r\\n\\r\\n # Append inlets to nodes dict\\r\\n nodes['inlets'] = inlets\\r\\n\\r\\n return nodes\",\n \"def _get_indices_2(image_set, min_groups, num_labels=2, num_protected=2):\\r\\n indices = [[[] for _ in range(num_protected)] for _ in range(num_labels)]\\r\\n for i, (_, label, _, index) in enumerate(image_set):\\r\\n indices[label][int(image_set.samples[i][0].split(\\\"/\\\")[-1] in min_groups[label])].append(index)\\r\\n\\r\\n return indices\",\n \"def match_min(coords1,coords2,tail1=(),tail2=()):\\n nc=len(coords1)\\n np1=len(coords1[0])\\n np2=len(coords2[0])\\n a1=array(coords1)\\n a2=array(coords2)\\n nt1=len(tail1)\\n for i in range(nt1): \\n if len(tail1[i])!= np1: raise 'Not the same lenght as coordinates 1'\\n nt2=len(tail2)\\n for i in range(nt2): \\n if len(tail2[i])!= np2: raise 'Not the same lenght as coordinates 2'\\n match=zeros(np1, int)-1\\n\\n dist_min=zeros(np1)*1.\\n\\n for j in range(np1):\\n #dist=sqrt(add.reduce((a1[:,j,NewAxis]-a2[:,:])**2))\\n a1j = a1[:,j]\\n dist=add.reduce((reshape(a1j, (len(a1j), 1)) - a2)**2)\\n i_min=argmin(dist)\\n dist_min[j]=dist[i_min]\\n match[j]=i_min\\n\\n salida=list(a1)\\n for i in range(nt1):salida.append(tail1[i])\\n \\n for i in range(nt2):\\n if type(tail2[i][0])==type('si'):\\n t=[]\\n for j in match: t.append(tail2[i][j])\\n else:\\n t=take(tail2[i],match)\\n salida.append(t)\\n\\n salida.append(dist_min)\\n return tuple(salida)\",\n \"def match_nodes(source_node, target_node):\\n\\n node_position = cmds.xform(source_node, q=True, ws=True, t=True)\\n node_rotation = cmds.xform(source_node, q=True, ws=True, ro=True)\\n cmds.xform(target_node, ws=True, t=node_position)\\n cmds.xform(target_node, ws=True, ro=node_rotation)\",\n \"def get_move_indexes(i, j):\\n return (i, j), (j, n - 1 - i), (n - 1 - i, n - 1 - j), (n - 1 - j, i)\",\n \"def build_verticies(list_of_tuples):\\n result = defaultdict(list)\\n for (from_node, to_node), cost in list_of_tuples:\\n from_action = Action(to_node, cost)\\n result[from_node].append(from_action)\\n to_action = Action(from_node, cost)\\n result[to_node].append(to_action)\\n\\n return result\",\n \"def findSubsetIndices(min_lat,max_lat,min_lon,max_lon,lats,lons):\\n res=np.zeros((4),dtype=np.float64)\\n minLon=min_lon; maxLon=max_lon\\n\\n distances1 = []; distances2 = []\\n indices=[]; index=1\\n\\n for point in lats:\\n s1 = max_lat-point # (vector subtract)\\n s2 = min_lat-point # (vector subtract)\\n distances1.append((np.dot(s1, s1), point, index))\\n distances2.append((np.dot(s2, s2), point, index-1))\\n index=index+1\\n\\n distances1.sort()\\n distances2.sort()\\n indices.append(distances1[0])\\n indices.append(distances2[0])\\n\\n distances1 = []; distances2 = []; index=1\\n\\n for point in lons:\\n s1 = maxLon-point # (vector subtract)\\n s2 = minLon-point # (vector subtract)\\n distances1.append((np.dot(s1, s1), point, index))\\n distances2.append((np.dot(s2, s2), point, index-1))\\n index=index+1\\n\\n distances1.sort()\\n distances2.sort()\\n indices.append(distances1[0])\\n indices.append(distances2[0])\\n\\n # Save final product: max_lat_indices,min_lat_indices,max_lon_indices,min_lon_indices\\n minJ=indices[1][2]\\n maxJ=indices[0][2]\\n minI=indices[3][2]\\n maxI=indices[2][2]\\n\\n res[0]=minI; res[1]=maxI; res[2]=minJ; res[3]=maxJ\\n return res\",\n \"def _store_nodes(\\n self,\\n node_hashes: Tuple[Hash32, ...],\\n nodes: NodeDataBundles,\\n urgent: bool) -> Tuple[NodeDataBundles, bool]:\\n\\n new_nodes = tuple(\\n (node_hash, node) for node_hash, node in nodes\\n if node_hash not in self._db\\n )\\n\\n if new_nodes:\\n # batch all DB writes into one, for performance\\n with self._db.atomic_batch() as batch:\\n for node_hash, node in new_nodes:\\n batch[node_hash] = node\\n\\n # Don't bother checking if the nodes were found another way\\n found_independent = False\\n elif urgent:\\n # Check if the nodes were found another way, if they are urgently needed\\n for requested_hash in node_hashes:\\n if requested_hash in self._db:\\n found_independent = True\\n break\\n else:\\n found_independent = False\\n else:\\n # Don't bother checking if the nodes were found another way, if they are predictive\\n found_independent = False\\n\\n return new_nodes, found_independent\",\n \"def map_secondary_2_primary_ANs(ids_2_map, Secondary_2_Primary_IDs_dict=None, read_from_flat_files=False):\\n if Secondary_2_Primary_IDs_dict is None:\\n ### don't read this from flat files (VERY slow) if there is a DB and low_memory then use DB\\n Secondary_2_Primary_IDs_dict = get_Secondary_2_Primary_IDs_dict_from_sec(ids_2_map, read_from_flat_files)\\n Secondary_2_Primary_IDs_dict_userquery = {}\\n for id_ in ids_2_map:\\n try:\\n prim = Secondary_2_Primary_IDs_dict[id_]\\n except KeyError:\\n prim = False\\n if prim:\\n Secondary_2_Primary_IDs_dict_userquery[id_] = prim\\n return Secondary_2_Primary_IDs_dict_userquery\",\n \"def merge_nodes(self, node_ids):\\n node_ids = sorted(node_ids)\\n\\n # Make sure no duplicate node_ids.\\n for i in range(len(node_ids) - 1):\\n assert node_ids[i] != node_ids[i + 1], \\\"Duplicate node IDs.\\\"\\n\\n # Make sure nodes are the same type.\\n for i in range(1, len(node_ids)):\\n n1 = self.nodes[node_ids[0]]\\n n2 = self.nodes[node_ids[i]]\\n assert n1.__class__ == n2.__class__, \\\"%s %s\\\" % (\\n n1.__class__, n2.__class__)\\n\\n # Keep the first node, and delete the rest.\\n\\n # Make transitions to any node_ids point to the first one.\\n node_id = node_ids[0]\\n prev_ids = []\\n for nid in node_ids[1:]:\\n x = _get_parents_of(self, nid)\\n prev_ids.extend(x)\\n transitions = self.transitions.copy()\\n for prev_id in prev_ids:\\n x = transitions[prev_id]\\n if node_id not in x:\\n x = x + [node_id]\\n transitions[prev_id] = x\\n\\n # Make the first node point to all the next_nodes of the other\\n # node_ids.\\n nid0 = node_ids[0]\\n for nidi in node_ids[1:]:\\n x = transitions.get(nid0, []) + transitions.get(nidi, [])\\n x = sorted({}.fromkeys(x))\\n transitions[nid0] = x\\n\\n x = Network(self.nodes, transitions)\\n x = x.delete_nodes(node_ids[1:])\\n return x\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6820625","0.5716441","0.5706402","0.56754607","0.55908996","0.5546528","0.5427354","0.5134633","0.5119809","0.5119312","0.50765777","0.50579196","0.5057068","0.5023635","0.50086886","0.4989392","0.49750262","0.49497184","0.49187142","0.48737258","0.4856891","0.48398817","0.48330596","0.48218507","0.48193598","0.4815111","0.48114008","0.48046997","0.48020595","0.47946107","0.47755438","0.47727767","0.47701973","0.47687608","0.47553727","0.47331506","0.47325286","0.47292423","0.47253436","0.4721291","0.4718377","0.471446","0.47127384","0.47099468","0.47080943","0.47015995","0.46975538","0.4696341","0.46914548","0.46790013","0.467663","0.4669187","0.46677697","0.46677697","0.466482","0.4661139","0.46561328","0.46508202","0.46462053","0.46376202","0.46358764","0.46267974","0.46253598","0.4617682","0.46158016","0.46089613","0.4605985","0.46010065","0.45986056","0.45920733","0.45897934","0.4583727","0.45835978","0.45777377","0.45741343","0.45706964","0.45656195","0.4564063","0.45581928","0.455572","0.45552334","0.45463967","0.4540065","0.45384428","0.4535104","0.45295826","0.45288333","0.45249668","0.45247495","0.4521503","0.45179814","0.451513","0.45138586","0.45127952","0.451126","0.4509621","0.45095098","0.45034397","0.4501277","0.45000908"],"string":"[\n \"0.6820625\",\n \"0.5716441\",\n \"0.5706402\",\n \"0.56754607\",\n \"0.55908996\",\n \"0.5546528\",\n \"0.5427354\",\n \"0.5134633\",\n \"0.5119809\",\n \"0.5119312\",\n \"0.50765777\",\n \"0.50579196\",\n \"0.5057068\",\n \"0.5023635\",\n \"0.50086886\",\n \"0.4989392\",\n \"0.49750262\",\n \"0.49497184\",\n \"0.49187142\",\n \"0.48737258\",\n \"0.4856891\",\n \"0.48398817\",\n \"0.48330596\",\n \"0.48218507\",\n \"0.48193598\",\n \"0.4815111\",\n \"0.48114008\",\n \"0.48046997\",\n \"0.48020595\",\n \"0.47946107\",\n \"0.47755438\",\n \"0.47727767\",\n \"0.47701973\",\n \"0.47687608\",\n \"0.47553727\",\n \"0.47331506\",\n \"0.47325286\",\n \"0.47292423\",\n \"0.47253436\",\n \"0.4721291\",\n \"0.4718377\",\n \"0.471446\",\n \"0.47127384\",\n \"0.47099468\",\n \"0.47080943\",\n \"0.47015995\",\n \"0.46975538\",\n \"0.4696341\",\n \"0.46914548\",\n \"0.46790013\",\n \"0.467663\",\n \"0.4669187\",\n \"0.46677697\",\n \"0.46677697\",\n \"0.466482\",\n \"0.4661139\",\n \"0.46561328\",\n \"0.46508202\",\n \"0.46462053\",\n \"0.46376202\",\n \"0.46358764\",\n \"0.46267974\",\n \"0.46253598\",\n \"0.4617682\",\n \"0.46158016\",\n \"0.46089613\",\n \"0.4605985\",\n \"0.46010065\",\n \"0.45986056\",\n \"0.45920733\",\n \"0.45897934\",\n \"0.4583727\",\n \"0.45835978\",\n \"0.45777377\",\n \"0.45741343\",\n \"0.45706964\",\n \"0.45656195\",\n \"0.4564063\",\n \"0.45581928\",\n \"0.455572\",\n \"0.45552334\",\n \"0.45463967\",\n \"0.4540065\",\n \"0.45384428\",\n \"0.4535104\",\n \"0.45295826\",\n \"0.45288333\",\n \"0.45249668\",\n \"0.45247495\",\n \"0.4521503\",\n \"0.45179814\",\n \"0.451513\",\n \"0.45138586\",\n \"0.45127952\",\n \"0.451126\",\n \"0.4509621\",\n \"0.45095098\",\n \"0.45034397\",\n \"0.4501277\",\n \"0.45000908\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.7717208"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":89895,"cells":{"query":{"kind":"string","value":"Finds nodeids present in the aligned matched region of the large DMRS, but which have no equivalents in the small DMRS."},"document":{"kind":"string","value":"def find_extra_surface_nodeids(orderids, sorted_large_nodes):\n extra_nodeids = []\n first_overlap_orderid = orderids[0]\n min_cfrom = sorted_nodes[first_overlap_orderid].cfrom\n\n # Check if any earlier nodes also in the region.\n while True:\n prev_cfrom = sorted_nodes[first_overlap_orderid-1].cfrom\n if prev_cfrom == min_cfrom:\n first_overlap_orderid -= 1\n extra_nodeids.append(sorted_nodes[first_overlap_orderid].nodeid)\n else:\n break\n\n # Find the last node in the region.\n last_overlap_orderid = matched_orderids[-1]\n max_cto = sorted_nodes[last_overlap_orderid].cto\n for i in range(first_overlap_orderid, len(sorted_nodes)):\n if sorted_nodes[i].cfrom > max_cto:\n break\n else:\n if i not in orderids:\n extra_nodeids.append(sorted_nodes[i].nodeid)\n cto = sorted_nodes[i].cto\n if cto >= max_cto:\n max_cto = cto\n if i > last_overlap_orderid:\n last_overlap_orderid = i\n\n return extra_nodeids"},"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 get_matching_nodeids(small_dmrs, large_dmrs, all_surface=False):\n sorted_small_nodes = sort_nodes(small_dmrs.nodes)\n sorted_large_nodes = sort_nodes(large_dmrs.nodes)\n\n longest_matches = find_longest_matches(sorted_small_nodes, sorted_large_nodes) # list (of lists) of tuples (id_from_sub, id)\n\n all_matched_nodeids = []\n for match in longest_matches:\n matched_large_orderids = list(zip(*match))[1] # [(order ids from small dmrs), (order ids from the\n paired_nodeids = get_matched_nodeids_from_orderids(sorted_small_nodes, sorted_large_nodes, match)\n if all_surface:\n extra_overlap_nodeids = find_extra_surface_overlap(matched_large_nodeids, sorted_large_nodes)\n paired_nodeids.extend([(None, nodeid) for nodeid in extra_overlap_nodeids])\n all_matched_nodeids.append(paired_nodeids)\n\n return all_matched_nodeids","def get_matched_nodeids_from_orderids(sorted_small_nodes, sorted_large_nodes, matched_orderids):\n orderid2nodeid_func = lambda order_pair: (sorted_small_nodes[order_pair[0]].nodeid, sorted_large_nodes[order_pair[1]].nodeid)\n return list(map(orderid2nodeid_func, matched_orderids))","def needleMatching(self):\r\n # productive\r\n profprint()\r\n modelNodes = slicer.mrmlScene.GetNodesByClass('vtkMRMLModelNode')\r\n nbNode = modelNodes.GetNumberOfItems()\r\n result = []\r\n found = []\r\n # print nbNode\r\n for nthNode in range(nbNode):\r\n node = slicer.mrmlScene.GetNthNodeByClass(nthNode, 'vtkMRMLModelNode')\r\n if node.GetID() not in found and node.GetAttribute('type') != 'Validation':\r\n dist = []\r\n polydata = node.GetPolyData()\r\n if polydata != None:\r\n bounds = polydata.GetBounds()\r\n for nthNode2 in range(nbNode):\r\n node2 = slicer.mrmlScene.GetNthNodeByClass(nthNode2, 'vtkMRMLModelNode')\r\n if node2.GetID() not in found and node2.GetAttribute('type') == 'Validation':\r\n polydata2 = node2.GetPolyData()\r\n if polydata2 != None and polydata2.GetNumberOfPoints() > 100 and polydata.GetNumberOfPoints() > 100:\r\n tipDistance = self.distTip(int(node.GetID().strip('vtkMRMLModelNode')) , int(node2.GetID().strip('vtkMRMLModelNode')))\r\n baseDistance = self.distBase(int(node.GetID().strip('vtkMRMLModelNode')) , int(node2.GetID().strip('vtkMRMLModelNode')))\r\n name = node.GetName()\r\n manualName = name.lstrip('auto-seg_').lstrip('manual-seg_').lstrip('obturator-seg_').lstrip('0123456789').lstrip('-ID-vtkMRMLModelNode').lstrip('0123456789-')\r\n if manualName==node2.GetName(): dist.append([tipDistance, node2.GetID(), node2.GetName()])\r\n # print tipDistance\r\n if dist != []:\r\n match = [min(dist)[0], min(dist)[1], node.GetID(), min(dist)[2]]\r\n result.append(match)\r\n found.append(min(dist)[1])\r\n found.append(node.GetID())\r\n node.GetDisplayNode().SetSliceIntersectionVisibility(1)\r\n # print result\r\n return result","def nearby():\n for i in ids:\n for j in ids:\n if i != j:\n if sum([1 for x,y in zip(i,j) if x!=y]) == 1:\n print(\"\".join([x for x,y in zip(i,j) if x==y]))\n return","def get_allnids(self, rids=None):\n if rids == None:\n rids = sorted(self.r)\n allnids = np.hstack([ list(self.r[rid].alln) for rid in rids ])\n return np.unique(allnids)\n else:\n allnids = [ list(self.r[rid].alln) for rid in rids ]\n return core.intersect1d(allnids, assume_unique=True)","def find_edges_no_seed(rna_seq_objs, xgmml_obj, args, stats):\n seq_pairs = []\n # this makes the edges. looking at each pair of nodes\n for i in range(0, len(rna_seq_objs)):\n for j in range(i + 1, len(rna_seq_objs)):\n pair = RNASequencePair(\n rna_seq_objs[i], rna_seq_objs[j], xgmml_obj\n )\n pair.energy_delta = abs(\n float(pair.sequence1.free_energy) - float(pair.sequence2.free_energy)\n )\n pair.edit_distance = Levenshtein.distance(\n pair.sequence1.sequence, pair.sequence2.sequence\n )\n seq_pairs.append(pair)\n # group things in batches of 10000 to find tree distances\n if len(seq_pairs) > 10000:\n process_seq_pairs(seq_pairs, args, stats)\n # zero out the seq_pairs array and start refilling again\n seq_pairs = []\n # flush out the last of the tree distance seq_pairs\n process_seq_pairs(seq_pairs, args, stats)","def _match_identical_nodes(self):\n\n for job_name_b in self._topo_b_nodes:\n for job_name_a in self._unresolved_a_nodes:\n if self._is_node_identical(job_name_a, job_name_b):\n self._identical_nodes[job_name_b] = job_name_a\n self._unresolved_a_nodes.remove(job_name_a)\n self._unresolved_b_nodes.remove(job_name_b)\n break","def __find_similar_pairs(self):\n size = len(self.__indexclusters)\n candidates = []\n for i in range(size):\n for j in range(i+1, size):\n simi = self.__cluster_simi(i, j)\n #print simi, self.__indexclusters[i],self.__indexclusters[j]\n if simi >= self.__threshold:\n candidates.append((simi, i, j))\n candidates.sort(reverse = True, key = lambda x: x[0])\n\n\n # filter overlapped pairs\n to_remove = set()\n appeared = set()\n for index, cand in enumerate(candidates):\n if cand[1] not in appeared and cand[2] not in appeared:\n appeared.add(cand[1])\n appeared.add(cand[2])\n else:\n to_remove.add(index)\n\n #print 'ahha'\n #print [(cand[1], cand[2]) for index, cand in enumerate(candidates) if index not in to_remove]\n\n return [(cand[1], cand[2]) for index, cand in enumerate(candidates)\n if index not in to_remove]","def needleMatching(self):\n #productive\n profprint()\n modelNodes=slicer.mrmlScene.GetNodesByClass('vtkMRMLModelNode')\n nbNode=modelNodes.GetNumberOfItems()\n result=[]\n found=[]\n #print nbNode\n for nthNode in range(nbNode):\n node=slicer.mrmlScene.GetNthNodeByClass(nthNode,'vtkMRMLModelNode')\n if node.GetID() not in found and node.GetAttribute('type')!='Validation':\n dist=[]\n polydata = node.GetPolyData()\n if polydata!=None:\n bounds = polydata.GetBounds()\n for nthNode2 in range(nbNode):\n node2=slicer.mrmlScene.GetNthNodeByClass(nthNode2,'vtkMRMLModelNode')\n if node2.GetID() not in found and node2.GetAttribute('type')=='Validation':\n polydata2 = node2.GetPolyData()\n if polydata2!=None and polydata2.GetNumberOfPoints()>100 and polydata.GetNumberOfPoints()>100:\n\n axialDistance=self.distTip( int(node.GetID().strip('vtkMRMLModelNode')) , int(node2.GetID().strip('vtkMRMLModelNode')))\n \n dist.append([axialDistance,node2.GetID()])\n # print axialDistance\n \n if dist!=[]:\n match=[min(dist)[0],min(dist)[1],node.GetID()]\n result.append(match)\n found.append(min(dist)[1])\n found.append(node.GetID()) \n node.GetDisplayNode().SetSliceIntersectionVisibility(1)\n # print result\n return result","def get_match_ids_not_in_db(match_ids):\n q = select([Match.match_id])\n with engine.connect() as conn:\n result = conn.execute(q).fetchall()\n result = set([match_id[0] for match_id in result])\n\n return match_ids - result","def minima(self, nodeids: Optional[List[str]] = None) -> List[str]:\n\n if nodeids is None:\n nodeids = list(self.graph.nodes)\n\n return [nid for nid in nodeids\n if all(e[0] != nid\n for e in self.graph.edges\n if e[0] in nodeids\n if e[1] in nodeids\n if nid in e)]","def test_no_match(self):\n\n conn, cursor = get_db_cursor()\n build = \"toy_build\"\n database = \"scratch/toy.db\"\n run_info = talon.init_run_info(database, build)\n talon.get_counters(database)\n\n edge_dict = init_refs.make_edge_dict(cursor)\n location_dict = init_refs.make_location_dict(build, cursor)\n transcript_dict = init_refs.make_transcript_dict(cursor, build)\n gene_starts = init_refs.make_gene_start_or_end_dict(cursor, build, \"start\")\n gene_ends = init_refs.make_gene_start_or_end_dict(cursor, build, \"end\")\n\n chrom = \"chr1\"\n strand = \"+\"\n positions = [ 1, 100, 900, 1000 ]\n edge_IDs = [200]\n vertex_IDs = [2, 5]\n v_novelty = [0, 0]\n\n all_matches = talon.search_for_ISM(edge_IDs, transcript_dict)\n assert all_matches == None\n conn.close()","def find_near_nodes(self, new_node):\n number_nodes = len(self.node_list) + 1\n r = self.connect_circle_dist * math.sqrt(\n (math.log(number_nodes) / number_nodes)\n )\n\n # if expand_dist exists, search vertices in a range no more than expand_dist\n if hasattr(self, \"expand_dis\"):\n r = min(r, self.expand_dis)\n dist_list = [\n (node.x - new_node.x) ** 2 + (node.y - new_node.y) ** 2\n for node in self.node_list\n ]\n near_indexes = [dist_list.index(i) for i in dist_list if i <= r ** 2]\n return near_indexes","def _find_unpaired_regions(self, graph, adjacency):\n graph_c = graph.copy()\n unpaired_nodes_list = []\n self._pair_based_graph_cut(graph_c)\n for component in nx.connected_components(graph_c):\n if len(component) >= adjacency:\n unpaired_nodes_list = unpaired_nodes_list + component\n return unpaired_nodes_list","def simple_de_matching(adata, markers, n_genes=100):\n gene_groups = adata.uns['rank_genes_groups']\n de_genes = pd.DataFrame(data=gene_groups['names']).head(n_genes)\n #print(de_genes.head(10))\n\n matches = check_markers(de_genes, markers)\n for key, value in matches.items():\n print(f'-- cluster {key} --')\n print(value)\n\n return de_genes","def get_disjoint_genes(self, other):\n innovs = {g.innov_num for g in other.link_genes}\n if not innovs:\n return []\n max_innov = max(innovs)\n return [g for g in other.link_genes\n if g.innov_num < max_innov and g.innov_num not in innovs]","def remove_xmatch_multiples(index_primary, index_secondary, d2d, d3d, retain_best_match=True,\n verbose=False):\n n_entries = len(index_primary)\n n_unique_entries = len(np.unique(index_primary))\n if verbose:\n print('xmatch: cleanMultipleCrossMatches: there are {0:d} unique entries in the primary '\n 'catalog'.format(n_unique_entries))\n\n if n_entries != n_unique_entries:\n # get array of unique indices (here like identifier) and the corresponding occurrence count\n unique_array, return_counts = np.unique(index_primary, return_counts=True)\n\n # indices in unique array of stars with multiple crossmatches\n index_in_unique_array = np.where(return_counts > 1)[0]\n number_of_stars_with_multiplematches = len(index_in_unique_array)\n if verbose:\n if retain_best_match:\n print('xmatch: result contains {} multiple matches affecting {} entries, '\n 'keeping closest match'.format(number_of_stars_with_multiplematches,\n n_entries - n_unique_entries))\n else:\n print('xmatch: result contains {} multiple matches affecting {} entries, removing '\n 'them all'.format(number_of_stars_with_multiplematches,\n n_entries - n_unique_entries))\n\n # identifiers (i.e. numbers in index_primary) of stars with multiple crossmatches\n multi_matches = unique_array[index_in_unique_array]\n\n # index in index_primary where multiple matches occur\n index_multiple_match = np.where(np.in1d(index_primary, multi_matches))[0]\n if verbose:\n print(d2d[index_multiple_match], index_primary[index_multiple_match], index_secondary[index_multiple_match])\n\n good_index_in_index_primary = np.zeros(number_of_stars_with_multiplematches)\n for ii, jj in enumerate(multi_matches):\n tmp_idx0 = np.where(index_primary[index_multiple_match] == jj)[0]\n tmp_idx1 = np.argmin(d2d[index_multiple_match][tmp_idx0])\n good_index_in_index_primary[ii] = index_primary[index_multiple_match][tmp_idx0[tmp_idx1]]\n\n if retain_best_match:\n index_to_remove = np.setdiff1d(index_multiple_match, good_index_in_index_primary)\n else:\n index_to_remove = index_multiple_match\n\n mask = np.ones(len(index_primary), dtype=bool)\n mask[index_to_remove] = False\n index_primary = index_primary[mask]\n index_secondary = index_secondary[mask]\n d2d = d2d[mask]\n d3d = d3d[mask]\n if len(index_primary) != len(np.unique(index_primary)):\n print('xmatch: Multiple match cleanup procedure failed')\n # get array of unique indices (here like identifier) and the corresponding occurrence count\n unique_array, return_counts = np.unique(index_primary, return_counts=True)\n\n # indices in unique array of stars with multiple crossmatches\n index_in_unique_array = np.where(return_counts > 1)[0]\n number_of_stars_with_multiplematches = len(index_in_unique_array)\n print('xmatch: result still contains {} multiple matches'.format(\n number_of_stars_with_multiplematches))\n\n return index_primary, index_secondary, d2d, d3d","def splitNodes(matching):\n outer = set(range(self.n))\n inner = set([])\n for (u, v) in matching:\n if u in outer:\n outer.remove(u)\n if v in outer:\n outer.remove(v)\n inner.add(u)\n inner.add(v)\n return list(inner), list(outer)","def find_longest_matches(sorted_nodes1, sorted_nodes2):\n root = TreeNode(-1,-1)\n fill_tree(root, sorted_nodes1, sorted_nodes2)\n match = find_treepaths(root, [])\n\n # Remove (-1, -1) superroot.\n if isinstance(match[0], list): # More than one match of the same length.\n res = []\n for m in match:\n res.append([node.to_tuple() for node in m[1:]])\n return res\n else:\n return [[node.to_tuple() for node in match[1:]]]","def find_nonexceed(trainy, train_tree_node_ID, pred_tree_node_ID, thres):\n \n npred = pred_tree_node_ID.shape[0]\n out = np.zeros((npred, thres.shape[0]))*np.nan\n for i in prange(pred_tree_node_ID.shape[0]):\n for j in prange(thres.shape[0]):\n idxs = np.where(train_tree_node_ID == pred_tree_node_ID[i, :])[0]\n sample = trainy[idxs]\n out[i, j] = (sample < thres[j]).sum() / float(sample.shape[0])\n return out","def neighbours_R(self):\n seen = set()\n return [l.other(self) for l in self.dovetails_R \\\n if id(l) not in seen and not seen.add(id(l))]","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 compare_nodes(G,all_match_pairs,match_pair,traversed,node1,node2, ports_weight):\n logger.debug(f\"comparing {node1},{node2}, traversed {traversed}\")\n nbrs1 = sorted(set(G.neighbors(node1)) - set(traversed))\n #remove dummies\n nbrs1 = sorted(set([nbr for nbr in nbrs1 if G.get_edge_data(node1, nbr)['weight'] !=7]))\n nbrs2 = sorted(set(G.neighbors(node2)) - set(traversed))\n #remove dummies\n nbrs2 = sorted(set([nbr for nbr in nbrs2 if G.get_edge_data(node2, nbr)['weight'] !=7]))\n logger.debug(f\"node1:{node1},property: {G.nodes[node1]},neigbors1: {nbrs1}\")\n logger.debug(f\"node2:{node2},property: {G.nodes[node2]},neigbors2: {nbrs2}\")\n if not nbrs1 or not nbrs2:\n if compare_two_nodes(G, node1, node2, ports_weight):\n match_pair[node1] = node2\n logger.debug(f\"no new neihbours, returning recursion {match_pair}\")\n return\n elif len(nbrs1)> 10:\n if \"start_point\" in match_pair.keys():\n match_pair[\"start_point\"]+=[node1,node2]\n else:\n match_pair[\"start_point\"]=[node1,node2]\n logger.debug(f\"skipping high fanout nets due to large computation, {node1} {nbrs1}\")\n traversed.append(node1)\n return\n elif len(nbrs2)> 10:\n if \"start_point\" in match_pair.keys():\n match_pair[\"start_point\"]+=[node1,node2]\n else:\n match_pair[\"start_point\"]=[node1,node2]\n traversed.append(node2)\n logger.debug(f\"skipping high fanout nets due to large computation, {node2} {nbrs2}\")\n return\n\n if node1 == node2:\n if node1 in match_pair.keys() or node1 in match_pair.values():\n logger.debug(\"avoid existing pair wise symmetry\")\n return\n logger.debug(f\"single node {node1}, nbrs {nbrs1}, nbr_weight {[G.get_edge_data(node1,nbr) for nbr in nbrs1]}\")\n SD_nbrs= [nbr for nbr in nbrs1 if G.get_edge_data(node1, nbr)['weight'] !=2]\n ## TBD: filter based on primitive constraints\n ## Right now will try to figure out S/D paths\n if len(SD_nbrs) ==0:\n logger.debug(f\"No SD paths found to traverse\")\n match_pair[node1]=node1\n elif len(SD_nbrs) ==1:\n logger.debug(f\"traversing single S/D path {SD_nbrs}\")\n match_pair[node1]=node1\n traversed.append(node1)\n compare_nodes(G,all_match_pairs,match_pair,traversed,SD_nbrs[0],SD_nbrs[0],ports_weight)\n else:\n logger.debug(f\" multiple nodes diverging {SD_nbrs}\")\n logger.debug(f\"nbr weights: {SD_nbrs} {[G.get_edge_data(node1, nbr)['weight'] for nbr in SD_nbrs ]}\")\n match_pair[node1]=node1\n traversed.append(node1)\n new_sp=sorted(set(SD_nbrs)-set(traversed))\n all_match_pairs_local={}\n for nbr1,nbr2 in combinations(new_sp, 2):\n logger.debug(f\"recursive pair call from single branch {nbr1} {nbr2}\")\n new_pair={}\n compare_nodes(G,all_match_pairs,new_pair,traversed.copy(),nbr1,nbr2,ports_weight)\n if new_pair:\n #new_pair[nbr1]=nbr2\n all_match_pairs_local[nbr1+'_'+nbr2] = new_pair\n all_match_pairs_local={k: v for k, v in all_match_pairs_local.items() if len(v)>0}\n if len(all_match_pairs_local)==1:\n match_pair.update( all_match_pairs_local[list(all_match_pairs_local.keys())[0]])\n logger.debug(f\"found inline pair: {pprint.pformat(match_pair, indent=4)}\")\n else:\n for nbr1 in new_sp:\n if (nbr1+'_'+nbr1 not in all_match_pairs.keys()):\n logger.debug(f\"recursive single branch call from single branch {nbr1} {nbr1}\")\n new_pair={}\n compare_nodes(G,all_match_pairs,new_pair,traversed.copy(),nbr1,nbr1,ports_weight)\n #filtering multiple axis of symmetries with same block, ideally they should be handled by array generation\n if new_pair:\n all_match_pairs[nbr1+'_'+nbr1] = new_pair\n logger.debug(f\"updating match pairs: {pprint.pformat(all_match_pairs, indent=4)}\")\n\n\n elif nbrs1 == nbrs2:\n logger.debug(f\"traversing converging branch\")\n match_pair[node1]=node2\n traversed+=[node1,node2]\n nbrs1=sorted(set(nbrs1)-set([node1,node2]))\n logger.debug(f\"all non traversed neighbours: {nbrs1}\")\n if len(nbrs1)==1:\n nbr1=nbr2=nbrs1[0]\n logger.debug(f\"keeping single converged branch inline {nbr1} {nbr2}\")\n compare_nodes(G,all_match_pairs,match_pair,traversed.copy(),nbr1,nbr2,ports_weight)\n else:\n for nbr1,nbr2 in combinations_with_replacement(nbrs1,2):\n logger.debug(f\"recursive call from converged branch {nbr1} {nbr2}\")\n if nbr1+'_'+nbr2 not in all_match_pairs.keys():\n new_pair={}\n compare_nodes(G,all_match_pairs,new_pair,traversed.copy(),nbr1,nbr2,ports_weight)\n #filtering multiple axis of symmetries with same block, ideally they should be handled by array generation\n if new_pair:\n all_match_pairs[nbr1+'_'+nbr2] = new_pair\n logger.debug(f\"updating match pairs: {pprint.pformat(all_match_pairs, indent=4)}\")\n\n\n elif compare_two_nodes(G,node1,node2,ports_weight):\n nbrs1 = sorted(set([nbr for nbr in nbrs1 if G.get_edge_data(node1, nbr)['weight'] !=2]))\n nbrs2 = sorted(set([nbr for nbr in nbrs2 if G.get_edge_data(node2, nbr)['weight'] !=2]))\n match_pair[node1]=node2\n traversed+=[node1,node2]\n logger.debug(f\"Traversing parallel branches from {node1},{node2} {nbrs1}, {nbrs2}\")\n nbrs1_wt = [G.get_edge_data(node1, nbr)['weight'] for nbr in nbrs1]\n nbrs2_wt = [G.get_edge_data(node2, nbr)['weight'] for nbr in nbrs2]\n unique_match=find_unique_matching_branches(G,nbrs1,nbrs2,ports_weight)\n if len(nbrs1)==0 or len(nbrs2)==0:\n logger.debug(f\"no new SD neihbours, returning recursion {match_pair}\")\n elif len(nbrs1) ==1 and len(nbrs2)==1:\n logger.debug(f\"traversing binary branch\")\n compare_nodes(G,all_match_pairs,match_pair,traversed,nbrs1.pop(),nbrs2.pop(),ports_weight)\n elif unique_match:\n logger.debug(f'traversing unique matches {unique_match}')\n match_pair[node1]=node2\n traversed+=[node1,node2]\n for nbr1,nbr2 in unique_match.items():\n logger.debug(f\"recursive call from binary {node1}:{node2} to {nbr1}:{nbr2}\")\n compare_nodes(G,all_match_pairs,match_pair,traversed.copy(),nbr1,nbr2,ports_weight)\n elif len(nbrs1_wt)>len(set(nbrs1_wt))>1 and len(nbrs2_wt)>len(set(nbrs2_wt))>1:\n logger.debug(f\"setting new start points {node1} {node2}\")\n match_pair[node1]=node2\n if \"start_point\" in match_pair.keys():\n match_pair[\"start_point\"]+=[node1,node2]\n else:\n match_pair[\"start_point\"]=[node1,node2]\n else:\n match_pair = {}\n logger.debug(f\"end all traversal from binary branch {node1} {node2}\")\n\n else:\n match_pair = {}\n logger.debug(f\"end of recursion branch, matches {match_pair}\")","def eliminiateEmptyEdges(self, distance = 100):\n print \"Edge elimination started\"\n \n selected_edge_ids = []\n # let us \n \n for point in self.gps_points:\n results = self.idx.nearest(((point.getPoint().x-distance/2), \n (point.getPoint().y-distance/2),\n (point.getPoint().x+distance/2),\n (point.getPoint().y+distance/2)), objects=True)\n for result in results:\n from_node = self.node_counter__node.get(result.object.from_node.getAttributes().get(\"nodecounter\"))\n to_node = self.node_counter__node.get(result.object.to_node.getAttributes().get(\"nodecounter\"))\n edge_counter = self.G.edge[from_node][to_node].get(\"edgecounter\")\n if edge_counter not in selected_edge_ids:\n selected_edge_ids.append(edge_counter)\n print str(len(selected_edge_ids)) + \" edges found to keep.\"\n \n elimination_counter = 0\n for edge in self.G.edges():\n edgecounter = self.G.edge[edge[0]][edge[1]].get(\"edgecounter\")\n if edgecounter not in selected_edge_ids:\n edge_tuple = (self.G.edge[edge[0]][edge[1]].get(\"edge\").from_node, self.G.edge[edge[0]][edge[1]].get(\"edge\").to_node)\n self.G.remove_edge(*edge_tuple)\n elimination_counter = elimination_counter + 1\n \n print str(elimination_counter) + \" edges eliminated.\"","def find_similar_hashes(self):\n matches = self.hasher.find_matches(self.__offset_hash_map.values())\n print(\" Found {} matches.\".format(len(matches)))\n\n print(\" Formatting the found matches. This takes some time ...\")\n self.__matched_offsets = self.__to_offset_list(matches, self.__offset_hash_map)\n\n return","def map_graph_id(self):\n for graph_id in self.NX_GRAPHS:\n graph = self.NX_GRAPHS[graph_id]\n flag = 0\n try:\n for node_idx in range(len(graph.nodes)):\n if np.sum(\n np.array(graph.nodes[node_idx]['h']) == \n np.array(self.dgl_graph.nodes[node_idx].data['h'][0])) != 128:\n flag = -1\n break\n if flag == -1:\n continue\n else:\n self.graph_id = graph_id\n break\n except:\n pass","def get_matching_genes(self, other):\n innovs = {g.innov_num for g in other.link_genes}\n if not innovs:\n return []\n max_innov = max(innovs)\n return [g for g in self.link_genes\n if g.innov_num in innovs]","def get_nids(self, rids=None):\n if rids == None: # return all nids in all recordings\n rids = list(self.r)\n return np.unique(np.hstack([ list(self.r[rid].n) for rid in rids ]))\n else: # return intersection of nids of specified recordings\n nids = [ list(self.r[rid].n) for rid in rids ]\n return core.intersect1d(nids, assume_unique=True)","def identifyMindist(align, ignoreGaps=True):\n align = padAlignment(align)\n cons = consensus(align, ignoreGaps)\n dist = align.map(partial(hamming_distance, cons))\n return align[dist.argmin()]","def find_edges_seed(rna_seq_objs, xgmml_obj, args, stats):\n nodes_copy = rna_seq_objs\n while len(nodes_copy) > 2:\n nodes_copy[0].use_for_comparison = False\n seq_pairs = []\n # go through and find all the matches\n # then remove matches and start again till gone\n for x in range(1, len(nodes_copy) - 1):\n # new nodes_copy[0] each time a node is deleted\n pair = RNASequencePair(\n nodes_copy[0], nodes_copy[x], xgmml_obj\n )\n pair.energy_delta = abs(\n pair.sequence1.free_energy - pair.sequence2.free_energy\n )\n pair.edit_distance = Levenshtein.distance(\n pair.sequence1.sequence, pair.sequence2.sequence\n )\n seq_pairs.append(pair)\n process_seq_pairs(seq_pairs, args, stats)\n for x in seq_pairs:\n if x.is_valid_edge:\n x.sequence2.use_for_comparison = False\n # delete nodes which already belong to an edge\n new_nodes_copy = [\n z for z in nodes_copy if z.use_for_comparison\n ]\n print 'Number of RNA sequences reduced from %d to %d ' % (\n len(nodes_copy), len(new_nodes_copy)\n )\n nodes_copy = new_nodes_copy","def _reduce_distances(self, threshold):\n reduced = self.orig_dists.copy()\n reduced[reduced <= threshold] = 0\n # Remove ignored from all consideration\n ignrd_indices = [self.index[name] for name in self.ignored]\n if ignrd_indices:\n reduced[:,ignrd_indices] = np.inf\n reduced[ignrd_indices,:] = np.inf\n # Check if the given parameters are feasible\n chsn_indices = set(self.index[name] for name in self.chosen)\n avail_indices = set(self.index[name] for name in self.available)\n ca_indices = chsn_indices | avail_indices\n unassigned_indices = np.array(list(self._not_ignored_inds - ca_indices))\n if len(unassigned_indices) == 0:\n unassigned_orphans = unassigned_indices\n else:\n ca_indices = list(ca_indices)\n avail_in_range = np.count_nonzero(reduced[np.ix_(unassigned_indices,ca_indices)] == 0, axis=1)\n unassigned_orphans = unassigned_indices[avail_in_range == 0]\n return reduced, unassigned_orphans","def _partition_nearest(self, medoids, dists, only_these=set()):\n if len(only_these) == 0:\n allowed_inds = self._not_ignored_inds\n else:\n allowed_inds = self._not_ignored_inds & only_these\n closest_medoid_ind = np.argmin(dists[:,medoids], 1) # If len(medoids)==3, would look like [2,1,1,0,1,2,...].\n clusts = [[] for i in medoids]\n for node_ind, med_ind in enumerate(closest_medoid_ind):\n if node_ind in allowed_inds:\n clusts[med_ind].append(node_ind)\n return clusts","def get_identical_nodes(self):\n\n return self._identical_nodes","def prune(self, alignment_infos):\n alignments = []\n best_score = 0\n\n for alignment_info in alignment_infos:\n score = IBMModel4.model4_prob_t_a_given_s(alignment_info, self)\n best_score = max(score, best_score)\n alignments.append((alignment_info, score))\n\n threshold = IBMModel5.MIN_SCORE_FACTOR * best_score\n alignments = [a[0] for a in alignments if a[1] > threshold]\n return set(alignments)","def common_ids(descendent_ids, ancestor_ids, threshold=0.5):\n\n common = np.intersect1d(descendent_ids, ancestor_ids)\n return common.size > threshold * ancestor_ids.size","def find_nearby_membranes(all_membranes, all_membrane_map, vert_normals):\r\n membrane_tree = scipy.spatial.cKDTree(all_membranes)\r\n nearby_membranes = np.array(list(membrane_tree.query_pairs(adhesion_max_dist, p=2)))\r\n nearby_membrane_map = defaultdict(list)\r\n if nearby_membranes.shape[0] > 0:\r\n # Exclude same-cell membrane interactions and same-direction-facing segments\r\n all_vert_normals = np.concatenate(vert_normals, axis=0)\r\n subset = np.where(\r\n (all_membrane_map[nearby_membranes[:, 0], 0] !=\r\n all_membrane_map[nearby_membranes[:, 1], 0])\r\n & (np.einsum('ij,ik->i', all_vert_normals[nearby_membranes[:, 0]], all_vert_normals[nearby_membranes[:, 1]]) < 0.0)\r\n )\r\n nearby_membranes = nearby_membranes[subset]\r\n # {cell idx: (vert idx, other cell idx, other vert idx, 'all_membranes' vert idx)}\r\n for nm in nearby_membranes:\r\n m0 = all_membrane_map[nm[0]]\r\n m1 = all_membrane_map[nm[1]]\r\n nearby_membrane_map[m0[0]].append((m0[1], m1[0], m1[1], nm[1]))\r\n nearby_membrane_map[m1[0]].append((m1[1], m0[0], m0[1], nm[0]))\r\n nearby_membrane_map = {k: np.array(v)\r\n for k, v in nearby_membrane_map.items()}\r\n# print(nearby_membrane_map)\r\n return nearby_membranes, nearby_membrane_map","def no_match():\n S1=Spectrum.Spectrum()\n S1.add_peak(50.7,234)\n S1.add_peak(54.6,585)\n S1.add_peak(60.7,773)\n S1.add_peak(65.6,387)\n S1.add_peak(87.7,546)\n S1.add_peak(104.6,598)\n S1.pep_mass=100\n S1.euclidean_scale()\n\n S2=Spectrum.Spectrum()\n S2.add_peak(50.2,234)\n S2.add_peak(53.8,585)\n S2.add_peak(61.3,773)\n S2.add_peak(66.2,387)\n S2.add_peak(88.1,546)\n S2.add_peak(103.9,598)\n S2.pep_mass=100\n S2.euclidean_scale()\n\n score,peaks=similarity.cosine_score_max(S1,S2)\n assert peaks==0, \"Incorrect number of peaks matched with greedy method\"\n assert score==0, \"Incorrect score with greedy method\"\n \n\n score,peaks=similarity.cosine_score_greedy(S1,S2)\n assert peaks==0, \"Incorrect number of peaks matched with maximum weighted method\"\n assert score==0, \"Incorrect score with maximum weighted method\"","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 test_no_extra_ids():\n\tNLNP_pairs = set()\n\tall_ids = set()\n\tfor cat in nset['categories']:\n\t\tall_ids.add(cat['id'])\n\t\n\tfor search_row in map_rows:\n\t\tNL, NP = search_row[2], search_row[3]\n\t\tif not NL == 'NA':\n\t\t\tNLNP_pairs.add((NL, NP))\n\n\tassert len(all_ids) == len(nset['categories'])\n\tassert len(NLNP_pairs) == len(all_ids)","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 find_mutual_nn(self):\n best_match_src = self.scores.argmax(1) # Best match for each source word\n best_match_trg = self.scores.argmax(0) # Best match for each source word\n\n # ONELIENER\n # paired_idx = [(i,best_match_src[i]) for i in range(self.ns) if best_match_trg[best_match_src[i]] == i]\n # paired_words = [(self.src_words[i],self.trg_words[j]) for (i,j) in paired_idx]\n paired = []\n for i in range(self.ns):\n m = best_match_src[i]\n if best_match_trg[m] == i:\n paired.append((i,m))\n\n paired_toks = []\n if self.src_words and self.trg_words:\n paired_toks = [(self.src_words[i],self.trg_words[j]) for (i,j) in paired]\n else:\n paired_toks = paired\n return paired_toks","def nms_match(dets: array_like_type,\n iou_threshold: float) -> List[array_like_type]:\n if dets.shape[0] == 0:\n matched = []\n else:\n assert dets.shape[-1] == 5, 'inputs dets.shape should be (N, 5), ' \\\n f'but get {dets.shape}'\n if isinstance(dets, Tensor):\n dets_t = dets.detach().cpu()\n else:\n dets_t = torch.from_numpy(dets)\n indata_list = [dets_t]\n indata_dict = {'iou_threshold': float(iou_threshold)}\n matched = ext_module.nms_match(*indata_list, **indata_dict)\n if torch.__version__ == 'parrots':\n matched = matched.tolist() # type: ignore\n\n if isinstance(dets, Tensor):\n return [dets.new_tensor(m, dtype=torch.long) for m in matched]\n else:\n return [np.array(m, dtype=int) for m in matched]","def _reduce_search_space(self, neighbors_reduction_thr=18):\n centroid_matrix = bundles_distances_mdf(self.model_centroids,\n self.centroids)\n centroid_matrix[centroid_matrix >\n neighbors_reduction_thr] = np.inf\n\n mins = np.min(centroid_matrix, axis=0)\n close_clusters_indices = np.array(np.where(mins != np.inf)[0],\n dtype=np.int32)\n\n self.neighb_indices = []\n for i in close_clusters_indices:\n self.neighb_indices.extend(self.wb_clusters_indices[i])\n self.neighb_indices = np.array(self.neighb_indices, dtype=np.int32)\n self.neighb_streamlines = _reconstruct_streamlines(self.memmap_filenames,\n self.neighb_indices)\n\n self.neighb_centroids = [self.centroids[i]\n for i in close_clusters_indices]\n\n return len(close_clusters_indices) > 0","def find_specific_primer_matches(primers,\n integer_mapped_seq,\n deletion_threshold,\n seq_count,\n sequence_length,\n label,\n unaligned_seq,\n region_slice,\n seq):\n \n primer_len=sequence_length\n overall_length=region_slice+primer_len\n bad_primers=[]\n seq_length=len(integer_mapped_seq)\n \n if len(unaligned_seq)==0:\n raise_(ValueError,('unaligned sequence contains no data.'))\n \n for p in range(len(primers)):\n corrected_index = get_corrected_index(seq,primers[p].aligned_index)\n start_index = corrected_index\n end_index = corrected_index + primer_len\n \n \n # skip test if testing beyond the end of the sequence\n if end_index > seq_length:\n continue\n # Will return all non-zeros with perfect base pair matching\n seq_bitwise = bitwise_and(primers[p].numeric_seq,\n integer_mapped_seq[start_index:end_index])\n if len(seq_bitwise.nonzero()[0])==primer_len:\n primers[p].non_specific_hits +=1\n if primers[p].non_specific_hits>deletion_threshold:\n bad_primers.append(p)\n\n \n del_primers(primers,bad_primers)\n return primers","def match_any_node_id(self, match):\n pass","def test_multi_no_match_return_expr(self):\n eq_(None,line_no_matches_ngreps(self.line,[\"foo\",\"idontmatch\"]))","def test_get_new_otu_id_large(self):\r\n tree = DndParser(\"(A:0.1,B:0.2,(C:0.3,D:0.4):0.5);\")\r\n results = []\r\n for i in range(1000):\r\n results.append(qiime.simsam.get_new_otu_id(old_otu_id='D',\r\n tree=tree, dissim=.6))\r\n self.assertTrue('C' in results)\r\n self.assertTrue('D' in results)\r\n self.assertTrue('A' not in results)\r\n self.assertTrue('B' not in results)","def match_cells(gt_cells, m_cells, storm_input, filtered_binaries, max_d=3):\n img_numbers = np.array([int(re.findall(r'(\\d+)', cell.name)[0]) for cell in m_cells])\n encoded_gt = encode_intensity(gt_cells)\n\n false_positive = 0\n bordering = 0\n too_far = 0\n max_idx_gt = 0\n\n gt_matched, m_matched = [], []\n for i in tqdm(np.unique(storm_input['frame'])): # Iteration starts at 1 (ImageJ indexing)\n st_elem = storm_input[storm_input['frame'] == i].copy()\n X = np.array([st_elem['x'], st_elem['y']]).T.copy()\n linkage = fc.linkage(X)\n clusters = fcluster(linkage, max_d, criterion='distance')\n clustered_st = [st_elem[clusters == i] for i in np.unique(clusters)]\n encoded_storm = [encode(elem['intensity']) for elem in clustered_st]\n\n s_cells = m_cells[img_numbers == (i - 1)]\n if len(s_cells) == 0:\n print('No cells, img {}'.format(i))\n continue\n\n cell_numbers = np.array([int(re.findall(r'(\\d+)', cell.name)[1]) for cell in s_cells])\n binary_img = filtered_binaries[i - 1]\n coms_cells = np.array([mh.center_of_mass(binary_img == j) for j in cell_numbers])\n\n matched = 0\n for cluster, code in zip(clustered_st, encoded_storm):\n\n # Find the GT cell\n idx_gt = np.argwhere(code == encoded_gt)\n if idx_gt > max_idx_gt:\n max_idx_gt = idx_gt\n\n if len(idx_gt) == 0:\n # print('Cluster not in cells, probably bordering cell')\n bordering += 1\n continue\n else:\n gt_cell = gt_cells[idx_gt[0][0]]\n\n # Find the M cell\n com_storm = [np.mean(cluster['y']), np.mean(cluster['x'])]\n ds = np.sqrt((coms_cells[:, 0] - com_storm[0]) ** 2 + (coms_cells[:, 1] - com_storm[1]) ** 2)\n\n idx_m = np.argmin(ds)\n if np.min(ds) > 20:\n too_far += 1\n continue\n else:\n matched += 1\n m_cell = s_cells[idx_m]\n\n gt_matched.append(gt_cell.name + '\\n')\n m_matched.append(m_cell.name + '\\n')\n\n false_positive += (len(s_cells) - matched)\n\n print('False positive', false_positive)\n print('Bordering, Too far', bordering, too_far)\n print('Max GT index:', max_idx_gt)\n\n return gt_matched, m_matched","def nodes_with_m_nbrs(G,m):\n nodes = set()\n \n # Iterate over all nodes in G\n for n in G.nodes():\n \n # Check if the number of neighbors of n matches m\n if len(G.neighbors(n)) == m:\n \n # Add the node n to the set\n nodes.add(n)\n \n # Return the nodes with m neighbors\n return nodes","def match3(img1, img2, coordinates1, coordinates2, PATCH_SIZE, threshold=0.7):\n\n\t#creating patches for all points from img1 and img2\n\tcoord1_patches = [make_patch(coordinate, PATCH_SIZE, img1) for coordinate in coordinates1]\n\tcoord2_patches = [make_patch(coordinate, PATCH_SIZE, img2) for coordinate in coordinates2]\n\n\t# creating a matrix with dissimilarity measures for all pairs\n\tall_matches = np.zeros((len(coordinates1), len(coordinates2)))\n\n\tfor (x, y), _ in np.ndenumerate(all_matches):\n\t\tall_matches[x,y] = count_difference(coord1_patches[x], coord2_patches[y])\n\n\t#looking for best left-to-right and right-to-left matches\n\tmatches = []\n\t#left-to-right\n\tfor i, coord1 in enumerate(coordinates1):\n\t\tbest_ltr_match = np.argmin(all_matches[i, :]) #best left-to-right match for coord1\n\t\tbest_rtl_match = np.argmin(all_matches[:, best_ltr_match]) #best match for a best match\n\t\tif (i == best_rtl_match): #hurray, there is a super match\n\n\t\t\tmatches.append([coord1, coordinates2[best_ltr_match], all_matches[i, best_ltr_match]])\n\t\n\treturn matches","def mi_from_dm_alt_hq(distance_matrix, ns, nh, spike_train_list=None):\n \n print \"start loading\"\n \n nr = len(distance_matrix)\n nt = nr/ns\n #nearest_neighbours = np.array([r.argsort()[:nh] for r in distance_matrix])\n nearest_neighbours = np.array([np.array(hq.nsmallest(nh, r)) for r in distance_matrix])\n near_to = [[j for j in range(nr) if i in nearest_neighbours[j] ] for i in range(nr)]\n \n print \"finished sorting\"\n return\n #nr = len(distance_matrix)\n #nearest_neighbours = np.array([[i] + distance_matrix[i].argsort()[1:nh].tolist() for i in range(nr)])\n \n members_of_glob = trains_in_glob(spike_train_list)\n glob_comp = glob_composition(spike_train_list, ns, nt, nh)\n \n counts = []\n counted_glob = False #set a flag for later use\n if spike_train_list is not None:\n for i in range(len(near_to)):\n c_i = 0\n \n if i not in members_of_glob:\n #print near_to[i]\n for j in near_to[i]:\n if j not in members_of_glob and spike_train_list[i].start_time == spike_train_list[j].start_time:\n c_i += 1\n else:\n if not counted_glob: #this should only really happen if glob has a small number of members...\n f_i = glob_comp[i]/float(sum(glob_comp.values()))\n g_i = f_i - 1.0/float(sum(glob_comp.values()))\n c_i += (nh - c_i)*g_i\n \n counted_glob = True\n else:\n pass\n \n else: #If i is in the glob...\n f_i = glob_comp[i]/float(sum(glob_comp.values()))\n g_i = f_i - 1.0/float(sum(glob_comp.values()))\n c_i = 1 + (nh - 1)*g_i\n \n counts.append(c_i) \n counts = np.array(counts) \n I = (1.0/nr)*sum( np.log2((ns*counts)/float(nh)) ) \n \n else:\n near_to_same_stim = [[n for n in near_to[j] if abs(n-j)%ns==0 ] for j in range(nr)]\n number_of_neighbourhoods = np.array([len(l) for l in near_to])\n number_of_neighbourhoods_same_stim = np.array([len(l) for l in near_to_same_stim])\n I = (1.0/nr)*sum( np.log2((ns*number_of_neighbourhoods_same_stim)/float(nh)) )\n \n return I","def match_all(data_dir):\n print('Loading GT')\n gt_cells = load(os.path.join(data_dir, 'cell_obj', 'cells_final_selected.hdf5'))\n storm_i = np.load(os.path.join(data_dir, 'images', 'storm_inner.npy'))\n\n for ph in [10000, 1000, 500]:\n print('Photons {}'.format(ph))\n\n m_cells = load(os.path.join(data_dir, 'cell_obj', 'cell_ph_{}_raw.hdf5'.format(ph)))\n print('Measured cells loaded')\n\n bin_predicted = tifffile.imread(os.path.join(data_dir, 'images', 'binary_{}photons_predicted.tif'.format(ph)))\n print('Filtering')\n filtered_pred = filter_binaries(bin_predicted, min_size=495, max_size=2006.4, min_minor=7.57, max_minor=17.3,\n min_major=15.41, max_major=54.97)\n\n gt_match, m_match, = match_cells(gt_cells, m_cells, storm_i, filtered_pred, max_d=5)\n\n print('Matched {} cells out of max {}'.format(len(m_match), len(m_cells)))\n\n for i, (m_, gt_) in tqdm(enumerate(zip(m_match, gt_match))):\n m_i = m_cells.name.tolist().index(m_.rstrip())\n g_i = gt_cells.name.tolist().index(gt_.rstrip())\n\n try:\n assert len(m_cells[m_i].data.data_dict['storm_inner']) == len(gt_cells[g_i].data.data_dict['storm_inner'])\n except AssertionError:\n print('Assertion error:', i)\n\n with open(os.path.join(data_dir, 'matched_names', 'gt_cells_ph_{}_match.txt'.format(ph)), 'w') as f:\n f.writelines(gt_match)\n\n with open(os.path.join(data_dir, 'matched_names', 'm_cells_ph_{}_match.txt'.format(ph)), 'w') as f:\n f.writelines(m_match)","def out_of_place_dissimilarity(self, other):\n # Based on the implementation provided by the textcat R package\n # http://cran.r-project.org/web/packages/textcat/index.html.\n sorted_self = [ngram for ngram, freq in\n sorted(iteritems(self._ngrams),\n key=operator.itemgetter(1), reverse=True)]\n sorted_other = [ngram for ngram, freq in\n sorted(iteritems(other._ngrams),\n key=operator.itemgetter(1), reverse=True)]\n dissimilarity = 0\n for j in range(len(sorted_other)):\n if sorted_other[j] in self:\n i = sorted_self.index(sorted_other[j])\n dissimilarity += abs(i - j)\n else:\n dissimilarity += len(sorted_self)\n return dissimilarity","def get_plate_ids_from_node_ids(self, nodes: list[int]) -> list[int]:\n ids = []\n\n for k, v in vars(self).items():\n if v.nodes == nodes:\n ids.append(k)\n\n if len(ids) == 0:\n ids = None\n\n return ids","def sm_get_matching_blocks(s1,s2,min_length=1):\n anslist= list(SM(None, s1, s2).get_matching_blocks())\n\n\n anslist = [ l for l in anslist if l.size>=min_length]\n\n anslist=[ (s1[l.a:l.a+l.size], l.a, l.b, l.size) for l in anslist]\n return anslist","def _get_ring_nodes(m, namin=3, namax=9, remove_redudant=T):\n # first search for rings\n sets = []\n for i in range(namin, namax+1):\n #if i in [3,4,5]:\n pat_i = '*~1' + '~*'*(i-2) + '~*1'\n #else:\n # pat_i = '*:1' + ':*'*(i-2) + ':*1'\n Qi = Chem.MolFromSmarts( pat_i )\n for tsi in m.GetSubstructMatches(Qi):\n set_i = set(tsi)\n if set_i not in sets:\n sets.append( set(tsi) )\n if remove_redudant:\n # now remove those rings that are union of smaller rings\n n = len(sets)\n sets_remove = []\n ijs = itl.combinations( list(range(n)), 2 )\n sets_u = []\n for i,j in ijs:\n set_ij = sets[i].union( sets[j] )\n if (set_ij in sets) and (set_ij not in sets_remove):\n sets_remove.append( set_ij )\n sets_u = cim.get_compl(sets, sets_remove)\n else:\n sets_u = sets\n return sets_u","def starting_nodes(self):\n # Level 0 nodes in a directed graph will have 1 or more out_edges but no in_edges\n nodes_with_outs = set(e[0] for e in self.G2.out_edges())\n nodes_with_ins = set(e[1] for e in self.G2.in_edges())\n return nodes_with_outs - nodes_with_ins","def contained(self):\n seen = set()\n return [l.to_segment for l in self.edges_to_contained \\\n if id(l) not in seen and not seen.add(id(l))]","def get_neighbours(kmer, max_d):\n assert (is_dna(kmer))\n result = set([kmer])\n for i in range(max_d):\n addded = set()\n for kmer in result:\n addded |= _get_neighbours(kmer)\n result |= addded\n return result","def intersection(matrix,n1,n2):\n inter = []\n for n,v in matrix[n1.id].items():\n if v == None and matrix[n2.id][n] == None:\n inter.append(n)\n return inter","def perform_mindmatch(\n A: np.array, n_trim: int = None,\n n_match: int = 6, cois: list = None\n):\n # setting distance in the diagonal\n A[np.arange(len(A)), np.arange(len(A))] = -1000 \n\n # if conflict of interest (COIs) is available, add to the matrix\n cois = [(c1, c2) for (c1, c2) in cois\n if c1 <= len(A) and c2 <= len(A)] # make sure a given cois is in range\n A[np.array(cois)] = -1000\n\n # trimming affinity matrix to reduce the problem size\n if n_trim != 0:\n A_trim = []\n for r in range(len(A)):\n a = A[r, :]\n a[np.argsort(a)[0:n_trim]] = 0\n A_trim.append(a)\n A_trim = np.vstack(A_trim)\n else:\n A_trim = A\n\n # solving matching problem\n print('Solving a matching problem...')\n v, K, d = create_lp_matrix(A_trim, \n min_reviewers_per_paper=n_match, max_reviewers_per_paper=n_match,\n min_papers_per_reviewer=n_match, max_papers_per_reviewer=n_match)\n x_sol = linprog(v, K, d)['x']\n b = create_assignment(x_sol, A_trim)\n\n if (b.sum() == 0):\n print('Seems like the problem does not converge, try reducing <n_trim> but not too low!')\n else:\n print('Successfully assigned all the match!')\n return b","def create_match_instance_pairs(plant_match_in):\r\n\t## collect all plant name match instances indices\r\n\tjust_indices = [int(indices) for plant_match_in_set in plant_match_in for indices in plant_match_in_set[1]]\r\n\t\r\n\tassert len(just_indices) == len(set(just_indices)) # check there are no exact duplicates in indices\r\n\r\n\tsorted_index = list(sorted(just_indices)) # sort indices small-large\r\n\tprint(f'Length of corpus bigrams BEFORE ambiguous matches removed: {len(sorted_index)}')\r\n\t#print(sorted_index)\r\n\r\n\t# remove all ambiguous matches that are within 1 word of each other\r\n\tprint('Ambiguous plant name matches: ')\r\n\tfor i, index in enumerate(sorted_index): # iterate over all indices in sorted list\r\n\t\t\r\n\t\tif index == sorted_index[i-1]+1: # indices is within 1 of previous indices in list\r\n\t\t\tprint(index, sorted_index[i-1])\r\n\t\t\tsorted_index.remove(index) # remove indices from list\r\n\t\t\tsorted_index.remove(sorted_index[i-1]) # AND remove previous indices from list\r\n\tprint(f'Length of corpus bigrams AFTER ambiguous matches removed: {len(sorted_index)}')\r\n\r\n\t# create indices dict with 'B', 'I' values\r\n\tpaired_finds = {}\r\n\tfor match_index in sorted_index: # iterate over unambiguous match indices list\r\n\t\t\t\t\t\r\n\t\t\tpaired_finds[match_index] = ('B') # WITH value of 'B'\r\n\t\t\t\r\n\t\t\tpaired_finds[match_index+1] = ('I') # WITH value of 'I'\r\n\r\n\treturn paired_finds","def remove_duplicates_by_matching():\n # 1) and 2)\n all_blobs = vision.pqr_r\n all_angles = np.zeros(0)\n right = np.transpose(vision.pqr_r)\n left = np.transpose(vision.pqr_l)\n\n if not right.size and not left.size:\n return (0, 0)\n\n if not right.size:\n for l in left:\n angle = np.arctan2(l[1], l[0]) * 180 / pi\n all_angles = np.append(all_angles, angle)\n return (vision.pqr_l, all_angles)\n\n if not left.size:\n for r in right:\n angle = np.arctan2(r[1], r[0]) * 180 / pi\n all_angles = np.append(all_angles, angle)\n return (vision.pqr_r, all_angles)\n\n\n for r in right:\n angle = np.arctan2(r[1], r[0]) * 180 / pi\n all_angles = np.append(all_angles, angle)\n cand_r = np.zeros((3,1))\n if angle < 15:\n cand_r = np.append(cand_r, [[r[0]], [r[1]], [r[2]]], axis=1)\n cand_r = np.delete(cand_r, 0, axis=1)\n cand_r = np.transpose(cand_r)\n\n for l in left:\n angle = np.arctan2(l[1], l[0]) * 180 / pi\n dot = 0\n if angle > -15:\n dl = max(0.001, np.linalg.norm(l))\n for r in cand_r:\n dr = max(0.001, np.linalg.norm(r))\n dot = np.dot(r, l) / (dr * dl)\n print(dot)\n if dot > 0.9:\n continue\n \n if dot <= 0.9:\n all_blobs = np.append(all_blobs, [[l[0]], [l[1]], [l[2]]], axis=1)\n all_angles = np.append(all_angles, angle)\n\n # make even number of blobs if necessary\n #if all_blobs.shape[1] % 2:\n # all_blobs = np.delete(all_blobs, 0, axis=1)\n # all_angles = np.delete(all_angles, 0)\n\n\n\n return (all_blobs, all_angles)","def _get_identical_ligand_indices(\n ligand: oechem.OEMolBase, smiles_iterable: Iterable[str]\n ) -> List[int]:\n from ..modeling.OEModeling import read_smiles, are_identical_molecules\n\n identical_ligand_indices = []\n for i, complex_ligand in enumerate(smiles_iterable):\n if are_identical_molecules(ligand, read_smiles(complex_ligand)):\n identical_ligand_indices.append(i)\n\n return identical_ligand_indices","def calculate_disparity_map(\n left_img: torch.Tensor,\n right_img: torch.Tensor,\n block_size: int,\n sim_measure_function: Callable,\n max_search_bound: int = 50,\n) -> torch.Tensor:\n\n assert left_img.shape == right_img.shape\n (H,W,C) = left_img.shape\n H_offset = block_size//2\n W_offset = block_size//2\n disp_map = torch.zeros(H-2*H_offset,W-2*W_offset) # placeholder, this is not the actual size\n\n\n ###########################################################################\n # Student code begins\n ###########################################################################\n\n for ii in range(H-2*H_offset):\n for jj in range(W-2*W_offset):\n left_patch = left_img[ii:ii+block_size,jj:jj+block_size, :]\n similarity_error_array = -1 * np.ones(max_search_bound)\n \n for kk in range(max_search_bound):\n jj_start = max(jj - kk, 0)\n jj_end = max(jj - kk + block_size, block_size)\n\n right_patch = right_img[ii:ii+block_size, jj_start:jj_end, :]\n similarity_error_array[kk] = sim_measure_function(left_patch, right_patch)\n\n disp_map[ii,jj] = np.argmin(similarity_error_array)\n\n ###########################################################################\n # Student code ends\n ###########################################################################\n return disp_map","def get_elim_candidates(df2, df1):\n if df1.loc[1,'Problem']!= problems[0]:\n return\n \n nodes_order_av, nodes_above = order_analysis(df2, df1, 'NewNodes')\n time_order_av, time_above = order_analysis(df2, df1, 'ElapsedSeconds')\n elim_candidates = set(nodes_above[:nodes_order_av]).intersection(set(time_above[:time_order_av]))\n # return their 1-base index also:\n out = [(SEARCHES.index(c)+1, c) for c in elim_candidates]\n return out","def nodes_with_m_nbrs(G, m):\n nodes = set()\n\n # Iterate over all nodes in G\n for n in G.nodes():\n\n # Check if the number of neighbors of n matches m\n if len(G.neighbors(n)) == m:\n\n # Add the node n to the set\n nodes.add(n)\n\n # Return the nodes with m neighbors\n return nodes","def find_not_in_icd_set(lenoforginalset, numbers_set):\r\n originalset = [str(i) for i in range(1, lenoforginalset+1, 1)]\r\n\r\n numbers_not_in_set = list(set(originalset)-set(numbers_set))\r\n numbers_not_in_set = sorted([int(num) for num in numbers_not_in_set])\r\n numbers_not_in_set = [str(num) for num in numbers_not_in_set]\r\n\r\n return numbers_not_in_set","def node_purity_mask(group_ids: nb.int64[:],\n primary_ids: nb.int64[:]) -> nb.boolean[:]:\n purity_mask = np.zeros(len(group_ids), dtype=np.bool_)\n for g in np.unique(group_ids):\n group_mask = group_ids == g\n if np.sum(group_mask) > 1 and np.sum(primary_ids[group_mask] == 1) == 1:\n purity_mask[group_mask] = np.ones(np.sum(group_mask))\n\n return purity_mask","def MatchMatrixs (self,Node1,Node2):\n\n T1Native_Node = Node1\n T1Native_Matrix = slicer.util.arrayFromVolume(T1Native_Node)\n DimN = T1Native_Matrix.shape\n T1Enhanced_Node = Node2\n T1Enhanced_Matrix = slicer.util.arrayFromVolume(T1Enhanced_Node)\n DimE = T1Enhanced_Matrix.shape\n\n NMatrix = self.GetIJKToRASnpArray(T1Native_Node)\n NVector = NMatrix[:-1,-1]\n EMatrix = self.GetIJKToRASnpArray(T1Enhanced_Node)\n EVector = EMatrix[:-1,-1]\n NPixelSize = [np.linalg.norm(NMatrix[:-1,0]), np.linalg.norm(NMatrix[:-1,1])]\n EPixelSize = [np.linalg.norm(EMatrix[:-1,0]), np.linalg.norm(EMatrix[:-1,1])]\n\n Niversor = NMatrix[:-1,0]/NPixelSize[0]\n Njversor = NMatrix[:-1,1]/NPixelSize[1]\n Nkversor = np.round(np.cross(Niversor,Njversor),3)\n Nkstep = round(np.linalg.norm(NMatrix[:-1,2]),3)\n\n Eiversor = EMatrix[:-1,0]/EPixelSize[0]\n Ejversor = EMatrix[:-1,1]/EPixelSize[1]\n Ekversor = np.round(np.cross(Eiversor,Ejversor),3)\n Ekstep = round(np.linalg.norm(EMatrix[:-1,2]),3)\n print(Nkversor,Ekversor,Nkstep,Ekstep,NVector,EVector,(NVector-EVector).dot(Ekversor))\n if not ( np.sum(Nkversor==Ekversor) == 3 and Nkstep==Ekstep and ((NVector-EVector).dot(Ekversor)) == 0 ): # it verifies if the slices are oriented in the same direction, with the same step between slices and if the first images are complanar.\n slicer.util.warningDisplay('The geometry of the LL Native and LL Enhanced volume doesn\\'t match. It could deteriorate the ECV map', windowTitle= 'Warning')\n\n if (DimE == DimN):\n T1_ECVMappingLogic.setupNodeFromNode(self,self.ECVMapNode , self.NativeT1_Selector.currentNode()) \n return [T1Native_Matrix,T1Enhanced_Matrix]\n if (DimE[1:3] == DimN[1:3]):\n k = min([DimE[1],DimN[1]])\n T1_ECVMappingLogic.setupNodeFromNode(self,self.ECVMapNode , self.NativeT1_Selector.currentNode())\n return [T1Native_Matrix[:k,:,:],T1Enhanced_Matrix[:k,:,:]]\n\n jN = np.arange(0,DimN[2]*NPixelSize[1],NPixelSize[1])+NPixelSize[1]/2+(NVector-EVector).dot(Njversor)\n iN = np.arange(0,DimN[1]*NPixelSize[0],NPixelSize[0])+NPixelSize[0]/2+(NVector-EVector).dot(Niversor)\n iE = np.arange(0,DimE[1]*EPixelSize[0],EPixelSize[0])+EPixelSize[0]/2\n jE = np.arange(0,DimE[2]*EPixelSize[1],EPixelSize[1])+EPixelSize[1]/2 \n if DimE[1] > DimN[1]: ## I concidered a square image\n T1Nreshaped = np.zeros(DimE)\n for k in range(DimN[0]):\n f = interpolate.interp2d(iN, jN, np.nan_to_num(T1Native_Matrix[k,:,:]), fill_value = 0)\n T1Nreshaped[k,:,:] = f(iE, jE)\n T1Ereshaped = T1Enhanced_Matrix[:k+1,:,:]\n T1_ECVMappingLogic.setupNodeFromNode(self,self.ECVMapNode , self.EnhancedT1_Selector.currentNode())\n return [T1Nreshaped,T1Ereshaped]\n else:\n T1Ereshaped = np.zeros(DimN)\n for k in range(DimE[0]):\n f = interpolate.interp2d(iE, jE, np.nan_to_num(T1Enhanced_Matrix[k,:,:]), fill_value = 0)\n T1Ereshaped[k,:,:] = f(iN, jN) \n T1Nreshaped = T1Native_Matrix[:k+1,:,:]\n T1_ECVMappingLogic.setupNodeFromNode(self,self.ECVMapNode , self.NativeT1_Selector.currentNode()) \n return [T1Nreshaped,T1Ereshaped]","def problem2(self, s):\n \n points = self.neighbor(100, 10, s.exhaustive_search)\n points += self.neighbor(10, 100, s.exhaustive_search)\n points += 1\n\n _testDriver.get_code(s.exhaustive_search)\n print \"\\n(Check that scipy.spatial.KDTree is not used)\"\n points *= self.grade(1)\n\n return points","def test_selection():\n pdb_inp = iotbx.pdb.input(source_info=None, lines=pdb_answer_0)\n ncs_obj_phil = ncs.input(\n hierarchy=pdb_inp.construct_hierarchy())\n nrg = ncs_obj_phil.get_ncs_restraints_group_list()\n\n m1 = list(nrg[0].master_iselection)\n c1 = list(nrg[0].copies[0].iselection)\n c2 = list(nrg[0].copies[1].iselection)\n\n assert len(m1) == len(c1) # renumbering\n assert m1 == [0, 1, 2, 3, 4, 5, 6] # 0, 1, X, 3, X, 5, X | 0, 1, 3\n assert c1 == [7, 8, 9, 10, 11, 12, 13] # 7, 8, 9, X, X, 12, X | 4, 5, 7\n assert c2 == [14, 15, 16, 17, 18, 19, 20] # 14, 15, X, 17, X, 19, X | 8, 9, 11\n\n selection1 = flex.size_t([0,1,5,3,100,101])\n selection2 = flex.size_t([0,1,5,3,7,8,9,12,100,101])\n selection3 = flex.size_t([0,1,5,3,7,8,9,12,14,15,19,17,100,101])\n # gone iseqs for selection3: 2,4,6,10,11,13,16,18,20-99\n\n new_nrg = nrg.select(flex.bool(102, selection1))\n # only atoms in master are selected\n mt = list(new_nrg[0].master_iselection)\n c1t = list(new_nrg[0].copies[0].iselection)\n\n assert mt == []\n assert c1t == []\n\n # atoms selected in both master and copies\n new_nrg = nrg.select(flex.bool(102, selection2))\n # only atoms in master are selected\n mt = list(new_nrg[0].master_iselection)\n c1t = list(new_nrg[0].copies[0].iselection)\n\n assert mt == []\n assert c1t == []\n\n new_nrg = nrg.select(flex.bool(102, selection3))\n # only atoms in master are selected\n mt = list(new_nrg[0].master_iselection)\n c1t = list(new_nrg[0].copies[0].iselection)\n c2t = list(new_nrg[0].copies[1].iselection)\n\n assert mt == [0, 1, 3], list(mt)\n assert c1t == [4, 5, 7], list(c1t)\n assert c2t == [8, 9, 11], list(c2t)","def compare_two_grids( treecode1, treecode2 ):\n import numpy as np\n\n common_blocks = 0\n\n for i in range(treecode1.shape[0]):\n # we look for this tree code in the second array\n code1 = treecode1[i,:]\n\n for j in range(treecode2.shape[0]):\n code2 = treecode2[j,:]\n if np.linalg.norm( code2-code1 ) < 1.0e-13:\n # found code1 in the second array\n common_blocks += 1\n break\n\n print( \"Nblocks1=%i NBlocks2=%i common blocks=%i\" % (treecode1.shape[0], treecode2.shape[0], common_blocks) )\n\n return common_blocks / treecode1.shape[0]","def match_twosided(desc1, desc2):\n\n matches_12 = match(desc1, desc2)\n matches_21 = match(desc2, desc1)\n\n ndx_12 = matches_12.non_zeros()[0]\n\n for n in ndx_12:\n if matches_21[int(matches_12[n])] != n:\n matches_12[n] = 0\n\n return matches_12","def hard_examples_mining(dist_mat, identity_mat, return_idxes=False):\n # the implementation here is a little tricky, dist_mat contains pairwise distance between probe image and other\n # images in current mini-batch. As we want to select positive examples of the same person, we add a constant\n # negative offset on other images before sorting. As a result, images of the **same** person will rank first.\n sorted_dist_mat, sorted_idxes = torch.sort(dist_mat + (-1e7) * (1 - identity_mat), dim=1,\n descending=True)\n dist_ap = sorted_dist_mat[:, 0]\n hard_positive_idxes = sorted_idxes[:, 0]\n\n # the implementation here is similar to above code, we add a constant positive offset on images of same person\n # before sorting. Besides, we sort in ascending order. As a result, images of **different** persons will rank first.\n sorted_dist_mat, sorted_idxes = torch.sort(dist_mat + 1e7 * identity_mat, dim=1,\n descending=False)\n dist_an = sorted_dist_mat[:, 0]\n hard_negative_idxes = sorted_idxes[:, 0]\n if return_idxes:\n return dist_ap, dist_an, hard_positive_idxes, hard_negative_idxes\n return dist_ap, dist_an","def maxima(self, nodeids: Optional[List[str]] = None) -> List[str]:\n\n if nodeids is None:\n nodeids = list(self.graph.nodes)\n\n return [nid for nid in nodeids\n if all(e[0] == nid\n for e in self.graph.edges\n if e[0] in nodeids\n if e[1] in nodeids\n if nid in e)]","def GetNodeCommonality(self):\n\n self.__do_essential_memebers_exist__()\n\n elements = self.elements.ravel()\n idx_sort = np.argsort(elements)\n sorted_elements = elements[idx_sort]\n vals, idx_start = np.unique(sorted_elements, return_index=True)\n\n # Sets of indices\n flat_pos = np.split(idx_sort, idx_start[1:])\n els = np.split(idx_sort // int(self.elements.shape[1]), idx_start[1:])\n pos = np.split(idx_sort % int(self.elements.shape[1]), idx_start[1:])\n\n # In case one wants to return only the duplicates i.e. filter keeping only items occurring more than once\n # vals, idx_start, count = np.unique(sorted_elements, return_counts=True, return_index=True)\n # vals = vals[count > 1]\n # res = filter(lambda x: x.size > 1, res)\n\n return els, pos, flat_pos","def mi_from_dm_alt(distance_matrix, ns, nh, spike_train_list=None):\n \n #print \"start loading\"\n \n nr = len(distance_matrix)\n nt = nr/ns\n nearest_neighbours = np.array([r.argsort()[:nh] for r in distance_matrix])\n near_to = [[j for j in range(nr) if i in nearest_neighbours[j] ] for i in range(nr)]\n \n #print \"finished sorting\"\n #return\n #nr = len(distance_matrix)\n #nearest_neighbours = np.array([[i] + distance_matrix[i].argsort()[1:nh].tolist() for i in range(nr)])\n \n members_of_glob = trains_in_glob(spike_train_list)\n glob_comp = glob_composition(spike_train_list, ns, nt, nh)\n \n counts = []\n counted_glob = False #set a flag for later use\n if spike_train_list is not None:\n for i in range(len(near_to)):\n c_i = 0\n \n if i not in members_of_glob:\n #print near_to[i]\n for j in near_to[i]:\n \n if j not in members_of_glob and spike_train_list[i].start_time == spike_train_list[j].start_time:\n c_i += 1\n else:\n if not counted_glob: #this should only really happen if glob has a small number of members...\n f_i = glob_comp[i]/float(sum(glob_comp.values()))\n g_i = f_i - 1.0/float(sum(glob_comp.values()))\n c_i += (nh - c_i)*g_i\n \n counted_glob = True\n else:\n pass\n \n else: #If i is in the glob...\n f_i = glob_comp[i]/float(sum(glob_comp.values()))\n g_i = f_i - 1.0/float(sum(glob_comp.values()))\n c_i = 1 + (nh - 1)*g_i\n \n counts.append(c_i) \n counts = np.array(counts) \n I = (1.0/nr)*sum( np.log2((ns*counts)/float(nh)) ) \n \n else:\n near_to_same_stim = [[n for n in near_to[j] if abs(n-j)%ns==0 ] for j in range(nr)]\n number_of_neighbourhoods = np.array([len(l) for l in near_to])\n number_of_neighbourhoods_same_stim = np.array([len(l) for l in near_to_same_stim])\n I = (1.0/nr)*sum( np.log2((ns*number_of_neighbourhoods_same_stim)/float(nh)) )\n \n return I","def find_nodes(shp):\n node_count = {}\n for road in shp:\n vrts = road.vertices\n for node in vrts:\n if node not in node_count:\n node_count[node] = 0\n node_count[node] += 1\n node_count[vrts[0]] += 1\n node_count[vrts[-1]] += 1\n return set([node for node,c in node_count.iteritems() if c > 1])","def calculate_disjoint_excess_count(\n smaller_genome_gene_ids: List[ObjectId],\n differing_gene_ids: List[ObjectId]\n ) -> Tuple[int, int]:\n\n smaller_genome_timestamps = [\n gene_id.generation_time\n for gene_id in smaller_genome_gene_ids\n ]\n\n if len(smaller_genome_timestamps) > 0:\n max_timestamp = smaller_genome_timestamps[0] # type: 'ObjectID'\n else:\n return 0, 0\n\n for timestamp in smaller_genome_timestamps:\n\n if timestamp > max_timestamp:\n max_timestamp = timestamp\n\n excess_genes = [\n gene_id\n for gene_id in differing_gene_ids\n if gene_id.generation_time > max_timestamp\n ]\n\n disjoint_genes = [\n gene_id\n for gene_id in differing_gene_ids\n if gene_id not in excess_genes\n ]\n\n return len(disjoint_genes), len(excess_genes)","def get_intersecting_dissemination_ids(cross_section, dissemination_areas):\n assert 'DAUID' in cross_section.columns \n dissem_arr = dissemination_areas.loc[dissemination_areas['DAUID'].isin(np.unique(cross_section['DAUID'].values))].DAUID.unique()\n reg_arr = dissemination_areas.loc[dissemination_areas['DAUID'].isin(np.unique(cross_section['DAUID'].values))].CSDUID.unique()\n# code_arr = dissemination_areas.loc[dissemination_areas['DAUID'].isin(np.unique(cross_section['DAUID'].values))].CODEID.unique()\n\n\n return list(dissem_arr), list(reg_arr)","def selectCompatibleIndices(bigTimes, smallTimes):\r\n indices = []\r\n for idx, _ in enumerate(smallTimes):\r\n distances = (bigTimes - smallTimes[idx])**2\r\n def getValue(k):\r\n return distances[k]\r\n thisIndices = sorted(range(len(distances)), key=getValue)\r\n indices.append(thisIndices[0])\r\n return np.array(indices)","def mass_based_dissimilarity(self, x1, x2):\n # In each i-tree, find lowest nodes containing both x and y\n # TODO: parallelize\n sum_masses = 0\n for itree in self.random_itrees:\n # Divide each sum by size of subset used to construct the trees.\n sum_masses += self.get_lowest_common_node_mass(itree, x1, x2)/self.subs_size\n return (1/len(self.random_itrees)) * sum_masses # Divide by number of space partitioning models.","def nn_match(descs1, descs2):\n # diff = descs1[:, None, :] - descs2[None, :, :]\n # diff = np.linalg.norm(diff, ord=2, axis=2)\n # indices = np.argmin(diff, axis=1)\n\n flann = cv2.FlannBasedMatcher_create()\n matches = flann.match(descs1.astype(np.float32), descs2.astype(np.float32))\n indices = [x.trainIdx for x in matches]\n\n return indices","def is_near_genome_reference(self, set_iids):\n\t\tassert isinstance(set_iids, set)\n\t\tif None in set_iids:\n\t\t\tset_iids.remove(None)\n\t\tif None in self._set_reference_genome_ncbi:\n\t\t\tself._set_reference_genome_ncbi.remove(None)\n\t\tset2 = self._set_reference_genome_ncbi\n\t\tfor iid in set_iids:\n\t\t\tset1 = set(self._iid_to_tid_lineage[iid])\n\t\t\tif not set1.isdisjoint(set2):\n\t\t\t\treturn True\n\t\treturn False","def shareNoEdges(segment,neighbours,segmentsMeta):\n return np.fromiter(map(lambda x : haveNoSameEdges(segment,x,segmentsMeta),neighbours),np.bool)","def nodes_row_similar(all_rows: set[tuple[str, str, str, int, int, int]],\n identifier: tuple[str, str, str, int, int, int]) -> bool:\n for row in all_rows:\n if row[0] == identifier[0] and row[1] == identifier[1]:\n return True\n return False","def match_gc_content(pos_one_hot, neg_one_hot, neg_pos_ratio=1):\n N, L, A = pos_one_hot.shape\n gc_pos = np.sum(np.sum(pos_one_hot[:,:,[1,2]], axis=2), axis=1)/L\n gc_neg = np.sum(np.sum(neg_one_hot[:,:,[1,2]], axis=2), axis=1)/L\n print(' Average GC content for positive sequences: %.3f'%(np.mean(gc_pos)))\n print(' Average GC content for negative sequences: %.3f'%(np.mean(gc_neg)))\n\n pos_index = np.argsort(gc_pos)\n neg_index = np.argsort(gc_neg)\n num_neg = len(neg_index)\n num_pos = len(pos_index)\n\n match_index = []\n if num_neg > num_pos:\n k = 0\n status = True\n for i in pos_index:\n for j in range(k, num_neg):\n if gc_pos[i] < gc_neg[neg_index[j]]:\n if k > num_neg:\n status = False\n break\n else:\n # print(\"%.2f vs %.2f\"%(gc_pos[i], gc_neg[neg_index[j]]))\n match_index.append(neg_index[j])\n k = j+1\n break\n if not status:\n break\n\n remainder = int(num_pos*neg_pos_ratio) - len(match_index)\n print(' Found %d GC-matched sequences.'%(len(match_index)))\n if remainder > 0:\n print(' Adding %d more random negative sequences.'%(remainder))\n remain_index = np.array(list(set(range(num_neg)) - set(match_index)))\n index = np.random.permutation(len(remain_index))[:remainder] \n # index = np.argsort(gc_neg[remain_index])[::-1]\n for n in remain_index[index[:remainder]]:\n match_index.append(n)\n \n match_index = np.array(match_index)\n print(' Average GC content for sub-sampled negative sequences: %.3f'%(np.mean(gc_neg[match_index])))\n\n return neg_one_hot[match_index], match_index","def getDistanceMatrix(self, alignedSequences):\n\t\tif not alignedSequences:\n\t\t\traise ValueError(\"alignedSequences must not be empty\")\n\t\tdominantAlignedSequence = alignedSequences[0]\n\t\tsubdominantAlignedSequences = alignedSequences[1:]\n\t\tdistanceMatrix = []\n\t\tfor seq in subdominantAlignedSequences:\n\t\t\tdistanceMatrix.append(len(seq) - self._getNumberOfSpaces(seq) - self._getNumberOfAlignedNucleotides(dominantAlignedSequence, seq))\n\t\treturn distanceMatrix","def get_excess_genes(self, other):\n innovs = {g.innov_num for g in other.link_genes}\n if not innovs:\n return []\n max_innov = max(innovs)\n return [g for g in self.link_genes\n if g.innov_num > max_innov and g.innov_num not in innovs]","def get_mismatches(rec):\n qseq = rec.get_forward_sequence().upper()\n if rec.is_reverse:\n qseq = reverseComplement(qseq)\n rseq = rec.get_reference_sequence().upper()\n for qpos, rpos in rec.get_aligned_pairs():\n if qpos == None or rpos == None:\n continue # no indels yet\n q = qseq[qpos]\n r = rseq[rpos - rec.reference_start]\n if q != r:\n position = (rec.reference_name, rpos)\n change = (r, q)\n yield (position, change)","def cng_dissimilarity(self, other):\n dissimilarity = 0.0\n for ngram in set(self) | set(other):\n dissimilarity += (2 * (self[ngram] - other[ngram]) /\n (self[ngram] + other[ngram])) ** 2\n return dissimilarity","def _notstaticneighs_get_corestored_by_inds_notslice(self, inds):\n inds = [inds] if type(inds) == int else inds\n idxs = []\n for k in range(len(self.idxs)):\n idxs.append([self.idxs[k][i] for i in inds])\n idxs = np.array(idxs) if type(self.idxs) == np.ndarray else idxs\n\n if self.sp_relative_pos is not None:\n sp_relative_pos = []\n for k in range(len(self.sp_relative_pos)):\n sp_relative_pos += [[self.sp_relative_pos[k][i] for i in inds]]\n else:\n sp_relative_pos = None\n return idxs, sp_relative_pos","def removeOrphanContents(self):\n reObjNum = re.compile('[0-9A-Z]{8}$')\n #--Determine which contIds are matched to a reference.\n contIds = set(self.conts_id.keys())\n matched = dict([(id,False) for id in contIds])\n for cell in self.cells:\n objects = cell.getObjects()\n for object in objects.list():\n objId= object[2]\n #--LVCR? Get id of spawned creature instead.\n for objRecord in object[3]:\n if objRecord.name == 'NAME':\n objId = cstrip(objRecord.data)\n break\n if reObjNum.search(objId):\n if objId in contIds:\n matched[objId] = True\n #--Special case: PlayerSaveGame\n matched['PlayerSaveGame00000000'] = True\n #--unmatched = container records that have not been matched.\n orphans = set([self.conts_id[id] for id in contIds if not matched[id]])\n for orphan in sorted(orphans, key=lambda a: a.getId().lower()):\n self.log(' '+orphan.getId())\n #--Delete Records\n self.records = [record for record in self.records if record not in orphans]\n self.conts = [record for record in self.conts if record not in orphans]\n self.conts_id = dict([(id,record) for id,record in self.conts_id.iteritems() if matched[id] > 0])\n return len(orphans)","def __get_ids_of_all_unrelaxed_candidates__(self):\n\n all_unrelaxed_ids = set([t.gaid for t in self.c.select(relaxed=0)])\n all_relaxed_ids = set([t.gaid for t in self.c.select(relaxed=1)])\n all_queued_ids = set([t.gaid for t in self.c.select(queued=1)])\n\n actually_unrelaxed = [gaid for gaid in all_unrelaxed_ids\n if (gaid not in all_relaxed_ids and\n gaid not in all_queued_ids)]\n\n return actually_unrelaxed","def find_irred(d, m):\n # Define l\n l = d + 1\n\n # Initialize list\n result = []\n # Fill list with random numbers between 0 and m\n for _ in range(l):\n result.append(random.randrange(0, m))\n\n # Make sure first number is not a 0 \n result[0] = random.randrange(1, m)\n\n # If result is not irreducible, create new list\n while is_irreducible(result, m) == 'FALSE':\n result = []\n for _ in range(l):\n result.append(random.randrange(0, m))\n result[0] = random.randrange(1, m)\n\n # Clear leading zeroes of the result\n return clear_leading_zeroes(result)","def greedy_match(cost_matrix):\n num_detections, num_tracks = cost_matrix.shape\n distance_1d = cost_matrix.reshape(-1)\n index_1d = np.argsort(distance_1d)\n index_2d = np.stack([index_1d // num_tracks, index_1d % num_tracks], axis=1).astype(int, copy=False)\n\n matched_indices = []\n matched_firsts = set()\n matched_seconds = set()\n\n for (first_id, second_id) in index_2d:\n if first_id not in matched_firsts and second_id not in matched_seconds:\n matched_seconds.add(second_id)\n matched_firsts.add(first_id)\n matched_indices.append([first_id, second_id])\n return np.array(matched_indices)","def match_twosided(desc1,desc2):\n matches_12 = match(desc1, desc2)\n matches_21 = match(desc2, desc1)\n ndx_12 = matches_12.nonzero()[0]\n # remove matches that are not symmetric\n for n in ndx_12:\n if matches_21[int(matches_12[n])] != n:\n matches_12[n] = 0\n return matches_12","def _find_neighbours(self):\n\n neighbours = []\n for i, p in enumerate(self.frame_0):\n nearests = np.where(np.linalg.norm(self.frame_0 - p, axis=1) <= self.R_n)[0]\n # delete self index\n index = np.argwhere(nearests==i)\n nearests = np.delete(nearests, index)\n neighbours.append(nearests)\n\n return neighbours","def match_align(self, match_only=True):\n\n print('Running match_align')\n\n # Note about alignment parameters: Used to have a small -0.1\n # penalty for gap creation & extension. Got rid of this in favor\n # of getting better alignments, but the downside is that for\n # cases where you want to know which residues are mutants of\n # each other, you don't get that info anymore.\n alignments = pairwise2.align.globalxs(self.target_sequence,\\\n self.mobile_sequence, 0, 0)\n\n #for alignment in alignments:\n if not alignments:\n return False\n print(alignments)\n best_rmsd = 9999\n i = 0\n for i in range(0, len(alignments)):\n bb_rmsd = self.align_sequences(alignments, i,\n match_only=match_only)\n if bb_rmsd < best_rmsd:\n best_rmsd = bb_rmsd\n best_i = i\n self.bb_rmsd = self.align_sequences(alignments, best_i,\n match_only=match_only)\n\n return True"],"string":"[\n \"def get_matching_nodeids(small_dmrs, large_dmrs, all_surface=False):\\n sorted_small_nodes = sort_nodes(small_dmrs.nodes)\\n sorted_large_nodes = sort_nodes(large_dmrs.nodes)\\n\\n longest_matches = find_longest_matches(sorted_small_nodes, sorted_large_nodes) # list (of lists) of tuples (id_from_sub, id)\\n\\n all_matched_nodeids = []\\n for match in longest_matches:\\n matched_large_orderids = list(zip(*match))[1] # [(order ids from small dmrs), (order ids from the\\n paired_nodeids = get_matched_nodeids_from_orderids(sorted_small_nodes, sorted_large_nodes, match)\\n if all_surface:\\n extra_overlap_nodeids = find_extra_surface_overlap(matched_large_nodeids, sorted_large_nodes)\\n paired_nodeids.extend([(None, nodeid) for nodeid in extra_overlap_nodeids])\\n all_matched_nodeids.append(paired_nodeids)\\n\\n return all_matched_nodeids\",\n \"def get_matched_nodeids_from_orderids(sorted_small_nodes, sorted_large_nodes, matched_orderids):\\n orderid2nodeid_func = lambda order_pair: (sorted_small_nodes[order_pair[0]].nodeid, sorted_large_nodes[order_pair[1]].nodeid)\\n return list(map(orderid2nodeid_func, matched_orderids))\",\n \"def needleMatching(self):\\r\\n # productive\\r\\n profprint()\\r\\n modelNodes = slicer.mrmlScene.GetNodesByClass('vtkMRMLModelNode')\\r\\n nbNode = modelNodes.GetNumberOfItems()\\r\\n result = []\\r\\n found = []\\r\\n # print nbNode\\r\\n for nthNode in range(nbNode):\\r\\n node = slicer.mrmlScene.GetNthNodeByClass(nthNode, 'vtkMRMLModelNode')\\r\\n if node.GetID() not in found and node.GetAttribute('type') != 'Validation':\\r\\n dist = []\\r\\n polydata = node.GetPolyData()\\r\\n if polydata != None:\\r\\n bounds = polydata.GetBounds()\\r\\n for nthNode2 in range(nbNode):\\r\\n node2 = slicer.mrmlScene.GetNthNodeByClass(nthNode2, 'vtkMRMLModelNode')\\r\\n if node2.GetID() not in found and node2.GetAttribute('type') == 'Validation':\\r\\n polydata2 = node2.GetPolyData()\\r\\n if polydata2 != None and polydata2.GetNumberOfPoints() > 100 and polydata.GetNumberOfPoints() > 100:\\r\\n tipDistance = self.distTip(int(node.GetID().strip('vtkMRMLModelNode')) , int(node2.GetID().strip('vtkMRMLModelNode')))\\r\\n baseDistance = self.distBase(int(node.GetID().strip('vtkMRMLModelNode')) , int(node2.GetID().strip('vtkMRMLModelNode')))\\r\\n name = node.GetName()\\r\\n manualName = name.lstrip('auto-seg_').lstrip('manual-seg_').lstrip('obturator-seg_').lstrip('0123456789').lstrip('-ID-vtkMRMLModelNode').lstrip('0123456789-')\\r\\n if manualName==node2.GetName(): dist.append([tipDistance, node2.GetID(), node2.GetName()])\\r\\n # print tipDistance\\r\\n if dist != []:\\r\\n match = [min(dist)[0], min(dist)[1], node.GetID(), min(dist)[2]]\\r\\n result.append(match)\\r\\n found.append(min(dist)[1])\\r\\n found.append(node.GetID())\\r\\n node.GetDisplayNode().SetSliceIntersectionVisibility(1)\\r\\n # print result\\r\\n return result\",\n \"def nearby():\\n for i in ids:\\n for j in ids:\\n if i != j:\\n if sum([1 for x,y in zip(i,j) if x!=y]) == 1:\\n print(\\\"\\\".join([x for x,y in zip(i,j) if x==y]))\\n return\",\n \"def get_allnids(self, rids=None):\\n if rids == None:\\n rids = sorted(self.r)\\n allnids = np.hstack([ list(self.r[rid].alln) for rid in rids ])\\n return np.unique(allnids)\\n else:\\n allnids = [ list(self.r[rid].alln) for rid in rids ]\\n return core.intersect1d(allnids, assume_unique=True)\",\n \"def find_edges_no_seed(rna_seq_objs, xgmml_obj, args, stats):\\n seq_pairs = []\\n # this makes the edges. looking at each pair of nodes\\n for i in range(0, len(rna_seq_objs)):\\n for j in range(i + 1, len(rna_seq_objs)):\\n pair = RNASequencePair(\\n rna_seq_objs[i], rna_seq_objs[j], xgmml_obj\\n )\\n pair.energy_delta = abs(\\n float(pair.sequence1.free_energy) - float(pair.sequence2.free_energy)\\n )\\n pair.edit_distance = Levenshtein.distance(\\n pair.sequence1.sequence, pair.sequence2.sequence\\n )\\n seq_pairs.append(pair)\\n # group things in batches of 10000 to find tree distances\\n if len(seq_pairs) > 10000:\\n process_seq_pairs(seq_pairs, args, stats)\\n # zero out the seq_pairs array and start refilling again\\n seq_pairs = []\\n # flush out the last of the tree distance seq_pairs\\n process_seq_pairs(seq_pairs, args, stats)\",\n \"def _match_identical_nodes(self):\\n\\n for job_name_b in self._topo_b_nodes:\\n for job_name_a in self._unresolved_a_nodes:\\n if self._is_node_identical(job_name_a, job_name_b):\\n self._identical_nodes[job_name_b] = job_name_a\\n self._unresolved_a_nodes.remove(job_name_a)\\n self._unresolved_b_nodes.remove(job_name_b)\\n break\",\n \"def __find_similar_pairs(self):\\n size = len(self.__indexclusters)\\n candidates = []\\n for i in range(size):\\n for j in range(i+1, size):\\n simi = self.__cluster_simi(i, j)\\n #print simi, self.__indexclusters[i],self.__indexclusters[j]\\n if simi >= self.__threshold:\\n candidates.append((simi, i, j))\\n candidates.sort(reverse = True, key = lambda x: x[0])\\n\\n\\n # filter overlapped pairs\\n to_remove = set()\\n appeared = set()\\n for index, cand in enumerate(candidates):\\n if cand[1] not in appeared and cand[2] not in appeared:\\n appeared.add(cand[1])\\n appeared.add(cand[2])\\n else:\\n to_remove.add(index)\\n\\n #print 'ahha'\\n #print [(cand[1], cand[2]) for index, cand in enumerate(candidates) if index not in to_remove]\\n\\n return [(cand[1], cand[2]) for index, cand in enumerate(candidates)\\n if index not in to_remove]\",\n \"def needleMatching(self):\\n #productive\\n profprint()\\n modelNodes=slicer.mrmlScene.GetNodesByClass('vtkMRMLModelNode')\\n nbNode=modelNodes.GetNumberOfItems()\\n result=[]\\n found=[]\\n #print nbNode\\n for nthNode in range(nbNode):\\n node=slicer.mrmlScene.GetNthNodeByClass(nthNode,'vtkMRMLModelNode')\\n if node.GetID() not in found and node.GetAttribute('type')!='Validation':\\n dist=[]\\n polydata = node.GetPolyData()\\n if polydata!=None:\\n bounds = polydata.GetBounds()\\n for nthNode2 in range(nbNode):\\n node2=slicer.mrmlScene.GetNthNodeByClass(nthNode2,'vtkMRMLModelNode')\\n if node2.GetID() not in found and node2.GetAttribute('type')=='Validation':\\n polydata2 = node2.GetPolyData()\\n if polydata2!=None and polydata2.GetNumberOfPoints()>100 and polydata.GetNumberOfPoints()>100:\\n\\n axialDistance=self.distTip( int(node.GetID().strip('vtkMRMLModelNode')) , int(node2.GetID().strip('vtkMRMLModelNode')))\\n \\n dist.append([axialDistance,node2.GetID()])\\n # print axialDistance\\n \\n if dist!=[]:\\n match=[min(dist)[0],min(dist)[1],node.GetID()]\\n result.append(match)\\n found.append(min(dist)[1])\\n found.append(node.GetID()) \\n node.GetDisplayNode().SetSliceIntersectionVisibility(1)\\n # print result\\n return result\",\n \"def get_match_ids_not_in_db(match_ids):\\n q = select([Match.match_id])\\n with engine.connect() as conn:\\n result = conn.execute(q).fetchall()\\n result = set([match_id[0] for match_id in result])\\n\\n return match_ids - result\",\n \"def minima(self, nodeids: Optional[List[str]] = None) -> List[str]:\\n\\n if nodeids is None:\\n nodeids = list(self.graph.nodes)\\n\\n return [nid for nid in nodeids\\n if all(e[0] != nid\\n for e in self.graph.edges\\n if e[0] in nodeids\\n if e[1] in nodeids\\n if nid in e)]\",\n \"def test_no_match(self):\\n\\n conn, cursor = get_db_cursor()\\n build = \\\"toy_build\\\"\\n database = \\\"scratch/toy.db\\\"\\n run_info = talon.init_run_info(database, build)\\n talon.get_counters(database)\\n\\n edge_dict = init_refs.make_edge_dict(cursor)\\n location_dict = init_refs.make_location_dict(build, cursor)\\n transcript_dict = init_refs.make_transcript_dict(cursor, build)\\n gene_starts = init_refs.make_gene_start_or_end_dict(cursor, build, \\\"start\\\")\\n gene_ends = init_refs.make_gene_start_or_end_dict(cursor, build, \\\"end\\\")\\n\\n chrom = \\\"chr1\\\"\\n strand = \\\"+\\\"\\n positions = [ 1, 100, 900, 1000 ]\\n edge_IDs = [200]\\n vertex_IDs = [2, 5]\\n v_novelty = [0, 0]\\n\\n all_matches = talon.search_for_ISM(edge_IDs, transcript_dict)\\n assert all_matches == None\\n conn.close()\",\n \"def find_near_nodes(self, new_node):\\n number_nodes = len(self.node_list) + 1\\n r = self.connect_circle_dist * math.sqrt(\\n (math.log(number_nodes) / number_nodes)\\n )\\n\\n # if expand_dist exists, search vertices in a range no more than expand_dist\\n if hasattr(self, \\\"expand_dis\\\"):\\n r = min(r, self.expand_dis)\\n dist_list = [\\n (node.x - new_node.x) ** 2 + (node.y - new_node.y) ** 2\\n for node in self.node_list\\n ]\\n near_indexes = [dist_list.index(i) for i in dist_list if i <= r ** 2]\\n return near_indexes\",\n \"def _find_unpaired_regions(self, graph, adjacency):\\n graph_c = graph.copy()\\n unpaired_nodes_list = []\\n self._pair_based_graph_cut(graph_c)\\n for component in nx.connected_components(graph_c):\\n if len(component) >= adjacency:\\n unpaired_nodes_list = unpaired_nodes_list + component\\n return unpaired_nodes_list\",\n \"def simple_de_matching(adata, markers, n_genes=100):\\n gene_groups = adata.uns['rank_genes_groups']\\n de_genes = pd.DataFrame(data=gene_groups['names']).head(n_genes)\\n #print(de_genes.head(10))\\n\\n matches = check_markers(de_genes, markers)\\n for key, value in matches.items():\\n print(f'-- cluster {key} --')\\n print(value)\\n\\n return de_genes\",\n \"def get_disjoint_genes(self, other):\\n innovs = {g.innov_num for g in other.link_genes}\\n if not innovs:\\n return []\\n max_innov = max(innovs)\\n return [g for g in other.link_genes\\n if g.innov_num < max_innov and g.innov_num not in innovs]\",\n \"def remove_xmatch_multiples(index_primary, index_secondary, d2d, d3d, retain_best_match=True,\\n verbose=False):\\n n_entries = len(index_primary)\\n n_unique_entries = len(np.unique(index_primary))\\n if verbose:\\n print('xmatch: cleanMultipleCrossMatches: there are {0:d} unique entries in the primary '\\n 'catalog'.format(n_unique_entries))\\n\\n if n_entries != n_unique_entries:\\n # get array of unique indices (here like identifier) and the corresponding occurrence count\\n unique_array, return_counts = np.unique(index_primary, return_counts=True)\\n\\n # indices in unique array of stars with multiple crossmatches\\n index_in_unique_array = np.where(return_counts > 1)[0]\\n number_of_stars_with_multiplematches = len(index_in_unique_array)\\n if verbose:\\n if retain_best_match:\\n print('xmatch: result contains {} multiple matches affecting {} entries, '\\n 'keeping closest match'.format(number_of_stars_with_multiplematches,\\n n_entries - n_unique_entries))\\n else:\\n print('xmatch: result contains {} multiple matches affecting {} entries, removing '\\n 'them all'.format(number_of_stars_with_multiplematches,\\n n_entries - n_unique_entries))\\n\\n # identifiers (i.e. numbers in index_primary) of stars with multiple crossmatches\\n multi_matches = unique_array[index_in_unique_array]\\n\\n # index in index_primary where multiple matches occur\\n index_multiple_match = np.where(np.in1d(index_primary, multi_matches))[0]\\n if verbose:\\n print(d2d[index_multiple_match], index_primary[index_multiple_match], index_secondary[index_multiple_match])\\n\\n good_index_in_index_primary = np.zeros(number_of_stars_with_multiplematches)\\n for ii, jj in enumerate(multi_matches):\\n tmp_idx0 = np.where(index_primary[index_multiple_match] == jj)[0]\\n tmp_idx1 = np.argmin(d2d[index_multiple_match][tmp_idx0])\\n good_index_in_index_primary[ii] = index_primary[index_multiple_match][tmp_idx0[tmp_idx1]]\\n\\n if retain_best_match:\\n index_to_remove = np.setdiff1d(index_multiple_match, good_index_in_index_primary)\\n else:\\n index_to_remove = index_multiple_match\\n\\n mask = np.ones(len(index_primary), dtype=bool)\\n mask[index_to_remove] = False\\n index_primary = index_primary[mask]\\n index_secondary = index_secondary[mask]\\n d2d = d2d[mask]\\n d3d = d3d[mask]\\n if len(index_primary) != len(np.unique(index_primary)):\\n print('xmatch: Multiple match cleanup procedure failed')\\n # get array of unique indices (here like identifier) and the corresponding occurrence count\\n unique_array, return_counts = np.unique(index_primary, return_counts=True)\\n\\n # indices in unique array of stars with multiple crossmatches\\n index_in_unique_array = np.where(return_counts > 1)[0]\\n number_of_stars_with_multiplematches = len(index_in_unique_array)\\n print('xmatch: result still contains {} multiple matches'.format(\\n number_of_stars_with_multiplematches))\\n\\n return index_primary, index_secondary, d2d, d3d\",\n \"def splitNodes(matching):\\n outer = set(range(self.n))\\n inner = set([])\\n for (u, v) in matching:\\n if u in outer:\\n outer.remove(u)\\n if v in outer:\\n outer.remove(v)\\n inner.add(u)\\n inner.add(v)\\n return list(inner), list(outer)\",\n \"def find_longest_matches(sorted_nodes1, sorted_nodes2):\\n root = TreeNode(-1,-1)\\n fill_tree(root, sorted_nodes1, sorted_nodes2)\\n match = find_treepaths(root, [])\\n\\n # Remove (-1, -1) superroot.\\n if isinstance(match[0], list): # More than one match of the same length.\\n res = []\\n for m in match:\\n res.append([node.to_tuple() for node in m[1:]])\\n return res\\n else:\\n return [[node.to_tuple() for node in match[1:]]]\",\n \"def find_nonexceed(trainy, train_tree_node_ID, pred_tree_node_ID, thres):\\n \\n npred = pred_tree_node_ID.shape[0]\\n out = np.zeros((npred, thres.shape[0]))*np.nan\\n for i in prange(pred_tree_node_ID.shape[0]):\\n for j in prange(thres.shape[0]):\\n idxs = np.where(train_tree_node_ID == pred_tree_node_ID[i, :])[0]\\n sample = trainy[idxs]\\n out[i, j] = (sample < thres[j]).sum() / float(sample.shape[0])\\n return out\",\n \"def neighbours_R(self):\\n seen = set()\\n return [l.other(self) for l in self.dovetails_R \\\\\\n if id(l) not in seen and not seen.add(id(l))]\",\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 compare_nodes(G,all_match_pairs,match_pair,traversed,node1,node2, ports_weight):\\n logger.debug(f\\\"comparing {node1},{node2}, traversed {traversed}\\\")\\n nbrs1 = sorted(set(G.neighbors(node1)) - set(traversed))\\n #remove dummies\\n nbrs1 = sorted(set([nbr for nbr in nbrs1 if G.get_edge_data(node1, nbr)['weight'] !=7]))\\n nbrs2 = sorted(set(G.neighbors(node2)) - set(traversed))\\n #remove dummies\\n nbrs2 = sorted(set([nbr for nbr in nbrs2 if G.get_edge_data(node2, nbr)['weight'] !=7]))\\n logger.debug(f\\\"node1:{node1},property: {G.nodes[node1]},neigbors1: {nbrs1}\\\")\\n logger.debug(f\\\"node2:{node2},property: {G.nodes[node2]},neigbors2: {nbrs2}\\\")\\n if not nbrs1 or not nbrs2:\\n if compare_two_nodes(G, node1, node2, ports_weight):\\n match_pair[node1] = node2\\n logger.debug(f\\\"no new neihbours, returning recursion {match_pair}\\\")\\n return\\n elif len(nbrs1)> 10:\\n if \\\"start_point\\\" in match_pair.keys():\\n match_pair[\\\"start_point\\\"]+=[node1,node2]\\n else:\\n match_pair[\\\"start_point\\\"]=[node1,node2]\\n logger.debug(f\\\"skipping high fanout nets due to large computation, {node1} {nbrs1}\\\")\\n traversed.append(node1)\\n return\\n elif len(nbrs2)> 10:\\n if \\\"start_point\\\" in match_pair.keys():\\n match_pair[\\\"start_point\\\"]+=[node1,node2]\\n else:\\n match_pair[\\\"start_point\\\"]=[node1,node2]\\n traversed.append(node2)\\n logger.debug(f\\\"skipping high fanout nets due to large computation, {node2} {nbrs2}\\\")\\n return\\n\\n if node1 == node2:\\n if node1 in match_pair.keys() or node1 in match_pair.values():\\n logger.debug(\\\"avoid existing pair wise symmetry\\\")\\n return\\n logger.debug(f\\\"single node {node1}, nbrs {nbrs1}, nbr_weight {[G.get_edge_data(node1,nbr) for nbr in nbrs1]}\\\")\\n SD_nbrs= [nbr for nbr in nbrs1 if G.get_edge_data(node1, nbr)['weight'] !=2]\\n ## TBD: filter based on primitive constraints\\n ## Right now will try to figure out S/D paths\\n if len(SD_nbrs) ==0:\\n logger.debug(f\\\"No SD paths found to traverse\\\")\\n match_pair[node1]=node1\\n elif len(SD_nbrs) ==1:\\n logger.debug(f\\\"traversing single S/D path {SD_nbrs}\\\")\\n match_pair[node1]=node1\\n traversed.append(node1)\\n compare_nodes(G,all_match_pairs,match_pair,traversed,SD_nbrs[0],SD_nbrs[0],ports_weight)\\n else:\\n logger.debug(f\\\" multiple nodes diverging {SD_nbrs}\\\")\\n logger.debug(f\\\"nbr weights: {SD_nbrs} {[G.get_edge_data(node1, nbr)['weight'] for nbr in SD_nbrs ]}\\\")\\n match_pair[node1]=node1\\n traversed.append(node1)\\n new_sp=sorted(set(SD_nbrs)-set(traversed))\\n all_match_pairs_local={}\\n for nbr1,nbr2 in combinations(new_sp, 2):\\n logger.debug(f\\\"recursive pair call from single branch {nbr1} {nbr2}\\\")\\n new_pair={}\\n compare_nodes(G,all_match_pairs,new_pair,traversed.copy(),nbr1,nbr2,ports_weight)\\n if new_pair:\\n #new_pair[nbr1]=nbr2\\n all_match_pairs_local[nbr1+'_'+nbr2] = new_pair\\n all_match_pairs_local={k: v for k, v in all_match_pairs_local.items() if len(v)>0}\\n if len(all_match_pairs_local)==1:\\n match_pair.update( all_match_pairs_local[list(all_match_pairs_local.keys())[0]])\\n logger.debug(f\\\"found inline pair: {pprint.pformat(match_pair, indent=4)}\\\")\\n else:\\n for nbr1 in new_sp:\\n if (nbr1+'_'+nbr1 not in all_match_pairs.keys()):\\n logger.debug(f\\\"recursive single branch call from single branch {nbr1} {nbr1}\\\")\\n new_pair={}\\n compare_nodes(G,all_match_pairs,new_pair,traversed.copy(),nbr1,nbr1,ports_weight)\\n #filtering multiple axis of symmetries with same block, ideally they should be handled by array generation\\n if new_pair:\\n all_match_pairs[nbr1+'_'+nbr1] = new_pair\\n logger.debug(f\\\"updating match pairs: {pprint.pformat(all_match_pairs, indent=4)}\\\")\\n\\n\\n elif nbrs1 == nbrs2:\\n logger.debug(f\\\"traversing converging branch\\\")\\n match_pair[node1]=node2\\n traversed+=[node1,node2]\\n nbrs1=sorted(set(nbrs1)-set([node1,node2]))\\n logger.debug(f\\\"all non traversed neighbours: {nbrs1}\\\")\\n if len(nbrs1)==1:\\n nbr1=nbr2=nbrs1[0]\\n logger.debug(f\\\"keeping single converged branch inline {nbr1} {nbr2}\\\")\\n compare_nodes(G,all_match_pairs,match_pair,traversed.copy(),nbr1,nbr2,ports_weight)\\n else:\\n for nbr1,nbr2 in combinations_with_replacement(nbrs1,2):\\n logger.debug(f\\\"recursive call from converged branch {nbr1} {nbr2}\\\")\\n if nbr1+'_'+nbr2 not in all_match_pairs.keys():\\n new_pair={}\\n compare_nodes(G,all_match_pairs,new_pair,traversed.copy(),nbr1,nbr2,ports_weight)\\n #filtering multiple axis of symmetries with same block, ideally they should be handled by array generation\\n if new_pair:\\n all_match_pairs[nbr1+'_'+nbr2] = new_pair\\n logger.debug(f\\\"updating match pairs: {pprint.pformat(all_match_pairs, indent=4)}\\\")\\n\\n\\n elif compare_two_nodes(G,node1,node2,ports_weight):\\n nbrs1 = sorted(set([nbr for nbr in nbrs1 if G.get_edge_data(node1, nbr)['weight'] !=2]))\\n nbrs2 = sorted(set([nbr for nbr in nbrs2 if G.get_edge_data(node2, nbr)['weight'] !=2]))\\n match_pair[node1]=node2\\n traversed+=[node1,node2]\\n logger.debug(f\\\"Traversing parallel branches from {node1},{node2} {nbrs1}, {nbrs2}\\\")\\n nbrs1_wt = [G.get_edge_data(node1, nbr)['weight'] for nbr in nbrs1]\\n nbrs2_wt = [G.get_edge_data(node2, nbr)['weight'] for nbr in nbrs2]\\n unique_match=find_unique_matching_branches(G,nbrs1,nbrs2,ports_weight)\\n if len(nbrs1)==0 or len(nbrs2)==0:\\n logger.debug(f\\\"no new SD neihbours, returning recursion {match_pair}\\\")\\n elif len(nbrs1) ==1 and len(nbrs2)==1:\\n logger.debug(f\\\"traversing binary branch\\\")\\n compare_nodes(G,all_match_pairs,match_pair,traversed,nbrs1.pop(),nbrs2.pop(),ports_weight)\\n elif unique_match:\\n logger.debug(f'traversing unique matches {unique_match}')\\n match_pair[node1]=node2\\n traversed+=[node1,node2]\\n for nbr1,nbr2 in unique_match.items():\\n logger.debug(f\\\"recursive call from binary {node1}:{node2} to {nbr1}:{nbr2}\\\")\\n compare_nodes(G,all_match_pairs,match_pair,traversed.copy(),nbr1,nbr2,ports_weight)\\n elif len(nbrs1_wt)>len(set(nbrs1_wt))>1 and len(nbrs2_wt)>len(set(nbrs2_wt))>1:\\n logger.debug(f\\\"setting new start points {node1} {node2}\\\")\\n match_pair[node1]=node2\\n if \\\"start_point\\\" in match_pair.keys():\\n match_pair[\\\"start_point\\\"]+=[node1,node2]\\n else:\\n match_pair[\\\"start_point\\\"]=[node1,node2]\\n else:\\n match_pair = {}\\n logger.debug(f\\\"end all traversal from binary branch {node1} {node2}\\\")\\n\\n else:\\n match_pair = {}\\n logger.debug(f\\\"end of recursion branch, matches {match_pair}\\\")\",\n \"def eliminiateEmptyEdges(self, distance = 100):\\n print \\\"Edge elimination started\\\"\\n \\n selected_edge_ids = []\\n # let us \\n \\n for point in self.gps_points:\\n results = self.idx.nearest(((point.getPoint().x-distance/2), \\n (point.getPoint().y-distance/2),\\n (point.getPoint().x+distance/2),\\n (point.getPoint().y+distance/2)), objects=True)\\n for result in results:\\n from_node = self.node_counter__node.get(result.object.from_node.getAttributes().get(\\\"nodecounter\\\"))\\n to_node = self.node_counter__node.get(result.object.to_node.getAttributes().get(\\\"nodecounter\\\"))\\n edge_counter = self.G.edge[from_node][to_node].get(\\\"edgecounter\\\")\\n if edge_counter not in selected_edge_ids:\\n selected_edge_ids.append(edge_counter)\\n print str(len(selected_edge_ids)) + \\\" edges found to keep.\\\"\\n \\n elimination_counter = 0\\n for edge in self.G.edges():\\n edgecounter = self.G.edge[edge[0]][edge[1]].get(\\\"edgecounter\\\")\\n if edgecounter not in selected_edge_ids:\\n edge_tuple = (self.G.edge[edge[0]][edge[1]].get(\\\"edge\\\").from_node, self.G.edge[edge[0]][edge[1]].get(\\\"edge\\\").to_node)\\n self.G.remove_edge(*edge_tuple)\\n elimination_counter = elimination_counter + 1\\n \\n print str(elimination_counter) + \\\" edges eliminated.\\\"\",\n \"def find_similar_hashes(self):\\n matches = self.hasher.find_matches(self.__offset_hash_map.values())\\n print(\\\" Found {} matches.\\\".format(len(matches)))\\n\\n print(\\\" Formatting the found matches. This takes some time ...\\\")\\n self.__matched_offsets = self.__to_offset_list(matches, self.__offset_hash_map)\\n\\n return\",\n \"def map_graph_id(self):\\n for graph_id in self.NX_GRAPHS:\\n graph = self.NX_GRAPHS[graph_id]\\n flag = 0\\n try:\\n for node_idx in range(len(graph.nodes)):\\n if np.sum(\\n np.array(graph.nodes[node_idx]['h']) == \\n np.array(self.dgl_graph.nodes[node_idx].data['h'][0])) != 128:\\n flag = -1\\n break\\n if flag == -1:\\n continue\\n else:\\n self.graph_id = graph_id\\n break\\n except:\\n pass\",\n \"def get_matching_genes(self, other):\\n innovs = {g.innov_num for g in other.link_genes}\\n if not innovs:\\n return []\\n max_innov = max(innovs)\\n return [g for g in self.link_genes\\n if g.innov_num in innovs]\",\n \"def get_nids(self, rids=None):\\n if rids == None: # return all nids in all recordings\\n rids = list(self.r)\\n return np.unique(np.hstack([ list(self.r[rid].n) for rid in rids ]))\\n else: # return intersection of nids of specified recordings\\n nids = [ list(self.r[rid].n) for rid in rids ]\\n return core.intersect1d(nids, assume_unique=True)\",\n \"def identifyMindist(align, ignoreGaps=True):\\n align = padAlignment(align)\\n cons = consensus(align, ignoreGaps)\\n dist = align.map(partial(hamming_distance, cons))\\n return align[dist.argmin()]\",\n \"def find_edges_seed(rna_seq_objs, xgmml_obj, args, stats):\\n nodes_copy = rna_seq_objs\\n while len(nodes_copy) > 2:\\n nodes_copy[0].use_for_comparison = False\\n seq_pairs = []\\n # go through and find all the matches\\n # then remove matches and start again till gone\\n for x in range(1, len(nodes_copy) - 1):\\n # new nodes_copy[0] each time a node is deleted\\n pair = RNASequencePair(\\n nodes_copy[0], nodes_copy[x], xgmml_obj\\n )\\n pair.energy_delta = abs(\\n pair.sequence1.free_energy - pair.sequence2.free_energy\\n )\\n pair.edit_distance = Levenshtein.distance(\\n pair.sequence1.sequence, pair.sequence2.sequence\\n )\\n seq_pairs.append(pair)\\n process_seq_pairs(seq_pairs, args, stats)\\n for x in seq_pairs:\\n if x.is_valid_edge:\\n x.sequence2.use_for_comparison = False\\n # delete nodes which already belong to an edge\\n new_nodes_copy = [\\n z for z in nodes_copy if z.use_for_comparison\\n ]\\n print 'Number of RNA sequences reduced from %d to %d ' % (\\n len(nodes_copy), len(new_nodes_copy)\\n )\\n nodes_copy = new_nodes_copy\",\n \"def _reduce_distances(self, threshold):\\n reduced = self.orig_dists.copy()\\n reduced[reduced <= threshold] = 0\\n # Remove ignored from all consideration\\n ignrd_indices = [self.index[name] for name in self.ignored]\\n if ignrd_indices:\\n reduced[:,ignrd_indices] = np.inf\\n reduced[ignrd_indices,:] = np.inf\\n # Check if the given parameters are feasible\\n chsn_indices = set(self.index[name] for name in self.chosen)\\n avail_indices = set(self.index[name] for name in self.available)\\n ca_indices = chsn_indices | avail_indices\\n unassigned_indices = np.array(list(self._not_ignored_inds - ca_indices))\\n if len(unassigned_indices) == 0:\\n unassigned_orphans = unassigned_indices\\n else:\\n ca_indices = list(ca_indices)\\n avail_in_range = np.count_nonzero(reduced[np.ix_(unassigned_indices,ca_indices)] == 0, axis=1)\\n unassigned_orphans = unassigned_indices[avail_in_range == 0]\\n return reduced, unassigned_orphans\",\n \"def _partition_nearest(self, medoids, dists, only_these=set()):\\n if len(only_these) == 0:\\n allowed_inds = self._not_ignored_inds\\n else:\\n allowed_inds = self._not_ignored_inds & only_these\\n closest_medoid_ind = np.argmin(dists[:,medoids], 1) # If len(medoids)==3, would look like [2,1,1,0,1,2,...].\\n clusts = [[] for i in medoids]\\n for node_ind, med_ind in enumerate(closest_medoid_ind):\\n if node_ind in allowed_inds:\\n clusts[med_ind].append(node_ind)\\n return clusts\",\n \"def get_identical_nodes(self):\\n\\n return self._identical_nodes\",\n \"def prune(self, alignment_infos):\\n alignments = []\\n best_score = 0\\n\\n for alignment_info in alignment_infos:\\n score = IBMModel4.model4_prob_t_a_given_s(alignment_info, self)\\n best_score = max(score, best_score)\\n alignments.append((alignment_info, score))\\n\\n threshold = IBMModel5.MIN_SCORE_FACTOR * best_score\\n alignments = [a[0] for a in alignments if a[1] > threshold]\\n return set(alignments)\",\n \"def common_ids(descendent_ids, ancestor_ids, threshold=0.5):\\n\\n common = np.intersect1d(descendent_ids, ancestor_ids)\\n return common.size > threshold * ancestor_ids.size\",\n \"def find_nearby_membranes(all_membranes, all_membrane_map, vert_normals):\\r\\n membrane_tree = scipy.spatial.cKDTree(all_membranes)\\r\\n nearby_membranes = np.array(list(membrane_tree.query_pairs(adhesion_max_dist, p=2)))\\r\\n nearby_membrane_map = defaultdict(list)\\r\\n if nearby_membranes.shape[0] > 0:\\r\\n # Exclude same-cell membrane interactions and same-direction-facing segments\\r\\n all_vert_normals = np.concatenate(vert_normals, axis=0)\\r\\n subset = np.where(\\r\\n (all_membrane_map[nearby_membranes[:, 0], 0] !=\\r\\n all_membrane_map[nearby_membranes[:, 1], 0])\\r\\n & (np.einsum('ij,ik->i', all_vert_normals[nearby_membranes[:, 0]], all_vert_normals[nearby_membranes[:, 1]]) < 0.0)\\r\\n )\\r\\n nearby_membranes = nearby_membranes[subset]\\r\\n # {cell idx: (vert idx, other cell idx, other vert idx, 'all_membranes' vert idx)}\\r\\n for nm in nearby_membranes:\\r\\n m0 = all_membrane_map[nm[0]]\\r\\n m1 = all_membrane_map[nm[1]]\\r\\n nearby_membrane_map[m0[0]].append((m0[1], m1[0], m1[1], nm[1]))\\r\\n nearby_membrane_map[m1[0]].append((m1[1], m0[0], m0[1], nm[0]))\\r\\n nearby_membrane_map = {k: np.array(v)\\r\\n for k, v in nearby_membrane_map.items()}\\r\\n# print(nearby_membrane_map)\\r\\n return nearby_membranes, nearby_membrane_map\",\n \"def no_match():\\n S1=Spectrum.Spectrum()\\n S1.add_peak(50.7,234)\\n S1.add_peak(54.6,585)\\n S1.add_peak(60.7,773)\\n S1.add_peak(65.6,387)\\n S1.add_peak(87.7,546)\\n S1.add_peak(104.6,598)\\n S1.pep_mass=100\\n S1.euclidean_scale()\\n\\n S2=Spectrum.Spectrum()\\n S2.add_peak(50.2,234)\\n S2.add_peak(53.8,585)\\n S2.add_peak(61.3,773)\\n S2.add_peak(66.2,387)\\n S2.add_peak(88.1,546)\\n S2.add_peak(103.9,598)\\n S2.pep_mass=100\\n S2.euclidean_scale()\\n\\n score,peaks=similarity.cosine_score_max(S1,S2)\\n assert peaks==0, \\\"Incorrect number of peaks matched with greedy method\\\"\\n assert score==0, \\\"Incorrect score with greedy method\\\"\\n \\n\\n score,peaks=similarity.cosine_score_greedy(S1,S2)\\n assert peaks==0, \\\"Incorrect number of peaks matched with maximum weighted method\\\"\\n assert score==0, \\\"Incorrect score with maximum weighted method\\\"\",\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 test_no_extra_ids():\\n\\tNLNP_pairs = set()\\n\\tall_ids = set()\\n\\tfor cat in nset['categories']:\\n\\t\\tall_ids.add(cat['id'])\\n\\t\\n\\tfor search_row in map_rows:\\n\\t\\tNL, NP = search_row[2], search_row[3]\\n\\t\\tif not NL == 'NA':\\n\\t\\t\\tNLNP_pairs.add((NL, NP))\\n\\n\\tassert len(all_ids) == len(nset['categories'])\\n\\tassert len(NLNP_pairs) == len(all_ids)\",\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 find_mutual_nn(self):\\n best_match_src = self.scores.argmax(1) # Best match for each source word\\n best_match_trg = self.scores.argmax(0) # Best match for each source word\\n\\n # ONELIENER\\n # paired_idx = [(i,best_match_src[i]) for i in range(self.ns) if best_match_trg[best_match_src[i]] == i]\\n # paired_words = [(self.src_words[i],self.trg_words[j]) for (i,j) in paired_idx]\\n paired = []\\n for i in range(self.ns):\\n m = best_match_src[i]\\n if best_match_trg[m] == i:\\n paired.append((i,m))\\n\\n paired_toks = []\\n if self.src_words and self.trg_words:\\n paired_toks = [(self.src_words[i],self.trg_words[j]) for (i,j) in paired]\\n else:\\n paired_toks = paired\\n return paired_toks\",\n \"def nms_match(dets: array_like_type,\\n iou_threshold: float) -> List[array_like_type]:\\n if dets.shape[0] == 0:\\n matched = []\\n else:\\n assert dets.shape[-1] == 5, 'inputs dets.shape should be (N, 5), ' \\\\\\n f'but get {dets.shape}'\\n if isinstance(dets, Tensor):\\n dets_t = dets.detach().cpu()\\n else:\\n dets_t = torch.from_numpy(dets)\\n indata_list = [dets_t]\\n indata_dict = {'iou_threshold': float(iou_threshold)}\\n matched = ext_module.nms_match(*indata_list, **indata_dict)\\n if torch.__version__ == 'parrots':\\n matched = matched.tolist() # type: ignore\\n\\n if isinstance(dets, Tensor):\\n return [dets.new_tensor(m, dtype=torch.long) for m in matched]\\n else:\\n return [np.array(m, dtype=int) for m in matched]\",\n \"def _reduce_search_space(self, neighbors_reduction_thr=18):\\n centroid_matrix = bundles_distances_mdf(self.model_centroids,\\n self.centroids)\\n centroid_matrix[centroid_matrix >\\n neighbors_reduction_thr] = np.inf\\n\\n mins = np.min(centroid_matrix, axis=0)\\n close_clusters_indices = np.array(np.where(mins != np.inf)[0],\\n dtype=np.int32)\\n\\n self.neighb_indices = []\\n for i in close_clusters_indices:\\n self.neighb_indices.extend(self.wb_clusters_indices[i])\\n self.neighb_indices = np.array(self.neighb_indices, dtype=np.int32)\\n self.neighb_streamlines = _reconstruct_streamlines(self.memmap_filenames,\\n self.neighb_indices)\\n\\n self.neighb_centroids = [self.centroids[i]\\n for i in close_clusters_indices]\\n\\n return len(close_clusters_indices) > 0\",\n \"def find_specific_primer_matches(primers,\\n integer_mapped_seq,\\n deletion_threshold,\\n seq_count,\\n sequence_length,\\n label,\\n unaligned_seq,\\n region_slice,\\n seq):\\n \\n primer_len=sequence_length\\n overall_length=region_slice+primer_len\\n bad_primers=[]\\n seq_length=len(integer_mapped_seq)\\n \\n if len(unaligned_seq)==0:\\n raise_(ValueError,('unaligned sequence contains no data.'))\\n \\n for p in range(len(primers)):\\n corrected_index = get_corrected_index(seq,primers[p].aligned_index)\\n start_index = corrected_index\\n end_index = corrected_index + primer_len\\n \\n \\n # skip test if testing beyond the end of the sequence\\n if end_index > seq_length:\\n continue\\n # Will return all non-zeros with perfect base pair matching\\n seq_bitwise = bitwise_and(primers[p].numeric_seq,\\n integer_mapped_seq[start_index:end_index])\\n if len(seq_bitwise.nonzero()[0])==primer_len:\\n primers[p].non_specific_hits +=1\\n if primers[p].non_specific_hits>deletion_threshold:\\n bad_primers.append(p)\\n\\n \\n del_primers(primers,bad_primers)\\n return primers\",\n \"def match_any_node_id(self, match):\\n pass\",\n \"def test_multi_no_match_return_expr(self):\\n eq_(None,line_no_matches_ngreps(self.line,[\\\"foo\\\",\\\"idontmatch\\\"]))\",\n \"def test_get_new_otu_id_large(self):\\r\\n tree = DndParser(\\\"(A:0.1,B:0.2,(C:0.3,D:0.4):0.5);\\\")\\r\\n results = []\\r\\n for i in range(1000):\\r\\n results.append(qiime.simsam.get_new_otu_id(old_otu_id='D',\\r\\n tree=tree, dissim=.6))\\r\\n self.assertTrue('C' in results)\\r\\n self.assertTrue('D' in results)\\r\\n self.assertTrue('A' not in results)\\r\\n self.assertTrue('B' not in results)\",\n \"def match_cells(gt_cells, m_cells, storm_input, filtered_binaries, max_d=3):\\n img_numbers = np.array([int(re.findall(r'(\\\\d+)', cell.name)[0]) for cell in m_cells])\\n encoded_gt = encode_intensity(gt_cells)\\n\\n false_positive = 0\\n bordering = 0\\n too_far = 0\\n max_idx_gt = 0\\n\\n gt_matched, m_matched = [], []\\n for i in tqdm(np.unique(storm_input['frame'])): # Iteration starts at 1 (ImageJ indexing)\\n st_elem = storm_input[storm_input['frame'] == i].copy()\\n X = np.array([st_elem['x'], st_elem['y']]).T.copy()\\n linkage = fc.linkage(X)\\n clusters = fcluster(linkage, max_d, criterion='distance')\\n clustered_st = [st_elem[clusters == i] for i in np.unique(clusters)]\\n encoded_storm = [encode(elem['intensity']) for elem in clustered_st]\\n\\n s_cells = m_cells[img_numbers == (i - 1)]\\n if len(s_cells) == 0:\\n print('No cells, img {}'.format(i))\\n continue\\n\\n cell_numbers = np.array([int(re.findall(r'(\\\\d+)', cell.name)[1]) for cell in s_cells])\\n binary_img = filtered_binaries[i - 1]\\n coms_cells = np.array([mh.center_of_mass(binary_img == j) for j in cell_numbers])\\n\\n matched = 0\\n for cluster, code in zip(clustered_st, encoded_storm):\\n\\n # Find the GT cell\\n idx_gt = np.argwhere(code == encoded_gt)\\n if idx_gt > max_idx_gt:\\n max_idx_gt = idx_gt\\n\\n if len(idx_gt) == 0:\\n # print('Cluster not in cells, probably bordering cell')\\n bordering += 1\\n continue\\n else:\\n gt_cell = gt_cells[idx_gt[0][0]]\\n\\n # Find the M cell\\n com_storm = [np.mean(cluster['y']), np.mean(cluster['x'])]\\n ds = np.sqrt((coms_cells[:, 0] - com_storm[0]) ** 2 + (coms_cells[:, 1] - com_storm[1]) ** 2)\\n\\n idx_m = np.argmin(ds)\\n if np.min(ds) > 20:\\n too_far += 1\\n continue\\n else:\\n matched += 1\\n m_cell = s_cells[idx_m]\\n\\n gt_matched.append(gt_cell.name + '\\\\n')\\n m_matched.append(m_cell.name + '\\\\n')\\n\\n false_positive += (len(s_cells) - matched)\\n\\n print('False positive', false_positive)\\n print('Bordering, Too far', bordering, too_far)\\n print('Max GT index:', max_idx_gt)\\n\\n return gt_matched, m_matched\",\n \"def nodes_with_m_nbrs(G,m):\\n nodes = set()\\n \\n # Iterate over all nodes in G\\n for n in G.nodes():\\n \\n # Check if the number of neighbors of n matches m\\n if len(G.neighbors(n)) == m:\\n \\n # Add the node n to the set\\n nodes.add(n)\\n \\n # Return the nodes with m neighbors\\n return nodes\",\n \"def match3(img1, img2, coordinates1, coordinates2, PATCH_SIZE, threshold=0.7):\\n\\n\\t#creating patches for all points from img1 and img2\\n\\tcoord1_patches = [make_patch(coordinate, PATCH_SIZE, img1) for coordinate in coordinates1]\\n\\tcoord2_patches = [make_patch(coordinate, PATCH_SIZE, img2) for coordinate in coordinates2]\\n\\n\\t# creating a matrix with dissimilarity measures for all pairs\\n\\tall_matches = np.zeros((len(coordinates1), len(coordinates2)))\\n\\n\\tfor (x, y), _ in np.ndenumerate(all_matches):\\n\\t\\tall_matches[x,y] = count_difference(coord1_patches[x], coord2_patches[y])\\n\\n\\t#looking for best left-to-right and right-to-left matches\\n\\tmatches = []\\n\\t#left-to-right\\n\\tfor i, coord1 in enumerate(coordinates1):\\n\\t\\tbest_ltr_match = np.argmin(all_matches[i, :]) #best left-to-right match for coord1\\n\\t\\tbest_rtl_match = np.argmin(all_matches[:, best_ltr_match]) #best match for a best match\\n\\t\\tif (i == best_rtl_match): #hurray, there is a super match\\n\\n\\t\\t\\tmatches.append([coord1, coordinates2[best_ltr_match], all_matches[i, best_ltr_match]])\\n\\t\\n\\treturn matches\",\n \"def mi_from_dm_alt_hq(distance_matrix, ns, nh, spike_train_list=None):\\n \\n print \\\"start loading\\\"\\n \\n nr = len(distance_matrix)\\n nt = nr/ns\\n #nearest_neighbours = np.array([r.argsort()[:nh] for r in distance_matrix])\\n nearest_neighbours = np.array([np.array(hq.nsmallest(nh, r)) for r in distance_matrix])\\n near_to = [[j for j in range(nr) if i in nearest_neighbours[j] ] for i in range(nr)]\\n \\n print \\\"finished sorting\\\"\\n return\\n #nr = len(distance_matrix)\\n #nearest_neighbours = np.array([[i] + distance_matrix[i].argsort()[1:nh].tolist() for i in range(nr)])\\n \\n members_of_glob = trains_in_glob(spike_train_list)\\n glob_comp = glob_composition(spike_train_list, ns, nt, nh)\\n \\n counts = []\\n counted_glob = False #set a flag for later use\\n if spike_train_list is not None:\\n for i in range(len(near_to)):\\n c_i = 0\\n \\n if i not in members_of_glob:\\n #print near_to[i]\\n for j in near_to[i]:\\n if j not in members_of_glob and spike_train_list[i].start_time == spike_train_list[j].start_time:\\n c_i += 1\\n else:\\n if not counted_glob: #this should only really happen if glob has a small number of members...\\n f_i = glob_comp[i]/float(sum(glob_comp.values()))\\n g_i = f_i - 1.0/float(sum(glob_comp.values()))\\n c_i += (nh - c_i)*g_i\\n \\n counted_glob = True\\n else:\\n pass\\n \\n else: #If i is in the glob...\\n f_i = glob_comp[i]/float(sum(glob_comp.values()))\\n g_i = f_i - 1.0/float(sum(glob_comp.values()))\\n c_i = 1 + (nh - 1)*g_i\\n \\n counts.append(c_i) \\n counts = np.array(counts) \\n I = (1.0/nr)*sum( np.log2((ns*counts)/float(nh)) ) \\n \\n else:\\n near_to_same_stim = [[n for n in near_to[j] if abs(n-j)%ns==0 ] for j in range(nr)]\\n number_of_neighbourhoods = np.array([len(l) for l in near_to])\\n number_of_neighbourhoods_same_stim = np.array([len(l) for l in near_to_same_stim])\\n I = (1.0/nr)*sum( np.log2((ns*number_of_neighbourhoods_same_stim)/float(nh)) )\\n \\n return I\",\n \"def match_all(data_dir):\\n print('Loading GT')\\n gt_cells = load(os.path.join(data_dir, 'cell_obj', 'cells_final_selected.hdf5'))\\n storm_i = np.load(os.path.join(data_dir, 'images', 'storm_inner.npy'))\\n\\n for ph in [10000, 1000, 500]:\\n print('Photons {}'.format(ph))\\n\\n m_cells = load(os.path.join(data_dir, 'cell_obj', 'cell_ph_{}_raw.hdf5'.format(ph)))\\n print('Measured cells loaded')\\n\\n bin_predicted = tifffile.imread(os.path.join(data_dir, 'images', 'binary_{}photons_predicted.tif'.format(ph)))\\n print('Filtering')\\n filtered_pred = filter_binaries(bin_predicted, min_size=495, max_size=2006.4, min_minor=7.57, max_minor=17.3,\\n min_major=15.41, max_major=54.97)\\n\\n gt_match, m_match, = match_cells(gt_cells, m_cells, storm_i, filtered_pred, max_d=5)\\n\\n print('Matched {} cells out of max {}'.format(len(m_match), len(m_cells)))\\n\\n for i, (m_, gt_) in tqdm(enumerate(zip(m_match, gt_match))):\\n m_i = m_cells.name.tolist().index(m_.rstrip())\\n g_i = gt_cells.name.tolist().index(gt_.rstrip())\\n\\n try:\\n assert len(m_cells[m_i].data.data_dict['storm_inner']) == len(gt_cells[g_i].data.data_dict['storm_inner'])\\n except AssertionError:\\n print('Assertion error:', i)\\n\\n with open(os.path.join(data_dir, 'matched_names', 'gt_cells_ph_{}_match.txt'.format(ph)), 'w') as f:\\n f.writelines(gt_match)\\n\\n with open(os.path.join(data_dir, 'matched_names', 'm_cells_ph_{}_match.txt'.format(ph)), 'w') as f:\\n f.writelines(m_match)\",\n \"def out_of_place_dissimilarity(self, other):\\n # Based on the implementation provided by the textcat R package\\n # http://cran.r-project.org/web/packages/textcat/index.html.\\n sorted_self = [ngram for ngram, freq in\\n sorted(iteritems(self._ngrams),\\n key=operator.itemgetter(1), reverse=True)]\\n sorted_other = [ngram for ngram, freq in\\n sorted(iteritems(other._ngrams),\\n key=operator.itemgetter(1), reverse=True)]\\n dissimilarity = 0\\n for j in range(len(sorted_other)):\\n if sorted_other[j] in self:\\n i = sorted_self.index(sorted_other[j])\\n dissimilarity += abs(i - j)\\n else:\\n dissimilarity += len(sorted_self)\\n return dissimilarity\",\n \"def get_plate_ids_from_node_ids(self, nodes: list[int]) -> list[int]:\\n ids = []\\n\\n for k, v in vars(self).items():\\n if v.nodes == nodes:\\n ids.append(k)\\n\\n if len(ids) == 0:\\n ids = None\\n\\n return ids\",\n \"def sm_get_matching_blocks(s1,s2,min_length=1):\\n anslist= list(SM(None, s1, s2).get_matching_blocks())\\n\\n\\n anslist = [ l for l in anslist if l.size>=min_length]\\n\\n anslist=[ (s1[l.a:l.a+l.size], l.a, l.b, l.size) for l in anslist]\\n return anslist\",\n \"def _get_ring_nodes(m, namin=3, namax=9, remove_redudant=T):\\n # first search for rings\\n sets = []\\n for i in range(namin, namax+1):\\n #if i in [3,4,5]:\\n pat_i = '*~1' + '~*'*(i-2) + '~*1'\\n #else:\\n # pat_i = '*:1' + ':*'*(i-2) + ':*1'\\n Qi = Chem.MolFromSmarts( pat_i )\\n for tsi in m.GetSubstructMatches(Qi):\\n set_i = set(tsi)\\n if set_i not in sets:\\n sets.append( set(tsi) )\\n if remove_redudant:\\n # now remove those rings that are union of smaller rings\\n n = len(sets)\\n sets_remove = []\\n ijs = itl.combinations( list(range(n)), 2 )\\n sets_u = []\\n for i,j in ijs:\\n set_ij = sets[i].union( sets[j] )\\n if (set_ij in sets) and (set_ij not in sets_remove):\\n sets_remove.append( set_ij )\\n sets_u = cim.get_compl(sets, sets_remove)\\n else:\\n sets_u = sets\\n return sets_u\",\n \"def starting_nodes(self):\\n # Level 0 nodes in a directed graph will have 1 or more out_edges but no in_edges\\n nodes_with_outs = set(e[0] for e in self.G2.out_edges())\\n nodes_with_ins = set(e[1] for e in self.G2.in_edges())\\n return nodes_with_outs - nodes_with_ins\",\n \"def contained(self):\\n seen = set()\\n return [l.to_segment for l in self.edges_to_contained \\\\\\n if id(l) not in seen and not seen.add(id(l))]\",\n \"def get_neighbours(kmer, max_d):\\n assert (is_dna(kmer))\\n result = set([kmer])\\n for i in range(max_d):\\n addded = set()\\n for kmer in result:\\n addded |= _get_neighbours(kmer)\\n result |= addded\\n return result\",\n \"def intersection(matrix,n1,n2):\\n inter = []\\n for n,v in matrix[n1.id].items():\\n if v == None and matrix[n2.id][n] == None:\\n inter.append(n)\\n return inter\",\n \"def perform_mindmatch(\\n A: np.array, n_trim: int = None,\\n n_match: int = 6, cois: list = None\\n):\\n # setting distance in the diagonal\\n A[np.arange(len(A)), np.arange(len(A))] = -1000 \\n\\n # if conflict of interest (COIs) is available, add to the matrix\\n cois = [(c1, c2) for (c1, c2) in cois\\n if c1 <= len(A) and c2 <= len(A)] # make sure a given cois is in range\\n A[np.array(cois)] = -1000\\n\\n # trimming affinity matrix to reduce the problem size\\n if n_trim != 0:\\n A_trim = []\\n for r in range(len(A)):\\n a = A[r, :]\\n a[np.argsort(a)[0:n_trim]] = 0\\n A_trim.append(a)\\n A_trim = np.vstack(A_trim)\\n else:\\n A_trim = A\\n\\n # solving matching problem\\n print('Solving a matching problem...')\\n v, K, d = create_lp_matrix(A_trim, \\n min_reviewers_per_paper=n_match, max_reviewers_per_paper=n_match,\\n min_papers_per_reviewer=n_match, max_papers_per_reviewer=n_match)\\n x_sol = linprog(v, K, d)['x']\\n b = create_assignment(x_sol, A_trim)\\n\\n if (b.sum() == 0):\\n print('Seems like the problem does not converge, try reducing <n_trim> but not too low!')\\n else:\\n print('Successfully assigned all the match!')\\n return b\",\n \"def create_match_instance_pairs(plant_match_in):\\r\\n\\t## collect all plant name match instances indices\\r\\n\\tjust_indices = [int(indices) for plant_match_in_set in plant_match_in for indices in plant_match_in_set[1]]\\r\\n\\t\\r\\n\\tassert len(just_indices) == len(set(just_indices)) # check there are no exact duplicates in indices\\r\\n\\r\\n\\tsorted_index = list(sorted(just_indices)) # sort indices small-large\\r\\n\\tprint(f'Length of corpus bigrams BEFORE ambiguous matches removed: {len(sorted_index)}')\\r\\n\\t#print(sorted_index)\\r\\n\\r\\n\\t# remove all ambiguous matches that are within 1 word of each other\\r\\n\\tprint('Ambiguous plant name matches: ')\\r\\n\\tfor i, index in enumerate(sorted_index): # iterate over all indices in sorted list\\r\\n\\t\\t\\r\\n\\t\\tif index == sorted_index[i-1]+1: # indices is within 1 of previous indices in list\\r\\n\\t\\t\\tprint(index, sorted_index[i-1])\\r\\n\\t\\t\\tsorted_index.remove(index) # remove indices from list\\r\\n\\t\\t\\tsorted_index.remove(sorted_index[i-1]) # AND remove previous indices from list\\r\\n\\tprint(f'Length of corpus bigrams AFTER ambiguous matches removed: {len(sorted_index)}')\\r\\n\\r\\n\\t# create indices dict with 'B', 'I' values\\r\\n\\tpaired_finds = {}\\r\\n\\tfor match_index in sorted_index: # iterate over unambiguous match indices list\\r\\n\\t\\t\\t\\t\\t\\r\\n\\t\\t\\tpaired_finds[match_index] = ('B') # WITH value of 'B'\\r\\n\\t\\t\\t\\r\\n\\t\\t\\tpaired_finds[match_index+1] = ('I') # WITH value of 'I'\\r\\n\\r\\n\\treturn paired_finds\",\n \"def remove_duplicates_by_matching():\\n # 1) and 2)\\n all_blobs = vision.pqr_r\\n all_angles = np.zeros(0)\\n right = np.transpose(vision.pqr_r)\\n left = np.transpose(vision.pqr_l)\\n\\n if not right.size and not left.size:\\n return (0, 0)\\n\\n if not right.size:\\n for l in left:\\n angle = np.arctan2(l[1], l[0]) * 180 / pi\\n all_angles = np.append(all_angles, angle)\\n return (vision.pqr_l, all_angles)\\n\\n if not left.size:\\n for r in right:\\n angle = np.arctan2(r[1], r[0]) * 180 / pi\\n all_angles = np.append(all_angles, angle)\\n return (vision.pqr_r, all_angles)\\n\\n\\n for r in right:\\n angle = np.arctan2(r[1], r[0]) * 180 / pi\\n all_angles = np.append(all_angles, angle)\\n cand_r = np.zeros((3,1))\\n if angle < 15:\\n cand_r = np.append(cand_r, [[r[0]], [r[1]], [r[2]]], axis=1)\\n cand_r = np.delete(cand_r, 0, axis=1)\\n cand_r = np.transpose(cand_r)\\n\\n for l in left:\\n angle = np.arctan2(l[1], l[0]) * 180 / pi\\n dot = 0\\n if angle > -15:\\n dl = max(0.001, np.linalg.norm(l))\\n for r in cand_r:\\n dr = max(0.001, np.linalg.norm(r))\\n dot = np.dot(r, l) / (dr * dl)\\n print(dot)\\n if dot > 0.9:\\n continue\\n \\n if dot <= 0.9:\\n all_blobs = np.append(all_blobs, [[l[0]], [l[1]], [l[2]]], axis=1)\\n all_angles = np.append(all_angles, angle)\\n\\n # make even number of blobs if necessary\\n #if all_blobs.shape[1] % 2:\\n # all_blobs = np.delete(all_blobs, 0, axis=1)\\n # all_angles = np.delete(all_angles, 0)\\n\\n\\n\\n return (all_blobs, all_angles)\",\n \"def _get_identical_ligand_indices(\\n ligand: oechem.OEMolBase, smiles_iterable: Iterable[str]\\n ) -> List[int]:\\n from ..modeling.OEModeling import read_smiles, are_identical_molecules\\n\\n identical_ligand_indices = []\\n for i, complex_ligand in enumerate(smiles_iterable):\\n if are_identical_molecules(ligand, read_smiles(complex_ligand)):\\n identical_ligand_indices.append(i)\\n\\n return identical_ligand_indices\",\n \"def calculate_disparity_map(\\n left_img: torch.Tensor,\\n right_img: torch.Tensor,\\n block_size: int,\\n sim_measure_function: Callable,\\n max_search_bound: int = 50,\\n) -> torch.Tensor:\\n\\n assert left_img.shape == right_img.shape\\n (H,W,C) = left_img.shape\\n H_offset = block_size//2\\n W_offset = block_size//2\\n disp_map = torch.zeros(H-2*H_offset,W-2*W_offset) # placeholder, this is not the actual size\\n\\n\\n ###########################################################################\\n # Student code begins\\n ###########################################################################\\n\\n for ii in range(H-2*H_offset):\\n for jj in range(W-2*W_offset):\\n left_patch = left_img[ii:ii+block_size,jj:jj+block_size, :]\\n similarity_error_array = -1 * np.ones(max_search_bound)\\n \\n for kk in range(max_search_bound):\\n jj_start = max(jj - kk, 0)\\n jj_end = max(jj - kk + block_size, block_size)\\n\\n right_patch = right_img[ii:ii+block_size, jj_start:jj_end, :]\\n similarity_error_array[kk] = sim_measure_function(left_patch, right_patch)\\n\\n disp_map[ii,jj] = np.argmin(similarity_error_array)\\n\\n ###########################################################################\\n # Student code ends\\n ###########################################################################\\n return disp_map\",\n \"def get_elim_candidates(df2, df1):\\n if df1.loc[1,'Problem']!= problems[0]:\\n return\\n \\n nodes_order_av, nodes_above = order_analysis(df2, df1, 'NewNodes')\\n time_order_av, time_above = order_analysis(df2, df1, 'ElapsedSeconds')\\n elim_candidates = set(nodes_above[:nodes_order_av]).intersection(set(time_above[:time_order_av]))\\n # return their 1-base index also:\\n out = [(SEARCHES.index(c)+1, c) for c in elim_candidates]\\n return out\",\n \"def nodes_with_m_nbrs(G, m):\\n nodes = set()\\n\\n # Iterate over all nodes in G\\n for n in G.nodes():\\n\\n # Check if the number of neighbors of n matches m\\n if len(G.neighbors(n)) == m:\\n\\n # Add the node n to the set\\n nodes.add(n)\\n\\n # Return the nodes with m neighbors\\n return nodes\",\n \"def find_not_in_icd_set(lenoforginalset, numbers_set):\\r\\n originalset = [str(i) for i in range(1, lenoforginalset+1, 1)]\\r\\n\\r\\n numbers_not_in_set = list(set(originalset)-set(numbers_set))\\r\\n numbers_not_in_set = sorted([int(num) for num in numbers_not_in_set])\\r\\n numbers_not_in_set = [str(num) for num in numbers_not_in_set]\\r\\n\\r\\n return numbers_not_in_set\",\n \"def node_purity_mask(group_ids: nb.int64[:],\\n primary_ids: nb.int64[:]) -> nb.boolean[:]:\\n purity_mask = np.zeros(len(group_ids), dtype=np.bool_)\\n for g in np.unique(group_ids):\\n group_mask = group_ids == g\\n if np.sum(group_mask) > 1 and np.sum(primary_ids[group_mask] == 1) == 1:\\n purity_mask[group_mask] = np.ones(np.sum(group_mask))\\n\\n return purity_mask\",\n \"def MatchMatrixs (self,Node1,Node2):\\n\\n T1Native_Node = Node1\\n T1Native_Matrix = slicer.util.arrayFromVolume(T1Native_Node)\\n DimN = T1Native_Matrix.shape\\n T1Enhanced_Node = Node2\\n T1Enhanced_Matrix = slicer.util.arrayFromVolume(T1Enhanced_Node)\\n DimE = T1Enhanced_Matrix.shape\\n\\n NMatrix = self.GetIJKToRASnpArray(T1Native_Node)\\n NVector = NMatrix[:-1,-1]\\n EMatrix = self.GetIJKToRASnpArray(T1Enhanced_Node)\\n EVector = EMatrix[:-1,-1]\\n NPixelSize = [np.linalg.norm(NMatrix[:-1,0]), np.linalg.norm(NMatrix[:-1,1])]\\n EPixelSize = [np.linalg.norm(EMatrix[:-1,0]), np.linalg.norm(EMatrix[:-1,1])]\\n\\n Niversor = NMatrix[:-1,0]/NPixelSize[0]\\n Njversor = NMatrix[:-1,1]/NPixelSize[1]\\n Nkversor = np.round(np.cross(Niversor,Njversor),3)\\n Nkstep = round(np.linalg.norm(NMatrix[:-1,2]),3)\\n\\n Eiversor = EMatrix[:-1,0]/EPixelSize[0]\\n Ejversor = EMatrix[:-1,1]/EPixelSize[1]\\n Ekversor = np.round(np.cross(Eiversor,Ejversor),3)\\n Ekstep = round(np.linalg.norm(EMatrix[:-1,2]),3)\\n print(Nkversor,Ekversor,Nkstep,Ekstep,NVector,EVector,(NVector-EVector).dot(Ekversor))\\n if not ( np.sum(Nkversor==Ekversor) == 3 and Nkstep==Ekstep and ((NVector-EVector).dot(Ekversor)) == 0 ): # it verifies if the slices are oriented in the same direction, with the same step between slices and if the first images are complanar.\\n slicer.util.warningDisplay('The geometry of the LL Native and LL Enhanced volume doesn\\\\'t match. It could deteriorate the ECV map', windowTitle= 'Warning')\\n\\n if (DimE == DimN):\\n T1_ECVMappingLogic.setupNodeFromNode(self,self.ECVMapNode , self.NativeT1_Selector.currentNode()) \\n return [T1Native_Matrix,T1Enhanced_Matrix]\\n if (DimE[1:3] == DimN[1:3]):\\n k = min([DimE[1],DimN[1]])\\n T1_ECVMappingLogic.setupNodeFromNode(self,self.ECVMapNode , self.NativeT1_Selector.currentNode())\\n return [T1Native_Matrix[:k,:,:],T1Enhanced_Matrix[:k,:,:]]\\n\\n jN = np.arange(0,DimN[2]*NPixelSize[1],NPixelSize[1])+NPixelSize[1]/2+(NVector-EVector).dot(Njversor)\\n iN = np.arange(0,DimN[1]*NPixelSize[0],NPixelSize[0])+NPixelSize[0]/2+(NVector-EVector).dot(Niversor)\\n iE = np.arange(0,DimE[1]*EPixelSize[0],EPixelSize[0])+EPixelSize[0]/2\\n jE = np.arange(0,DimE[2]*EPixelSize[1],EPixelSize[1])+EPixelSize[1]/2 \\n if DimE[1] > DimN[1]: ## I concidered a square image\\n T1Nreshaped = np.zeros(DimE)\\n for k in range(DimN[0]):\\n f = interpolate.interp2d(iN, jN, np.nan_to_num(T1Native_Matrix[k,:,:]), fill_value = 0)\\n T1Nreshaped[k,:,:] = f(iE, jE)\\n T1Ereshaped = T1Enhanced_Matrix[:k+1,:,:]\\n T1_ECVMappingLogic.setupNodeFromNode(self,self.ECVMapNode , self.EnhancedT1_Selector.currentNode())\\n return [T1Nreshaped,T1Ereshaped]\\n else:\\n T1Ereshaped = np.zeros(DimN)\\n for k in range(DimE[0]):\\n f = interpolate.interp2d(iE, jE, np.nan_to_num(T1Enhanced_Matrix[k,:,:]), fill_value = 0)\\n T1Ereshaped[k,:,:] = f(iN, jN) \\n T1Nreshaped = T1Native_Matrix[:k+1,:,:]\\n T1_ECVMappingLogic.setupNodeFromNode(self,self.ECVMapNode , self.NativeT1_Selector.currentNode()) \\n return [T1Nreshaped,T1Ereshaped]\",\n \"def problem2(self, s):\\n \\n points = self.neighbor(100, 10, s.exhaustive_search)\\n points += self.neighbor(10, 100, s.exhaustive_search)\\n points += 1\\n\\n _testDriver.get_code(s.exhaustive_search)\\n print \\\"\\\\n(Check that scipy.spatial.KDTree is not used)\\\"\\n points *= self.grade(1)\\n\\n return points\",\n \"def test_selection():\\n pdb_inp = iotbx.pdb.input(source_info=None, lines=pdb_answer_0)\\n ncs_obj_phil = ncs.input(\\n hierarchy=pdb_inp.construct_hierarchy())\\n nrg = ncs_obj_phil.get_ncs_restraints_group_list()\\n\\n m1 = list(nrg[0].master_iselection)\\n c1 = list(nrg[0].copies[0].iselection)\\n c2 = list(nrg[0].copies[1].iselection)\\n\\n assert len(m1) == len(c1) # renumbering\\n assert m1 == [0, 1, 2, 3, 4, 5, 6] # 0, 1, X, 3, X, 5, X | 0, 1, 3\\n assert c1 == [7, 8, 9, 10, 11, 12, 13] # 7, 8, 9, X, X, 12, X | 4, 5, 7\\n assert c2 == [14, 15, 16, 17, 18, 19, 20] # 14, 15, X, 17, X, 19, X | 8, 9, 11\\n\\n selection1 = flex.size_t([0,1,5,3,100,101])\\n selection2 = flex.size_t([0,1,5,3,7,8,9,12,100,101])\\n selection3 = flex.size_t([0,1,5,3,7,8,9,12,14,15,19,17,100,101])\\n # gone iseqs for selection3: 2,4,6,10,11,13,16,18,20-99\\n\\n new_nrg = nrg.select(flex.bool(102, selection1))\\n # only atoms in master are selected\\n mt = list(new_nrg[0].master_iselection)\\n c1t = list(new_nrg[0].copies[0].iselection)\\n\\n assert mt == []\\n assert c1t == []\\n\\n # atoms selected in both master and copies\\n new_nrg = nrg.select(flex.bool(102, selection2))\\n # only atoms in master are selected\\n mt = list(new_nrg[0].master_iselection)\\n c1t = list(new_nrg[0].copies[0].iselection)\\n\\n assert mt == []\\n assert c1t == []\\n\\n new_nrg = nrg.select(flex.bool(102, selection3))\\n # only atoms in master are selected\\n mt = list(new_nrg[0].master_iselection)\\n c1t = list(new_nrg[0].copies[0].iselection)\\n c2t = list(new_nrg[0].copies[1].iselection)\\n\\n assert mt == [0, 1, 3], list(mt)\\n assert c1t == [4, 5, 7], list(c1t)\\n assert c2t == [8, 9, 11], list(c2t)\",\n \"def compare_two_grids( treecode1, treecode2 ):\\n import numpy as np\\n\\n common_blocks = 0\\n\\n for i in range(treecode1.shape[0]):\\n # we look for this tree code in the second array\\n code1 = treecode1[i,:]\\n\\n for j in range(treecode2.shape[0]):\\n code2 = treecode2[j,:]\\n if np.linalg.norm( code2-code1 ) < 1.0e-13:\\n # found code1 in the second array\\n common_blocks += 1\\n break\\n\\n print( \\\"Nblocks1=%i NBlocks2=%i common blocks=%i\\\" % (treecode1.shape[0], treecode2.shape[0], common_blocks) )\\n\\n return common_blocks / treecode1.shape[0]\",\n \"def match_twosided(desc1, desc2):\\n\\n matches_12 = match(desc1, desc2)\\n matches_21 = match(desc2, desc1)\\n\\n ndx_12 = matches_12.non_zeros()[0]\\n\\n for n in ndx_12:\\n if matches_21[int(matches_12[n])] != n:\\n matches_12[n] = 0\\n\\n return matches_12\",\n \"def hard_examples_mining(dist_mat, identity_mat, return_idxes=False):\\n # the implementation here is a little tricky, dist_mat contains pairwise distance between probe image and other\\n # images in current mini-batch. As we want to select positive examples of the same person, we add a constant\\n # negative offset on other images before sorting. As a result, images of the **same** person will rank first.\\n sorted_dist_mat, sorted_idxes = torch.sort(dist_mat + (-1e7) * (1 - identity_mat), dim=1,\\n descending=True)\\n dist_ap = sorted_dist_mat[:, 0]\\n hard_positive_idxes = sorted_idxes[:, 0]\\n\\n # the implementation here is similar to above code, we add a constant positive offset on images of same person\\n # before sorting. Besides, we sort in ascending order. As a result, images of **different** persons will rank first.\\n sorted_dist_mat, sorted_idxes = torch.sort(dist_mat + 1e7 * identity_mat, dim=1,\\n descending=False)\\n dist_an = sorted_dist_mat[:, 0]\\n hard_negative_idxes = sorted_idxes[:, 0]\\n if return_idxes:\\n return dist_ap, dist_an, hard_positive_idxes, hard_negative_idxes\\n return dist_ap, dist_an\",\n \"def maxima(self, nodeids: Optional[List[str]] = None) -> List[str]:\\n\\n if nodeids is None:\\n nodeids = list(self.graph.nodes)\\n\\n return [nid for nid in nodeids\\n if all(e[0] == nid\\n for e in self.graph.edges\\n if e[0] in nodeids\\n if e[1] in nodeids\\n if nid in e)]\",\n \"def GetNodeCommonality(self):\\n\\n self.__do_essential_memebers_exist__()\\n\\n elements = self.elements.ravel()\\n idx_sort = np.argsort(elements)\\n sorted_elements = elements[idx_sort]\\n vals, idx_start = np.unique(sorted_elements, return_index=True)\\n\\n # Sets of indices\\n flat_pos = np.split(idx_sort, idx_start[1:])\\n els = np.split(idx_sort // int(self.elements.shape[1]), idx_start[1:])\\n pos = np.split(idx_sort % int(self.elements.shape[1]), idx_start[1:])\\n\\n # In case one wants to return only the duplicates i.e. filter keeping only items occurring more than once\\n # vals, idx_start, count = np.unique(sorted_elements, return_counts=True, return_index=True)\\n # vals = vals[count > 1]\\n # res = filter(lambda x: x.size > 1, res)\\n\\n return els, pos, flat_pos\",\n \"def mi_from_dm_alt(distance_matrix, ns, nh, spike_train_list=None):\\n \\n #print \\\"start loading\\\"\\n \\n nr = len(distance_matrix)\\n nt = nr/ns\\n nearest_neighbours = np.array([r.argsort()[:nh] for r in distance_matrix])\\n near_to = [[j for j in range(nr) if i in nearest_neighbours[j] ] for i in range(nr)]\\n \\n #print \\\"finished sorting\\\"\\n #return\\n #nr = len(distance_matrix)\\n #nearest_neighbours = np.array([[i] + distance_matrix[i].argsort()[1:nh].tolist() for i in range(nr)])\\n \\n members_of_glob = trains_in_glob(spike_train_list)\\n glob_comp = glob_composition(spike_train_list, ns, nt, nh)\\n \\n counts = []\\n counted_glob = False #set a flag for later use\\n if spike_train_list is not None:\\n for i in range(len(near_to)):\\n c_i = 0\\n \\n if i not in members_of_glob:\\n #print near_to[i]\\n for j in near_to[i]:\\n \\n if j not in members_of_glob and spike_train_list[i].start_time == spike_train_list[j].start_time:\\n c_i += 1\\n else:\\n if not counted_glob: #this should only really happen if glob has a small number of members...\\n f_i = glob_comp[i]/float(sum(glob_comp.values()))\\n g_i = f_i - 1.0/float(sum(glob_comp.values()))\\n c_i += (nh - c_i)*g_i\\n \\n counted_glob = True\\n else:\\n pass\\n \\n else: #If i is in the glob...\\n f_i = glob_comp[i]/float(sum(glob_comp.values()))\\n g_i = f_i - 1.0/float(sum(glob_comp.values()))\\n c_i = 1 + (nh - 1)*g_i\\n \\n counts.append(c_i) \\n counts = np.array(counts) \\n I = (1.0/nr)*sum( np.log2((ns*counts)/float(nh)) ) \\n \\n else:\\n near_to_same_stim = [[n for n in near_to[j] if abs(n-j)%ns==0 ] for j in range(nr)]\\n number_of_neighbourhoods = np.array([len(l) for l in near_to])\\n number_of_neighbourhoods_same_stim = np.array([len(l) for l in near_to_same_stim])\\n I = (1.0/nr)*sum( np.log2((ns*number_of_neighbourhoods_same_stim)/float(nh)) )\\n \\n return I\",\n \"def find_nodes(shp):\\n node_count = {}\\n for road in shp:\\n vrts = road.vertices\\n for node in vrts:\\n if node not in node_count:\\n node_count[node] = 0\\n node_count[node] += 1\\n node_count[vrts[0]] += 1\\n node_count[vrts[-1]] += 1\\n return set([node for node,c in node_count.iteritems() if c > 1])\",\n \"def calculate_disjoint_excess_count(\\n smaller_genome_gene_ids: List[ObjectId],\\n differing_gene_ids: List[ObjectId]\\n ) -> Tuple[int, int]:\\n\\n smaller_genome_timestamps = [\\n gene_id.generation_time\\n for gene_id in smaller_genome_gene_ids\\n ]\\n\\n if len(smaller_genome_timestamps) > 0:\\n max_timestamp = smaller_genome_timestamps[0] # type: 'ObjectID'\\n else:\\n return 0, 0\\n\\n for timestamp in smaller_genome_timestamps:\\n\\n if timestamp > max_timestamp:\\n max_timestamp = timestamp\\n\\n excess_genes = [\\n gene_id\\n for gene_id in differing_gene_ids\\n if gene_id.generation_time > max_timestamp\\n ]\\n\\n disjoint_genes = [\\n gene_id\\n for gene_id in differing_gene_ids\\n if gene_id not in excess_genes\\n ]\\n\\n return len(disjoint_genes), len(excess_genes)\",\n \"def get_intersecting_dissemination_ids(cross_section, dissemination_areas):\\n assert 'DAUID' in cross_section.columns \\n dissem_arr = dissemination_areas.loc[dissemination_areas['DAUID'].isin(np.unique(cross_section['DAUID'].values))].DAUID.unique()\\n reg_arr = dissemination_areas.loc[dissemination_areas['DAUID'].isin(np.unique(cross_section['DAUID'].values))].CSDUID.unique()\\n# code_arr = dissemination_areas.loc[dissemination_areas['DAUID'].isin(np.unique(cross_section['DAUID'].values))].CODEID.unique()\\n\\n\\n return list(dissem_arr), list(reg_arr)\",\n \"def selectCompatibleIndices(bigTimes, smallTimes):\\r\\n indices = []\\r\\n for idx, _ in enumerate(smallTimes):\\r\\n distances = (bigTimes - smallTimes[idx])**2\\r\\n def getValue(k):\\r\\n return distances[k]\\r\\n thisIndices = sorted(range(len(distances)), key=getValue)\\r\\n indices.append(thisIndices[0])\\r\\n return np.array(indices)\",\n \"def mass_based_dissimilarity(self, x1, x2):\\n # In each i-tree, find lowest nodes containing both x and y\\n # TODO: parallelize\\n sum_masses = 0\\n for itree in self.random_itrees:\\n # Divide each sum by size of subset used to construct the trees.\\n sum_masses += self.get_lowest_common_node_mass(itree, x1, x2)/self.subs_size\\n return (1/len(self.random_itrees)) * sum_masses # Divide by number of space partitioning models.\",\n \"def nn_match(descs1, descs2):\\n # diff = descs1[:, None, :] - descs2[None, :, :]\\n # diff = np.linalg.norm(diff, ord=2, axis=2)\\n # indices = np.argmin(diff, axis=1)\\n\\n flann = cv2.FlannBasedMatcher_create()\\n matches = flann.match(descs1.astype(np.float32), descs2.astype(np.float32))\\n indices = [x.trainIdx for x in matches]\\n\\n return indices\",\n \"def is_near_genome_reference(self, set_iids):\\n\\t\\tassert isinstance(set_iids, set)\\n\\t\\tif None in set_iids:\\n\\t\\t\\tset_iids.remove(None)\\n\\t\\tif None in self._set_reference_genome_ncbi:\\n\\t\\t\\tself._set_reference_genome_ncbi.remove(None)\\n\\t\\tset2 = self._set_reference_genome_ncbi\\n\\t\\tfor iid in set_iids:\\n\\t\\t\\tset1 = set(self._iid_to_tid_lineage[iid])\\n\\t\\t\\tif not set1.isdisjoint(set2):\\n\\t\\t\\t\\treturn True\\n\\t\\treturn False\",\n \"def shareNoEdges(segment,neighbours,segmentsMeta):\\n return np.fromiter(map(lambda x : haveNoSameEdges(segment,x,segmentsMeta),neighbours),np.bool)\",\n \"def nodes_row_similar(all_rows: set[tuple[str, str, str, int, int, int]],\\n identifier: tuple[str, str, str, int, int, int]) -> bool:\\n for row in all_rows:\\n if row[0] == identifier[0] and row[1] == identifier[1]:\\n return True\\n return False\",\n \"def match_gc_content(pos_one_hot, neg_one_hot, neg_pos_ratio=1):\\n N, L, A = pos_one_hot.shape\\n gc_pos = np.sum(np.sum(pos_one_hot[:,:,[1,2]], axis=2), axis=1)/L\\n gc_neg = np.sum(np.sum(neg_one_hot[:,:,[1,2]], axis=2), axis=1)/L\\n print(' Average GC content for positive sequences: %.3f'%(np.mean(gc_pos)))\\n print(' Average GC content for negative sequences: %.3f'%(np.mean(gc_neg)))\\n\\n pos_index = np.argsort(gc_pos)\\n neg_index = np.argsort(gc_neg)\\n num_neg = len(neg_index)\\n num_pos = len(pos_index)\\n\\n match_index = []\\n if num_neg > num_pos:\\n k = 0\\n status = True\\n for i in pos_index:\\n for j in range(k, num_neg):\\n if gc_pos[i] < gc_neg[neg_index[j]]:\\n if k > num_neg:\\n status = False\\n break\\n else:\\n # print(\\\"%.2f vs %.2f\\\"%(gc_pos[i], gc_neg[neg_index[j]]))\\n match_index.append(neg_index[j])\\n k = j+1\\n break\\n if not status:\\n break\\n\\n remainder = int(num_pos*neg_pos_ratio) - len(match_index)\\n print(' Found %d GC-matched sequences.'%(len(match_index)))\\n if remainder > 0:\\n print(' Adding %d more random negative sequences.'%(remainder))\\n remain_index = np.array(list(set(range(num_neg)) - set(match_index)))\\n index = np.random.permutation(len(remain_index))[:remainder] \\n # index = np.argsort(gc_neg[remain_index])[::-1]\\n for n in remain_index[index[:remainder]]:\\n match_index.append(n)\\n \\n match_index = np.array(match_index)\\n print(' Average GC content for sub-sampled negative sequences: %.3f'%(np.mean(gc_neg[match_index])))\\n\\n return neg_one_hot[match_index], match_index\",\n \"def getDistanceMatrix(self, alignedSequences):\\n\\t\\tif not alignedSequences:\\n\\t\\t\\traise ValueError(\\\"alignedSequences must not be empty\\\")\\n\\t\\tdominantAlignedSequence = alignedSequences[0]\\n\\t\\tsubdominantAlignedSequences = alignedSequences[1:]\\n\\t\\tdistanceMatrix = []\\n\\t\\tfor seq in subdominantAlignedSequences:\\n\\t\\t\\tdistanceMatrix.append(len(seq) - self._getNumberOfSpaces(seq) - self._getNumberOfAlignedNucleotides(dominantAlignedSequence, seq))\\n\\t\\treturn distanceMatrix\",\n \"def get_excess_genes(self, other):\\n innovs = {g.innov_num for g in other.link_genes}\\n if not innovs:\\n return []\\n max_innov = max(innovs)\\n return [g for g in self.link_genes\\n if g.innov_num > max_innov and g.innov_num not in innovs]\",\n \"def get_mismatches(rec):\\n qseq = rec.get_forward_sequence().upper()\\n if rec.is_reverse:\\n qseq = reverseComplement(qseq)\\n rseq = rec.get_reference_sequence().upper()\\n for qpos, rpos in rec.get_aligned_pairs():\\n if qpos == None or rpos == None:\\n continue # no indels yet\\n q = qseq[qpos]\\n r = rseq[rpos - rec.reference_start]\\n if q != r:\\n position = (rec.reference_name, rpos)\\n change = (r, q)\\n yield (position, change)\",\n \"def cng_dissimilarity(self, other):\\n dissimilarity = 0.0\\n for ngram in set(self) | set(other):\\n dissimilarity += (2 * (self[ngram] - other[ngram]) /\\n (self[ngram] + other[ngram])) ** 2\\n return dissimilarity\",\n \"def _notstaticneighs_get_corestored_by_inds_notslice(self, inds):\\n inds = [inds] if type(inds) == int else inds\\n idxs = []\\n for k in range(len(self.idxs)):\\n idxs.append([self.idxs[k][i] for i in inds])\\n idxs = np.array(idxs) if type(self.idxs) == np.ndarray else idxs\\n\\n if self.sp_relative_pos is not None:\\n sp_relative_pos = []\\n for k in range(len(self.sp_relative_pos)):\\n sp_relative_pos += [[self.sp_relative_pos[k][i] for i in inds]]\\n else:\\n sp_relative_pos = None\\n return idxs, sp_relative_pos\",\n \"def removeOrphanContents(self):\\n reObjNum = re.compile('[0-9A-Z]{8}$')\\n #--Determine which contIds are matched to a reference.\\n contIds = set(self.conts_id.keys())\\n matched = dict([(id,False) for id in contIds])\\n for cell in self.cells:\\n objects = cell.getObjects()\\n for object in objects.list():\\n objId= object[2]\\n #--LVCR? Get id of spawned creature instead.\\n for objRecord in object[3]:\\n if objRecord.name == 'NAME':\\n objId = cstrip(objRecord.data)\\n break\\n if reObjNum.search(objId):\\n if objId in contIds:\\n matched[objId] = True\\n #--Special case: PlayerSaveGame\\n matched['PlayerSaveGame00000000'] = True\\n #--unmatched = container records that have not been matched.\\n orphans = set([self.conts_id[id] for id in contIds if not matched[id]])\\n for orphan in sorted(orphans, key=lambda a: a.getId().lower()):\\n self.log(' '+orphan.getId())\\n #--Delete Records\\n self.records = [record for record in self.records if record not in orphans]\\n self.conts = [record for record in self.conts if record not in orphans]\\n self.conts_id = dict([(id,record) for id,record in self.conts_id.iteritems() if matched[id] > 0])\\n return len(orphans)\",\n \"def __get_ids_of_all_unrelaxed_candidates__(self):\\n\\n all_unrelaxed_ids = set([t.gaid for t in self.c.select(relaxed=0)])\\n all_relaxed_ids = set([t.gaid for t in self.c.select(relaxed=1)])\\n all_queued_ids = set([t.gaid for t in self.c.select(queued=1)])\\n\\n actually_unrelaxed = [gaid for gaid in all_unrelaxed_ids\\n if (gaid not in all_relaxed_ids and\\n gaid not in all_queued_ids)]\\n\\n return actually_unrelaxed\",\n \"def find_irred(d, m):\\n # Define l\\n l = d + 1\\n\\n # Initialize list\\n result = []\\n # Fill list with random numbers between 0 and m\\n for _ in range(l):\\n result.append(random.randrange(0, m))\\n\\n # Make sure first number is not a 0 \\n result[0] = random.randrange(1, m)\\n\\n # If result is not irreducible, create new list\\n while is_irreducible(result, m) == 'FALSE':\\n result = []\\n for _ in range(l):\\n result.append(random.randrange(0, m))\\n result[0] = random.randrange(1, m)\\n\\n # Clear leading zeroes of the result\\n return clear_leading_zeroes(result)\",\n \"def greedy_match(cost_matrix):\\n num_detections, num_tracks = cost_matrix.shape\\n distance_1d = cost_matrix.reshape(-1)\\n index_1d = np.argsort(distance_1d)\\n index_2d = np.stack([index_1d // num_tracks, index_1d % num_tracks], axis=1).astype(int, copy=False)\\n\\n matched_indices = []\\n matched_firsts = set()\\n matched_seconds = set()\\n\\n for (first_id, second_id) in index_2d:\\n if first_id not in matched_firsts and second_id not in matched_seconds:\\n matched_seconds.add(second_id)\\n matched_firsts.add(first_id)\\n matched_indices.append([first_id, second_id])\\n return np.array(matched_indices)\",\n \"def match_twosided(desc1,desc2):\\n matches_12 = match(desc1, desc2)\\n matches_21 = match(desc2, desc1)\\n ndx_12 = matches_12.nonzero()[0]\\n # remove matches that are not symmetric\\n for n in ndx_12:\\n if matches_21[int(matches_12[n])] != n:\\n matches_12[n] = 0\\n return matches_12\",\n \"def _find_neighbours(self):\\n\\n neighbours = []\\n for i, p in enumerate(self.frame_0):\\n nearests = np.where(np.linalg.norm(self.frame_0 - p, axis=1) <= self.R_n)[0]\\n # delete self index\\n index = np.argwhere(nearests==i)\\n nearests = np.delete(nearests, index)\\n neighbours.append(nearests)\\n\\n return neighbours\",\n \"def match_align(self, match_only=True):\\n\\n print('Running match_align')\\n\\n # Note about alignment parameters: Used to have a small -0.1\\n # penalty for gap creation & extension. Got rid of this in favor\\n # of getting better alignments, but the downside is that for\\n # cases where you want to know which residues are mutants of\\n # each other, you don't get that info anymore.\\n alignments = pairwise2.align.globalxs(self.target_sequence,\\\\\\n self.mobile_sequence, 0, 0)\\n\\n #for alignment in alignments:\\n if not alignments:\\n return False\\n print(alignments)\\n best_rmsd = 9999\\n i = 0\\n for i in range(0, len(alignments)):\\n bb_rmsd = self.align_sequences(alignments, i,\\n match_only=match_only)\\n if bb_rmsd < best_rmsd:\\n best_rmsd = bb_rmsd\\n best_i = i\\n self.bb_rmsd = self.align_sequences(alignments, best_i,\\n match_only=match_only)\\n\\n return True\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.7025583","0.58557904","0.5646902","0.56260955","0.55979025","0.5596457","0.5506559","0.54735655","0.54688025","0.5428346","0.54266435","0.5401781","0.5376381","0.53503776","0.53159696","0.53106","0.5259019","0.52510506","0.52362823","0.52313286","0.52215177","0.5196703","0.5182625","0.51767755","0.5175468","0.5172182","0.5154292","0.5153443","0.5148091","0.51260656","0.5116194","0.51149976","0.5111097","0.51076055","0.5061679","0.5049236","0.5034832","0.501697","0.5006199","0.50016505","0.49949038","0.4986162","0.49856737","0.49618223","0.4959491","0.4957305","0.4956508","0.49530572","0.49517292","0.4946373","0.4929652","0.49186552","0.4913311","0.49103603","0.49054474","0.4901659","0.48984858","0.48952395","0.48903027","0.48823473","0.48822066","0.4880196","0.48785686","0.48757115","0.4875297","0.4848663","0.48457602","0.48339862","0.48325896","0.4832004","0.48289084","0.48275638","0.48203376","0.48196894","0.48138252","0.4812278","0.4796509","0.4795352","0.4790396","0.47860554","0.4783766","0.47826695","0.47792777","0.47739163","0.4770491","0.47671276","0.47661588","0.47641256","0.47626722","0.47581136","0.47579896","0.4756379","0.47561136","0.47495705","0.47453418","0.47431073","0.4737472","0.47338456","0.4732362","0.4725343"],"string":"[\n \"0.7025583\",\n \"0.58557904\",\n \"0.5646902\",\n \"0.56260955\",\n \"0.55979025\",\n \"0.5596457\",\n \"0.5506559\",\n \"0.54735655\",\n \"0.54688025\",\n \"0.5428346\",\n \"0.54266435\",\n \"0.5401781\",\n \"0.5376381\",\n \"0.53503776\",\n \"0.53159696\",\n \"0.53106\",\n \"0.5259019\",\n \"0.52510506\",\n \"0.52362823\",\n \"0.52313286\",\n \"0.52215177\",\n \"0.5196703\",\n \"0.5182625\",\n \"0.51767755\",\n \"0.5175468\",\n \"0.5172182\",\n \"0.5154292\",\n \"0.5153443\",\n \"0.5148091\",\n \"0.51260656\",\n \"0.5116194\",\n \"0.51149976\",\n \"0.5111097\",\n \"0.51076055\",\n \"0.5061679\",\n \"0.5049236\",\n \"0.5034832\",\n \"0.501697\",\n \"0.5006199\",\n \"0.50016505\",\n \"0.49949038\",\n \"0.4986162\",\n \"0.49856737\",\n \"0.49618223\",\n \"0.4959491\",\n \"0.4957305\",\n \"0.4956508\",\n \"0.49530572\",\n \"0.49517292\",\n \"0.4946373\",\n \"0.4929652\",\n \"0.49186552\",\n \"0.4913311\",\n \"0.49103603\",\n \"0.49054474\",\n \"0.4901659\",\n \"0.48984858\",\n \"0.48952395\",\n \"0.48903027\",\n \"0.48823473\",\n \"0.48822066\",\n \"0.4880196\",\n \"0.48785686\",\n \"0.48757115\",\n \"0.4875297\",\n \"0.4848663\",\n \"0.48457602\",\n \"0.48339862\",\n \"0.48325896\",\n \"0.4832004\",\n \"0.48289084\",\n \"0.48275638\",\n \"0.48203376\",\n \"0.48196894\",\n \"0.48138252\",\n \"0.4812278\",\n \"0.4796509\",\n \"0.4795352\",\n \"0.4790396\",\n \"0.47860554\",\n \"0.4783766\",\n \"0.47826695\",\n \"0.47792777\",\n \"0.47739163\",\n \"0.4770491\",\n \"0.47671276\",\n \"0.47661588\",\n \"0.47641256\",\n \"0.47626722\",\n \"0.47581136\",\n \"0.47579896\",\n \"0.4756379\",\n \"0.47561136\",\n \"0.47495705\",\n \"0.47453418\",\n \"0.47431073\",\n \"0.4737472\",\n \"0.47338456\",\n \"0.4732362\",\n \"0.4725343\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.56096166"},"document_rank":{"kind":"string","value":"4"}}},{"rowIdx":89896,"cells":{"query":{"kind":"string","value":"Returns a subgraph of dmrs containing only nodes with subgraph_nodeids and all the links between them."},"document":{"kind":"string","value":"def get_subgraph(dmrs, subgraph_nodeids):\n links = []\n for nodeid in subgraph_nodeids:\n node_links = dmrs.get_out(nodeid)\n for link in node_links:\n if link.end in subgraph_nodeids:\n links.append(link)\n nodes = [dmrs[nodeid] for nodeid in subgraph_nodeids]\n return DictDmrs(nodes, links)"},"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 get_subgraphs(graph):\n nodes_powerset = get_nodes_combinations(graph)\n #print(\"Doing\")\n #draw_graph(graph)\n subgraphs = []\n for nodes in nodes_powerset:\n subg = graph.subgraph(nodes)\n nodes = subg.nodes(data=True)\n if nx.is_weakly_connected(subg):\n subgraphs.append(subg)\n return subgraphs","def getSubGraphs(self):\n\n self.subGraphs = []\n visited = {}\n queue = deque()\n\n for s in self.nodes:\n\n if s not in visited:\n subGraph = SubGraph()\n self.subGraphs.append(subGraph)\n else:\n continue\n\n queue.append(s)\n\n while len (queue) > 0:\n outDegree = 0\n node = queue.popleft()\n if node in visited:\n continue\n\n for u in node.adj:\n if u not in visited:\n outDegree += 1\n queue.append(u)\n\n\n subGraph.addNode(node, outDegree)\n visited[node] = True","def get_subgraphs(self):\n if hasattr(self, 'subgraphs') is False:\n self._get_subgraphs()\n for sub in self.subgraphs:\n yield sub","def subgraph(self, nodes, relabel_nodes=False, output_device=None):\n raise NotImplementedError(\"subgraph is not implemented yet\")","def sub_graph_merging(self):","def get_subgraph(self, node,subgraph=None):\n\t\tif subgraph == None:\n\t\t\tsubgraph = nx.DiGraph(database=self.database, server=self.server, root=node)\n\t\tfor edge in self.DiG.out_edges(node):\n\t\t\t# subgraph.add_node(edge[1],{'alias':get_alias(edge[1])})\n\t\t\t# if edge[0] in subgraph:\n\t\t\t# \tprint('child node: {} already in subgraph'.format(edge[0]))\n\t\t\t# if edge[1] in subgraph:\n\t\t\t# \tprint('parent node: {} already in subgraph'.format(edge[1]))\n\t\t\t# get_alias(edge[0])\n\t\t\tsubgraph.add_edge(node, edge[1],{'Column':self.DiG.get_edge_data(*edge)['Column']})\n\t\t\tself.get_subgraph(edge[1],subgraph)\n\t\t# for node in subgraph:\n\t\t# \tsubgraph[node]['alias'] = get_alias(node)\n\t\treturn subgraph","def get_subgraph(graph, min_degree):\n ###TODO\n pass","def find_all_subgraphs(graph, match):\n if not match:\n return []\n\n return _find(graph, match, {}, match)","def create_sub_graph_copy(graph: nx.MultiDiGraph, nodes_to_extract: list):\n return graph.subgraph(nodes_to_extract).copy()","def edge_subgraph(self, edges, relabel_nodes=False, output_device=None):\n raise NotImplementedError(\"edge_subgraph is not implemented yet\")","def sub_graph_merging(self):\n raise NotImplementedError()","def get_induced_subgraph(graph, subset):\n\t\n\tgraph_edges = graph.E\n\tvertices = list(graph.V)\n\n\t# construct the induced subgraph\n\n\tnew_graph_edge = {}\n\tnew_graph_vertices = subset\n\n\tfor start in graph_edges.keys():\n\t\tif start in new_graph_vertices:\n\t\t\tfor stop in graph_edges[start]:\n\t\t\t\tif stop in new_graph_vertices:\n\t\t\t\t\t# add it to new_graph_edge\n\t\t\t\t\tif start in new_graph_edge:\n\t\t\t\t\t\tnew_graph_edge[start].append(stop)\n\t\t\t\t\telse:\n\t\t\t\t\t\tnew_graph_edge[start] = [stop]\n\n\t#print new_graph_vertices\t\t\t\t\t\n\t#print new_graph_edge\n\treturn UndirectedGraph(new_graph_vertices, new_graph_edge)","def subgraph(self, nodes_to_include=None, edges_to_include=None,\n nodes_to_exclude=None, edges_to_exclude=None):\n if nodes_to_include is None:\n node_filter_prop = self.graph.new_vertex_property(\n \"bool\", val=True)\n if nodes_to_exclude is not None:\n indices_to_exclude = [\n _get_vertex_obj(self.graph, n)\n for n in nodes_to_exclude\n ]\n for i in indices_to_exclude:\n node_filter_prop[i] = False\n else:\n node_filter_prop = self.graph.new_vertex_property(\n \"bool\", val=False)\n indices_to_include = [\n _get_vertex_obj(self.graph, n)\n for n in nodes_to_include\n ]\n for i in indices_to_include:\n node_filter_prop[i] = True\n\n if edges_to_include is None:\n edge_filter_prop = self.graph.new_edge_property(\n \"bool\", val=True)\n if edges_to_exclude is not None:\n sources = [\n _get_vertex_obj(self.graph, s)\n for s, _ in edges_to_exclude\n ]\n targets = [\n _get_vertex_obj(self.graph, t)\n for _, t in edges_to_exclude\n ]\n for s, t in zip(sources, targets):\n edge_filter_prop[self.graph.edge(s, t)] = False\n else:\n edge_filter_prop = self.graph.new_edge_property(\n \"bool\", val=False)\n sources = [\n _get_vertex_obj(self.graph, s)\n for s, _ in edges_to_include\n ]\n targets = [\n _get_vertex_obj(self.graph, t)\n for _, t in edges_to_include\n ]\n for s, t in zip(sources, targets):\n edge_filter_prop[self.graph.edge(s, t)] = True\n\n return GraphView(\n self.graph,\n vfilt=node_filter_prop,\n efilt=edge_filter_prop)","def get_subgraph_between_nodes(self, start, end):\n nodes = set()\n nodes.add(start)\n\n to_visit = set()\n to_visit.add(start)\n\n while len(to_visit) > 0:\n current_visit = copy.copy(to_visit)\n for tv in current_visit:\n to_visit.remove(tv)\n if tv is not end:\n for s in self.successors(tv):\n to_visit.add(s)\n nodes.add(s)\n\n nodes.add(end)\n\n return self.subgraph(nodes)","def _subgraph(self):\n return {\n 'type': 'SubgraphTask',\n 'id': 0,\n 'dependencies': [],\n 'parameters': {\n 'info': {},\n 'current_retries': 0,\n 'send_task_events': False,\n 'containing_subgraph': None,\n 'task_kwargs': {}\n }\n }","def strongly_connected_components_subgraphs(self):\n return [self.subgraph(_) for _ in self.strongly_connected_components()]","def build_drop_fullgraphs(self, do_subgraph=False, graph_lib='pygraphviz'):\n if 'pygraphviz' == graph_lib:\n G = pgv.AGraph(strict=True, directed=True)\n else:\n G = nx.Graph()\n do_subgraph = False\n subgraph_dict = defaultdict(list) # k - node-ip, v - a list of graph nodes\n oid_gnid_dict = dict()\n\n for i, oid in enumerate(self.pg_spec.keys()):\n oid_gnid_dict[oid] = str(i)\n logger.info(\"oid to gid mapping done\")\n\n for dropspec in self.pg_spec.itervalues():\n gid = oid_gnid_dict[dropspec['oid']]\n ip = dropspec['node']\n subgraph_dict[ip].append(gid)\n if (dropspec['type'] == 'app'):\n G.add_node(gid, shape='rect', label='')#, fixedsize=True, hight=.05, width=.05)\n elif (dropspec['type'] == 'plain'): #parallelogram\n G.add_node(gid, shape='circle', label='')#, fixedsize=True, hight=.05, width=.05)\n logger.info(\"Graph nodes added\")\n\n for dropspec in self.pg_spec.itervalues():\n gid = oid_gnid_dict[dropspec['oid']]\n if (dropspec['type'] == 'app'):\n ds_kw = 'outputs' #down stream key word\n elif (dropspec['type'] == 'plain'):\n ds_kw = 'consumers'\n else:\n ds_kw = 'None'\n if (ds_kw in dropspec):\n for doid in dropspec[ds_kw]:\n G.add_edge(gid, oid_gnid_dict[doid])\n logger.info(\"Graph edges added\")\n\n if (do_subgraph):\n for i, subgraph_nodes in enumerate(subgraph_dict.values()):\n # we don't care about the subgraph label or rank\n subgraph = G.add_subgraph(subgraph_nodes, label='%d' % i, name=\"cluster_%d\" % i, rank=\"same\")\n subgraph.graph_attr['rank']='same'\n logger.info(\"Subgraph added\")\n\n return G","def subsets(self):\n \n # note subsets have an unusual encoding\n query = \"\"\"\n prefix oboInOwl: <http://www.geneontology.org/formats/oboInOwl#>\n SELECT DISTINCT ?s WHERE {{\n GRAPH <{g}> {{\n ?c oboInOwl:inSubset ?s \n }}\n }}\n \"\"\".format(g=self.graph_name)\n bindings = run_sparql(query)\n return [r['s']['value'] for r in bindings]","def create_labeled_subgraph(graph):\n labeled_nodes = []\n for (p, d) in graph.nodes(data=True):\n if (d['leaning'] == 'R') or (d['leaning'] == 'D'):\n labeled_nodes.append(p)\n return nx.subgraph(graph, labeled_nodes)","def create_subbasin_graph():\n subbasin_to_downstream = pd.read_csv(module_dir + '/../data/simulations_shervan/test.rvh', sep='\\s+', skiprows=7, nrows=724, names=['subbasin', 'downstream_subbasin'], usecols=[1,2])\n subbasin_to_downstream['subbasin'] = subbasin_to_downstream['subbasin']\n subbasin_to_downstream['downstream_subbasin'] = 'sub' + subbasin_to_downstream['downstream_subbasin'].astype(str)\n subbasin_to_downstream['edge'] = 1\n\n for subbasin in subbasin_to_downstream['subbasin'].unique():\n is_sink = 1 if len(subbasin_to_downstream[(subbasin_to_downstream['subbasin'] == subbasin) & subbasin_to_downstream['edge'] == 1]) == 0 else 0\n subbasin_to_downstream = subbasin_to_downstream.append({'subbasin': subbasin, 'downstream_subbasin': subbasin, 'edge': is_sink}, ignore_index=True)\n subbasin_to_downstream = subbasin_to_downstream.append({'subbasin': 'sub-1', 'downstream_subbasin': 'sub-1', 'edge': 1}, ignore_index=True)\n \n adj = subbasin_to_downstream.pivot(index='subbasin', columns='downstream_subbasin', values='edge').fillna(0) \n adj = adj.sort_index(axis=0).sort_index(axis=1)\n \n G = nx.from_numpy_matrix(adj.values, parallel_edges=False, create_using=nx.DiGraph())\n label_mapping = dict(zip(range(len(adj.values)), adj.index))\n G = nx.relabel_nodes(G, label_mapping)\n \n return G","def subgraph(self, v):\n\n from pygraph.algorithms.traversal import NodeVisitor, dfs\n\n\n class Visitor(NodeVisitor):\n def __init__(self, result):\n self.result = result\n\n def visit_node(self, dg, v):\n self.result.add_node(v)\n\n def visit_edge(self, dg, v, w):\n self.result.add_edge(v, w)\n\n dg = Digraph()\n visitor = Visitor(dg)\n\n dfs(self, v, visitor)\n return dg","def semantics_subgraph(self) -> DiGraph:\n\n return self.graph.subgraph(list(self.semantics_nodes))","def subgraph_within_dates(self, start_date, end_date):\n new = Graph.graph_with_graph(self)\n for u, v in self.nx_graph.edges_iter():\n edge = new.nx_graph.edge[u][v]\n done = False\n while len(edge['timestamps']) and not done:\n top = bottom = False\n if edge['timestamps'][0] >= end_date:\n edge['timestamps'].pop(0)\n else:\n top = True\n\n if len(edge['timestamps']) and edge['timestamps'][-1] < start_date:\n edge['timestamps'].pop(-1)\n else:\n bottom = True\n\n done = top and bottom\n\n if not len(edge['timestamps']):\n new.nx_graph.remove_edge(u, v)\n\n # min = 100000000\n # max = -100000000\n # for u,v, data in new.nx_graph.edges_iter(data=True):\n # for time in data['timestamps']:\n # if time < min:\n # min = time\n # elif time > max:\n # max = time\n\n new.max_date = end_date\n new.min_date = start_date\n return new","def extract_workload_subgraphs(workload_names, ts_from, ts_to):\n ts_from = int(ts_from)\n ts_to = int(ts_to)\n\n # Getting configuration for the ApexLake Landscape\n landscape_ip = ConfigHelper.get(\"LANDSCAPE\", \"host\")\n landscape_port = ConfigHelper.get(\"LANDSCAPE\", \"port\")\n\n # Manage the extraction of the subgraph\n subgraph_extraction = SubGraphExtraction(landscape_ip=landscape_ip,\n landscape_port=landscape_port)\n res = subgraph_extraction.get_workload_view_graph(\n workload_names, int(ts_from), int(ts_to),\n name_filtering_support=True)\n\n return res","def get_subgraphs(nodes):\n subs = collections.defaultdict(dict)\n for name, node in nodes.items():\n subs[node['sg']][name] = node\n return subs","def strongly_connected_component_subgraphs(G):\n cc=strongly_connected_components(G)\n graph_list=[]\n for c in cc:\n graph_list.append(G.subgraph(c))\n return graph_list","def line_graph_forbidden_subgraphs():\n from sage.graphs.all import Graph\n from sage.graphs.generators.basic import ClawGraph\n graphs = [ClawGraph()]\n\n graphs.append(Graph({\n 0: [1, 2, 3],\n 1: [2, 3],\n 4: [2],\n 5: [3]\n }))\n\n graphs.append(Graph({\n 0: [1, 2, 3, 4],\n 1: [2, 3, 4],\n 3: [4],\n 2: [5]\n }))\n\n graphs.append(Graph({\n 0: [1, 2, 3],\n 1: [2, 3],\n 4: [2, 3]\n }))\n\n graphs.append(Graph({\n 0: [1, 2, 3],\n 1: [2, 3],\n 4: [2],\n 5: [3, 4]\n }))\n\n graphs.append(Graph({\n 0: [1, 2, 3, 4],\n 1: [2, 3, 4],\n 3: [4],\n 5: [2, 0, 1]\n }))\n\n graphs.append(Graph({\n 5: [0, 1, 2, 3, 4],\n 0: [1, 4],\n 2: [1, 3],\n 3: [4]\n }))\n\n graphs.append(Graph({\n 1: [0, 2, 3, 4],\n 3: [0, 4],\n 2: [4, 5],\n 4: [5]\n }))\n\n graphs.append(Graph({\n 0: [1, 2, 3],\n 1: [2, 3, 4],\n 2: [3, 4],\n 3: [4]\n }))\n\n return graphs","def get_subdiagrams(self, depth):\n subdiagrams = set()\n\n def get_sds_rec(node, sds, level, cur_level):\n if level == cur_level:\n return sds.union({node})\n else:\n # the children have to be sorted for some usages\n children = set()\n for child in node.child_nodes:\n children = children.union(get_sds_rec(node.child_nodes[child], sds, level, cur_level+1))\n return children\n subdiagrams = get_sds_rec(self, subdiagrams, depth, 0)\n return subdiagrams","def get_dependency_subgraphs(graph, node_attrib='label', edge_attrib='label'):\n assert nx.is_directed_acyclic_graph(graph)\n for n in xrange(graph.number_of_nodes()):\n for subnodes in itertools.combinations(graph.nodes(), n+1):\n subgraph_candidate = graph.subgraph(subnodes)\n if is_dependency_subgraph(graph, subgraph_candidate,\n node_attrib=node_attrib,\n edge_attrib=edge_attrib):\n yield subgraph_candidate","def __deepcopy__(self):\n return UndirectedGraph.extract_edge_induced_subgraph(self, lambda edge: True) # copy all edges","def get_related_edges(nodes_list, graph):\n\n node_id_list = map(lambda x: x.id, nodes_list)\n node_id_set = set(node_id_list)\n edges = []\n\n for node in nodes_list:\n if node.id in graph.incoming_edges:\n for edge in graph.incoming_edges[node.id]:\n\n if edge.start in node_id_set:\n edges.append(edge)\n\n return edges","def get_subgraph(self, agglomeration_id: np.uint64,\n bounding_box: Optional[Sequence[Sequence[int]]] = None,\n bb_is_coordinate: bool = False,\n stop_lvl: int = 1,\n get_edges: bool = False, verbose: bool = True\n ) -> Union[Tuple[np.ndarray, np.ndarray], np.ndarray]:\n # Helper functions for multithreading\n def _handle_subgraph_children_layer2_edges_thread(\n child_ids: Iterable[np.uint64]) -> Tuple[List[np.ndarray],\n List[np.float32]]:\n\n _edges = []\n _affinities = []\n for child_id in child_ids:\n this_edges, this_affinities = self.get_subgraph_chunk(\n child_id, time_stamp=time_stamp)\n _edges.extend(this_edges)\n _affinities.extend(this_affinities)\n return _edges, _affinities\n\n def _handle_subgraph_children_layer2_thread(\n child_ids: Iterable[np.uint64]) -> None:\n\n for child_id in child_ids:\n atomic_ids.extend(self.get_children(child_id))\n\n def _handle_subgraph_children_higher_layers_thread(\n child_ids: Iterable[np.uint64]) -> None:\n\n for child_id in child_ids:\n _children = self.get_children(child_id)\n\n if bounding_box is not None:\n chunk_ids = self.get_chunk_ids_from_node_ids(_children)\n chunk_ids = np.array([self.get_chunk_coordinates(c)\n for c in chunk_ids])\n chunk_ids = np.array(chunk_ids)\n\n bounding_box_layer = bounding_box / self.fan_out ** np.max([0, (layer - 3)])\n\n bound_check = np.array([\n np.all(chunk_ids < bounding_box_layer[1], axis=1),\n np.all(chunk_ids + 1 > bounding_box_layer[0], axis=1)]).T\n\n bound_check_mask = np.all(bound_check, axis=1)\n _children = _children[bound_check_mask]\n\n new_childs.extend(_children)\n\n # Make sure that edges are not requested if we should stop on an\n # intermediate level\n assert stop_lvl == 1 or not get_edges\n\n if get_edges:\n time_stamp = self.read_row(agglomeration_id, \"children\",\n get_time_stamp=True)[1]\n\n if bounding_box is not None:\n\n if bb_is_coordinate:\n bounding_box = np.array(bounding_box,\n dtype=np.float32) / self.chunk_size\n bounding_box[0] = np.floor(bounding_box[0])\n bounding_box[1] = np.ceil(bounding_box[1])\n bounding_box = bounding_box.astype(np.int)\n else:\n bounding_box = np.array(bounding_box, dtype=np.int)\n\n edges = np.array([], dtype=np.uint64).reshape(0, 2)\n atomic_ids = []\n affinities = np.array([], dtype=np.float32)\n child_ids = [agglomeration_id]\n\n time_start = time.time()\n while len(child_ids) > 0:\n new_childs = []\n layer = self.get_chunk_layer(child_ids[0])\n\n if stop_lvl == layer:\n atomic_ids = child_ids\n break\n\n # Use heuristic to guess the optimal number of threads\n n_child_ids = len(child_ids)\n this_n_threads = np.min([int(n_child_ids // 20) + 1, mu.n_cpus])\n\n if layer == 2:\n if get_edges:\n edges_and_affinities = mu.multithread_func(\n _handle_subgraph_children_layer2_edges_thread,\n np.array_split(child_ids, this_n_threads),\n n_threads=this_n_threads, debug=this_n_threads == 1)\n\n for edges_and_affinities_pair in edges_and_affinities:\n _edges, _affinities = edges_and_affinities_pair\n affinities = np.concatenate([affinities, _affinities])\n edges = np.concatenate([edges, _edges])\n else:\n mu.multithread_func(\n _handle_subgraph_children_layer2_thread,\n np.array_split(child_ids, this_n_threads),\n n_threads=this_n_threads, debug=this_n_threads == 1)\n else:\n mu.multithread_func(\n _handle_subgraph_children_higher_layers_thread,\n np.array_split(child_ids, this_n_threads),\n n_threads=this_n_threads, debug=this_n_threads == 1)\n\n child_ids = new_childs\n\n if verbose:\n print(\"Layer %d: %.3fms for %d children with %d threads\" %\n (layer, (time.time() - time_start) * 1000, n_child_ids,\n this_n_threads))\n\n # if len(child_ids) != len(np.unique(child_ids)):\n # print(\"N children %d - %d\" % (len(child_ids), len(np.unique(child_ids))))\n # # print(agglomeration_id, child_ids)\n #\n # assert len(child_ids) == len(np.unique(child_ids))\n\n time_start = time.time()\n\n atomic_ids = np.array(atomic_ids, np.uint64)\n\n if get_edges:\n return edges, affinities\n else:\n return atomic_ids","def subgraphs_of_length(self, days=None, periods=None):\n graphs = []\n if days:\n sg_length = datetime.timedelta(days=days)\n else:\n sg_length = periods\n\n start_date = self.min_date\n end_date = start_date + sg_length\n done = False\n while not done:\n if start_date > self.max_date:\n break\n if end_date > self.max_date:\n # end_date = self.max_date\n done = True\n print(start_date, end_date)\n new = self.subgraph_within_dates(start_date, end_date)\n if new.nx_graph.number_of_edges():\n graphs.append(new)\n start_date += sg_length\n end_date += sg_length\n return graphs","def _get_subgraph(entities, kb_r, multigraph_W):\n seed = np.zeros((multigraph_W.shape[0], 1))\n if not SEED_WEIGHTING:\n seed[entities] = 1. / len(set(entities))\n else:\n seed[entities] = np.expand_dims(np.arange(len(entities), 0, -1),\n axis=1)\n seed = seed / seed.sum()\n ppr = _personalized_pagerank(seed, multigraph_W)\n sorted_idx = np.argsort(ppr)[::-1]\n extracted_ents = sorted_idx[:MAX_ENT]\n extracted_scores = ppr[sorted_idx[:MAX_ENT]]\n # check if any ppr values are nearly zero\n zero_idx = np.where(ppr[extracted_ents] < 1e-6)[0]\n if zero_idx.shape[0] > 0:\n extracted_ents = extracted_ents[:zero_idx[0]]\n extracted_tuples = []\n ents_in_tups = set()\n for relation in kb_r:\n submat = kb_r[relation][extracted_ents, :]\n submat = submat[:, extracted_ents]\n row_idx, col_idx = submat.nonzero()\n for ii in range(row_idx.shape[0]):\n extracted_tuples.append(\n (extracted_ents[row_idx[ii]], relation,\n extracted_ents[col_idx[ii]]))\n ents_in_tups.add((extracted_ents[row_idx[ii]],\n extracted_scores[row_idx[ii]]))\n ents_in_tups.add((extracted_ents[col_idx[ii]],\n extracted_scores[col_idx[ii]]))\n return extracted_tuples, list(ents_in_tups)","def create_unlabeled_subgraph(graph):\n unlabeled_nodes = []\n for (p, d) in graph.nodes(data=True):\n if (d['leaning'] == 'Unknown'):\n unlabeled_nodes.append(p)\n return nx.subgraph(graph, unlabeled_nodes)","def _recv_subgraph(receiver, graph):\n # hdl is a list of ptr\n hdl = unwrap_to_ptr_list(_CAPI_ReceiverRecvSubgraph(receiver))\n return NodeFlow(graph, hdl[0])","def _subnode_ids(self):\n for ticket in self:\n ticket.subnode_ids = self.search([\n ('parent_id', '=', ticket.id),\n ('type.has_children', '=', True)])","def extract_node_induced_subgraph(self, predicate):\n # construct the filtered nodeset\n nodeset = {node.produce_duplicate_disconnected_node() for node in self.get_nodeset() if predicate(node)}\n\n G_prime = UndirectedGraph(nodeset) # create a new subgraph\n\n for edge in self.get_edges(): # for every edge in the original graph\n # if the first incident node is in the graph\n if edge.get_first_incident_node().get_name() in G_prime.get_node_names():\n # if the second incident node is also in the graph\n if edge.get_second_incident_node().get_name() in G_prime.get_node_names():\n # add the edge to the subgraph\n G_prime = UndirectedGraph.__induced_subgraph_helper(G_prime, edge)\n return G_prime # return the subgraph","def readSubgraph(graph, ctxURI):\n filename = filenameFromURI(ctxURI)\n for dateDir in os.listdir(\"graph\"):\n f = \"graph/%s/%s\" % (dateDir, filename)\n if os.path.exists(f):\n print \"readSubgraph adds\", f\n graph.parse(f, format=SUBGRAPH_FORMAT, publicID=ctxURI)","def subgraph(infr, aids):\n orig_name_labels = list(infr.gen_node_values('orig_name_label', aids))\n infr2 = AnnotInference(\n infr.ibs, aids, orig_name_labels, autoinit=False, verbose=infr.verbose\n )\n # deep copy the graph structure\n infr2.graph = infr.graph.subgraph(aids).copy()\n infr2.readonly = True\n infr2.verifiers = infr.verifiers\n infr2.ranker = infr.ranker\n\n infr.params = copy.deepcopy(infr.params)\n infr2._viz_image_config = infr._viz_image_config.copy()\n\n # infr2._viz_init_nodes = infr._viz_image_config\n # infr2._viz_image_config_dirty = infr._viz_image_config_dirty\n infr2.edge_truth = {\n e: infr.edge_truth[e] for e in infr2.graph.edges() if e in infr.edge_truth\n }\n\n # TODO: internal/external feedback\n\n infr2.nid_counter = infr.nid_counter\n infr2.dirty = True\n infr2.cm_list = None\n infr2.qreq_ = None\n\n # TODO:\n # infr2.nid_to_errors {} # = copy.deepcopy(infr.nid_to_errors)\n # infr2.recover_graph = copy.deepcopy(infr.recover_graph)\n # infr2.pos_redun_nids = copy.deepcopy(infr.pos_redun_nids)\n # infr2.neg_redun_metagraph = copy.deepcopy(infr.neg_redun_metagraph)\n\n infr2.review_graphs = {}\n for k, g in infr.review_graphs.items():\n if g is None:\n infr2.review_graphs[k] = None\n elif k == POSTV:\n infr2.review_graphs[k] = g.subgraph(aids, dynamic=True)\n else:\n infr2.review_graphs[k] = g.subgraph(aids)\n return infr2","def generateGraph(mids, chaptersField, labelsField):\n output = \"digraph G { \\n\"\n # On ne traite que les chapitres qui ont actives le graphe\n chapts = chapters.graphChapters()\n # le dico nodes contient une liste pour chaque chapitre. Chaque liste\n # contient tous les neuds (un par note) presents dans ce chapitre, et\n # representes par des tuples (noteId, label)\n nodes = {}\n for mid in mids:\n chapterField = chaptersField[mid]\n labelField = labelsField[mid]\n for id, flds in mw.col.db.execute(\"\"\"\n SELECT id, flds FROM notes WHERE mid=%d\n \"\"\" % mid):\n fields = splitFields(flds)\n chapter = fields[chapterField]\n if not chapter in chapts:\n continue\n label = fields[labelField]\n if(not chapter in nodes):\n nodes[chapter] = []\n nodes[chapter].append((id, label))\n # On genere les noeuds, dans des clusters (un par chapitre)\n notes = []\n for chap in nodes:\n output += \"\"\"subgraph cluster_%d {\n node [style=filled];\n label = \"%s\";\n color=blue;\n \"\"\" % (chapts[chap], chap)\n for n in nodes[chap]:\n output += \"\"\"n%d [label=\"%s\", URL=\"%d\"];\\n\"\"\" % (n[0], n[1], n[0])\n notes.append(n)\n output += \"\"\"\n }\\n\"\"\"\n # Puis on ajoute tous les liens ..\n for n in notes:\n for nid in mw.col.db.execute(\"\"\"SELECT N.noteId FROM `PATH.links` AS L\n JOIN `PATH.match` AS M ON M.id = L.matchId\n JOIN `PATH.nodes` AS N ON M.nodeId = N.id\n WHERE L.noteId = %d\"\"\" % (n[0])):\n output += \"\"\"n%d -> n%d;\\n\"\"\" % (nid[0], n[0])\n output += \"}\"\n generateGraphImage(output)","def subgraphs(date):\n dateDir = \"graph/%s\" % date\n if not os.path.isdir(dateDir):\n return\n for name in os.listdir(dateDir):\n filename = \"graph/%s/%s\" % (date, name)\n if filename.endswith('.uri'):\n continue\n uri, label = open(filename + \".uri\").read().split(\"\\0\")\n yield uri, label, filename","def get_nodes_to_update(subgraph, graph_name, starter=0):\n global SUBGRAPHS, PARENTS\n \n nodes = extract_nodes(subgraph)\n \n for child_subgraph in subgraph.get_subgraph_list():\n nodes += get_nodes_to_update(child_subgraph, graph_name, 1)\n \n parent = PARENTS[subgraph.get_name()].get_name()\n while(parent != graph_name and starter == 0):\n nodes += extract_nodes(PARENTS[subgraph.get_name()])\n parent = PARENTS[parent].get_name()\n return nodes","def get_reverse_slice(self, node_id, nodes_in_slice):\n node = self.nodes[node_id]\n\n for related_node_id in node['relations']:\n if self.nodes[related_node_id]['distance'] > node['distance']:\n if not nodes_in_slice.get(node_id):\n nodes_in_slice[node_id] = [related_node_id]\n else:\n nodes_in_slice[node_id].append(related_node_id)\n if not nodes_in_slice.get(related_node_id):\n nodes_in_slice[related_node_id] = []\n self.get_reverse_slice(related_node_id, nodes_in_slice)\n return nodes_in_slice","def subgraph_matching(base_graph, subgraph, matches, validate=False):\n final_subgraphs = []\n initial_sg = _create_initial_subgraph(matches,\n base_graph,\n subgraph,\n validate)\n if not initial_sg:\n LOG.warning('subgraph_matching:Initial sub-graph creation failed')\n LOG.warning('subgraph_matching: Known matches: %s', matches)\n return final_subgraphs\n queue = [initial_sg]\n\n while queue:\n curr_subgraph = queue.pop(0)\n\n # STEP 1: STOPPING CONDITION\n mapped_vertices = list(filter(\n lambda v: v.get(MAPPED_V_ID),\n curr_subgraph.get_vertices()))\n if len(mapped_vertices) == subgraph.num_vertices():\n final_subgraphs.append(curr_subgraph)\n continue\n\n # STEP 2: CAN WE THROW THIS SUB-GRAPH?\n vertices_with_unmapped_neighbors = list(filter(\n lambda v: not v.get(NEIGHBORS_MAPPED),\n mapped_vertices))\n if not vertices_with_unmapped_neighbors:\n continue\n\n # STEP 3: FIND A SUB-GRAPH VERTEX TO MAP\n v_with_unmapped_neighbors = _choose_vertex(\n vertices_with_unmapped_neighbors,\n curr_subgraph)\n\n unmapped_neighbors = list(filter(\n lambda v: not v.get(MAPPED_V_ID),\n curr_subgraph.neighbors(v_with_unmapped_neighbors.vertex_id)))\n if not unmapped_neighbors:\n # Mark vertex as NEIGHBORS_MAPPED=True\n v_with_unmapped_neighbors[NEIGHBORS_MAPPED] = True\n curr_subgraph.update_vertex(v_with_unmapped_neighbors)\n queue.append(curr_subgraph)\n continue\n subgraph_vertex_to_map = _choose_vertex(\n unmapped_neighbors,\n curr_subgraph,\n curr_v=v_with_unmapped_neighbors)\n\n # STEP 4: PROPERTIES CHECK\n graph_candidate_vertices = base_graph.neighbors(\n v_id=v_with_unmapped_neighbors[MAPPED_V_ID],\n vertex_attr_filter=subgraph_vertex_to_map)\n\n graph_candidate_vertices = \\\n _remove_used_graph_candidates(graph_candidate_vertices,\n curr_subgraph)\n\n # STEP 5: STRUCTURE CHECK\n edges = _get_edges_to_mapped_vertices(curr_subgraph,\n subgraph_vertex_to_map.vertex_id)\n neg_edges = set(e for e in edges if e.get(NEG_CONDITION))\n pos_edges = edges.difference(neg_edges)\n\n if not graph_candidate_vertices and neg_edges and not pos_edges:\n subgraph_vertex_to_map[MAPPED_V_ID] = NEG_VERTEX\n curr_subgraph.update_vertex(subgraph_vertex_to_map)\n queue.append(curr_subgraph)\n continue\n\n found_subgraphs = []\n remaining_items = len(graph_candidate_vertices)\n for graph_vertex in graph_candidate_vertices:\n subgraph_vertex_to_map[MAPPED_V_ID] = graph_vertex.vertex_id\n subgraph_vertex_to_map[GRAPH_VERTEX] = graph_vertex\n curr_subgraph.update_vertex(subgraph_vertex_to_map)\n if not _graph_contains_subgraph_edges(base_graph,\n curr_subgraph,\n pos_edges):\n continue\n if not _graph_contains_subgraph_edges(base_graph,\n curr_subgraph,\n neg_edges):\n del found_subgraphs[:]\n break\n if neg_edges and not pos_edges:\n subgraph_vertex_to_map[MAPPED_V_ID] = NEG_VERTEX\n curr_subgraph.update_vertex(subgraph_vertex_to_map)\n\n remaining_items -= 1 # no need to copy the last one\n found_subgraphs.append(\n curr_subgraph.copy() if remaining_items else curr_subgraph)\n\n queue.extend(found_subgraphs)\n\n # Last thing: Convert results to the expected format!\n return _generate_result(final_subgraphs)","def extract_edge_induced_subgraph(self, predicate):\n # initialize the new nodeset as sets containing disconnected copies of the original nodes\n nodeset = {node.produce_duplicate_disconnected_node() for node in self.get_nodeset()}\n\n # create a null graph using the nodeset constructed above\n G_prime = UndirectedGraph(nodeset)\n\n # for every edge in the original graph\n for edge in self.get_edges():\n if predicate(edge): # if the edge is not filtered out\n G_prime = UndirectedGraph.__induced_subgraph_helper(G_prime, edge)\n\n return G_prime # return the subgraph","def test_restore_multiple_in_subgraph(self):\n subgraph = self._subgraph()\n subgraph['id'] = 15\n task1 = self._remote_task()\n task1['id'] = 1\n task2 = self._remote_task()\n task2['id'] = 2\n task1['parameters']['containing_subgraph'] = 15\n task2['parameters']['containing_subgraph'] = 15\n\n graph = self._restore_graph([subgraph, task1, task2])\n assert len(graph.tasks) == 3\n subgraphs = [op for op in graph.tasks if op.is_subgraph]\n remote_tasks = [op for op in graph.tasks if not op.is_subgraph]\n\n # those are all references to the same subgraph, the subgraph was\n # NOT restored multiple times\n assert remote_tasks[0].containing_subgraph \\\n is remote_tasks[1].containing_subgraph \\\n is subgraphs[0]\n\n assert len(subgraphs[0].tasks) == 2","def FeynmanSubgraphs(graph, model):\n model.SetTypes(graph)\n model.checktadpoles = False\n graph.FindSubgraphs(model)\n\n subs_toremove = subgraphs.DetectSauseges(graph._subgraphs)\n graph.RemoveSubgaphs(subs_toremove)\n\n subgraphs.RemoveTadpoles(graph)","def test_prune_dnnl_subgraph(run_module):\n\n def get_graph():\n x1 = relay.var(\"x1\", shape=(1, 32, 56, 56))\n x2 = relay.var(\"x2\", shape=(1, 32, 56, 56))\n bias = relay.var(\"bias\", shape=(32,))\n weight = relay.var(\"weight\", shape=(32, 32, 3, 3))\n y = relay.nn.conv2d(\n x1,\n weight,\n channels=32,\n kernel_size=(3, 3),\n padding=(1, 1),\n )\n y = relay.nn.bias_add(y, bias)\n y = relay.nn.relu(y)\n y = relay.nn.global_max_pool2d(y)\n y = relay.add(y, x2)\n dic = {\n \"x1\": (1, 32, 56, 56),\n \"x2\": (1, 32, 56, 56),\n \"weight\": (32, 32, 3, 3),\n \"bias\": (32,),\n }\n param_lst = [\"weight\", \"bias\"]\n out = tvm.IRModule.from_expr(y)\n return out, dic, param_lst\n\n run_and_verify_func(get_graph(), subgraph_num=1, run_module=run_module, test_bf16=False)","def allGraphs(date):\n g = getGraph()\n for uri, label, filename in subgraphs(date):\n if not label:\n label = \"(no label provided)\"\n g.parse(filename, format=SUBGRAPH_FORMAT)\n return g","def add_subgraph(self, subgraph, prefix):\n for ntype in subgraph.get_types():\n new_nodes = subgraph.get_node_list(ntype)\n for node in new_nodes:\n node.ext_id = node_id(prefix, node.ext_id)\n self.add_node_list(ntype, new_nodes)","def get_subnodes(self) -> List[SubNode]:\n\t\t# Get all SubNodes\n\t\tsubnode_holder = NodeSubNodeHolder()\n\t\tfor rootnode in self.root_nodes:\n\t\t\tfor subnode in rootnode.get_subnodes():\n\t\t\t\tsubnode_holder.add_subnode(subnode)\n\n\t\t# Return\n\t\treturn subnode_holder.get_subnodes()","def show_subgraph(dfs_codes, nsupport, mapper):\n\tglobal __subgraph_count\n\n\tg = build_graph(dfs_codes)\n\tg.id = __subgraph_count\n\t__subgraph_count += 1\n\tg.gprint(nsupport, mapper)","def _all_subnodes(self):\n return self.__dict__.values()","def to_undirected_graph(self):\n visited = set() \n G = Graph.Graph()\n \n for node in self.node_set:\n \n if node not in visited:\n visited.add(node)\n for i in self.suffix[node]:\n G.add_edge(node, i)\n \n return G","def _generate_subgraph_sql_parts(self, node, subgraph, i=0,colNames=None,sql=None):\n\t\treferencesPersonFact = False\n\t\tif i == 0:\n\t\t\tsql=[]\n\t\t\tcolNames=[]\n\t\t\t# print('\\nSELECT *\\nFROM {}'.format(node))\n\t\tfor edge in subgraph.out_edges(node):\n\t\t\t# print('\\tedge: {}->{} {}'.format(*edge,subgraph.get_edge_data(*edge)))\n\t\t\tcolNames.append('{}.{}'.format(edge[0],subgraph.get_edge_data(*edge)['Column']))\n\t\t\t# print('{}LEFT JOIN {}\\n{}ON {}.{}={}.{}'.format('\\t'*i,edge[1],'\\t'*i,edge[1],subgraph.get_edge_data(*edge)['Column'],edge[0],subgraph.get_edge_data(*edge)['Column']))\n\t\t\tsql.append('{}LEFT JOIN {}\\n{}ON {}.{}={}.{}'.format('\\t'*i,edge[1],'\\t'*i,edge[1],subgraph.get_edge_data(*edge)['Column'],edge[0],subgraph.get_edge_data(*edge)['Column']))\n\t\t\tself._generate_subgraph_sql_parts(edge[1],subgraph,i+1,colNames,sql)\n\t\t\tif 'dbo.PersonFact' in edge[0] or 'dbo.PersonFact' in edge[1]:\n\t\t\t\treferencesPersonFact = True\n\t\t# print('_generate_subgraph_sql_parts')\n\t\t# if referencesPersonFact and 'CommunityMart.dbo.PersonFact.PatientID' not in colNames:\n\t\t\t# colNames.append('CommunityMart.dbo.PersonFact.PatientID')\n\t\t# remove colNames of already in leaf table\n\t\tnet_new_colNames = []\n\t\tfor colName in colNames:\n\t\t\tif node not in colName:\n\t\t\t\tnet_new_colNames.append(colName)\n\t\treturn net_new_colNames,sql","def flat_graph(self) -> dict:\n return self.pgnode.flat_graph()","def single_source_subgraph(g, node):\n return g.subgraph(nx.single_source_shortest_path(g, node).keys())","def subgraph(self, name):\n\n self._compiled = None\n sub = Graph()\n self.graph[name] = sub\n return sub","def shrink(subgraph: list, graph: nx.Graph) -> list:\r\n\r\n if not utils.is_subgraph(subgraph, graph):\r\n raise ValueError(\"Input is not a valid subgraph\")\r\n\r\n subgraph = graph.subgraph(subgraph).copy() # A copy is required to be able to modify the\r\n # structure of the subgraph (https://networkx.github.io/documentation/stable/reference/classes/generated/networkx.Graph.subgraph.html)\r\n\r\n while not utils.is_clique(subgraph):\r\n degrees = list(subgraph.degree())\r\n np.random.shuffle(degrees) # used to make sure selection of node with lowest degree is not\r\n # deterministic in case of a tie (https://docs.python.org/3/library/functions.html#min)\r\n\r\n to_remove = min(degrees, key=lambda x: x[1])\r\n subgraph.remove_node(to_remove[0])\r\n\r\n return sorted(subgraph.nodes())","def test_restore_with_subgraph(self):\n subgraph = self._subgraph()\n task = self._remote_task()\n subgraph['id'] = 15\n task['parameters']['containing_subgraph'] = 15\n\n graph = self._restore_graph([subgraph, task])\n assert len(graph.tasks) == 2\n subgraphs = [op for op in graph.tasks if op.is_subgraph]\n remote_tasks = [op for op in graph.tasks if not op.is_subgraph]\n\n assert len(subgraphs) == 1\n assert len(remote_tasks) == 1\n\n assert len(subgraphs[0].tasks) == 1\n assert remote_tasks[0].containing_subgraph is subgraphs[0]","def subgraph(index, query, length=50):\n\n \n # get vertex ids\n proxs = {}\n pzeros = []\n for q in query:\n if q['form'] in ('', None):\n raise WrongQueryError(\"Un mot doit être sasie pour effectuer une recherche.\") \n \n result = extract(index, q, 500)\n if not len(result): \n raise WrongQueryError(u\"Aucun résultat pour le mot '%s'.\" % q['form']) \n\n p0, vect = result.keys()[0], result.values()[0]\n for k,v in vect:\n proxs[k] = proxs.get(k,0.) + v;\n pzeros.append(p0)\n \n proxs = proxs.items()\n proxs.sort(key=lambda x : x[1], reverse=True)\n proxs = dict(proxs[:length])\n \n ids = proxs.keys()\n # request es with ids\n res = search_docs(index, query[0]['graph'], ids)\n # convert res to docs\n docs = to_docs(res, pzeros)\n \n docs.sort(key=lambda x : proxs[x.docnum], reverse=True)\n \n \n # build graph from docs\n graph = to_graph(docs)\n \n return graph","def di_subgraph(self, nbunch):\n\t\t\n\t\t# create new subgraph.\n\t\tg = nx.DiGraph()\n\t\t\n\t\t# add edges and nodes.\n\t\tg.add_edges_from( self.edges(nbunch=nbunch) )\n\t\t\n\t\treturn g","def subgraph(self, subset_dict: Dict[NodeType, Tensor]) -> 'HeteroData':\n data = copy.copy(self)\n subset_dict = copy.copy(subset_dict)\n\n for node_type, subset in subset_dict.items():\n for key, value in self[node_type].items():\n if key == 'num_nodes':\n if subset.dtype == torch.bool:\n data[node_type].num_nodes = int(subset.sum())\n else:\n data[node_type].num_nodes = subset.size(0)\n elif self[node_type].is_node_attr(key):\n data[node_type][key] = value[subset]\n else:\n data[node_type][key] = value\n\n for edge_type in self.edge_types:\n src, _, dst = edge_type\n\n src_subset = subset_dict.get(src)\n if src_subset is None:\n src_subset = torch.arange(data[src].num_nodes)\n dst_subset = subset_dict.get(dst)\n if dst_subset is None:\n dst_subset = torch.arange(data[dst].num_nodes)\n\n edge_index, _, edge_mask = bipartite_subgraph(\n (src_subset, dst_subset),\n self[edge_type].edge_index,\n relabel_nodes=True,\n size=(self[src].num_nodes, self[dst].num_nodes),\n return_edge_mask=True,\n )\n\n for key, value in self[edge_type].items():\n if key == 'edge_index':\n data[edge_type].edge_index = edge_index\n elif self[edge_type].is_edge_attr(key):\n data[edge_type][key] = value[edge_mask]\n else:\n data[edge_type][key] = value\n\n return data","def create_subsets(self, start_ids):\n subsets = list()\n df = self.all_df.copy()\n for sid in start_ids:\n df2 = df.loc[sid:, :]\n subsets.append(df.drop(df2.index, axis=0))\n df = df2.copy()\n subsets.append(df)\n return subsets","def get_subdiagrams_grouped_by_level(self):\n subds = []\n\n def get_subds_gbl_rec(node, level):\n \"\"\"\n The recursive call\n \"\"\"\n try:\n subds[level] = subds[level].union({node})\n except IndexError:\n subds.append({node})\n if not isinstance(node, Leaf):\n for child in node.child_nodes:\n get_subds_gbl_rec(node.child_nodes[child][0], level+1)\n\n get_subds_gbl_rec(self, 0)\n return subds","def _get_edges_to_mapped_vertices(graph, vertex_id):\n subgraph_edges_to_mapped_vertices = []\n for e in graph.get_edges(vertex_id):\n t_neighbor = graph.get_vertex(e.other_vertex(vertex_id))\n if not t_neighbor:\n raise VitrageAlgorithmError('Cant get vertex for edge %s' % e)\n if t_neighbor and t_neighbor.get(MAPPED_V_ID):\n subgraph_edges_to_mapped_vertices.append(e)\n return set(subgraph_edges_to_mapped_vertices)","def get_stable_subgraph(self):\n if not self._fitted:\n raise NotFittedError()\n nbunch = []\n for node in self.nodes_iter():\n if len(node) == self._max_length:\n nbunch.append(node)\n return self.subgraph(nbunch)","def _get_full_graph(self):","def generate_subgraph(format):\n\n # get business information\n directorypath = genpath+directory\n if os.path.isfile(directorypath):\n \n bizdata = pd.read_csv( directorypath, escapechar='\\\\')\n\n #create a directory of page-id and object-ids\n tempdf = bizdata.set_index('pageid')\n tempdf = tempdf['objectid']\n dictionary = tempdf.to_dict()\n\n uncgraph = pd.read_csv(inpath+graphfile, escapechar='\\\\')\n uncgraph = uncgraph.dropna()\n uncgraph['likee_object_id'] = uncgraph.apply(lambda x: dictionary.get(x['likee_page_id']), axis=1)\n cgraph = uncgraph.dropna()\n cgraph = cgraph[['liker_page_id', 'likee_page_id']]\n cgraph.columns = ['Source', 'Target']\n\n \n print_stats(cgraph)\n if format == 'networkx' :\n print \"[Generating a networkX graph...]\" \n cgraph.to_csv(genpath+subgraph+'.ntx', index=False, header=False, sep= ' ')\n else:\n print \"[Generating a csv graph...]\" \n cgraph.to_csv(genpath+subgraph+'.csv', index=False)\n\n\n else:\n print \"Either file is missing or is not readable\"","def get_child_ids(id,conn):\n\n child_ids = ('WITH RECURSIVE children AS '\n '(SELECT subject_id '\n 'FROM cvterm_relationship '\n 'WHERE object_id = %s '\n 'UNION '\n 'SELECT cr.subject_id '\n 'FROM cvterm_relationship cr '\n 'INNER JOIN children ch ON ch.subject_id = cr.object_id) '\n 'SELECT * FROM children')\n ids = connect(child_ids,id,conn)\n list_of_ids = []\n for item in ids:\n list_of_ids.append(item[0])\n return(list_of_ids)","def is_subgraph_of(self, other):\n # If it is already recognized that it is a subgraph this procedure can be skipped.\n if other in self.__supergraph :\n return True\n \n if type(self)!=type(other):\n raise TypeError(\"Only works between graphs.\")\n elif other.return_num_vertices() == 0:\n return False\n elif self.return_num_vertices() == 0:\n return True\n names_to_check = self.return_names()\n # Checks if the vertices are a subset\n if not set(names_to_check).issubset(set(other.return_names())):\n return False\n \n # Traverses each node and checks if the adjacencies build a subset.\n # To do so, the node indices must be replaced by node names.\n # This is laborious, but only needs to be done once.\n for name in names_to_check:\n selflist = set(map(lambda x: (self.return_vertexName(x[0]),x[1]), self.return_adjacencies(self.return_vertexIndex(name))))\n otherlist = set(map(lambda x: (other.return_vertexName(x[0]),x[1]), other.return_adjacencies(other.return_vertexIndex(name))))\n if not selflist.issubset(otherlist):\n return False\n self.__supergraph.append(other)\n \n return True","def test_extract_graph(default_plugin_resolver):\n dpr = default_plugin_resolver\n nx_graph = nx.Graph()\n nx_graph.add_weighted_edges_from(\n [(1, 0, 2), (1, 4, 3), (2, 5, 5), (2, 7, 6), (3, 1, 7), (5, 6, 10), (6, 2, 11),]\n )\n desired_nodes = {2, 5, 6}\n nx_extracted_graph = nx.Graph()\n nx_extracted_graph.add_weighted_edges_from([(2, 5, 5), (5, 6, 10), (6, 2, 11)])\n graph = dpr.wrappers.Graph.NetworkXGraph(nx_graph)\n desired_nodes_wrapped = dpr.wrappers.NodeSet.PythonNodeSet(desired_nodes)\n extracted_graph = dpr.wrappers.Graph.NetworkXGraph(nx_extracted_graph)\n MultiVerify(\n dpr, \"subgraph.extract_subgraph\", graph, desired_nodes_wrapped\n ).assert_equals(extracted_graph)","def get_descendants(self, node, triples, ignore=\"^(rel_|frame_)\"):\n children = defaultdict(list) # parent id : [child ids]\n inrelation = set() # ids of all nodes in a relation\n for s, p, o in triples:\n s, o = int(s.id), int(o.id)\n if p.startswith(\"rel_\"):\n children[o].append(s)\n elif not re.match(ignore, p):\n inrelation |= {s, o}\n seen = set()\n def getnodes(n):\n if n in seen:\n return\n seen.add(n)\n yield n\n for c in children[n]:\n if c not in inrelation:\n for n2 in getnodes(c):\n yield n2\n return getnodes(node)","def subsample_graph(graph, max_degree,\n rng):\n edges = sampler.get_adjacency_lists(graph)\n edges = sampler.sample_adjacency_lists(edges, graph.train_nodes, max_degree,\n rng)\n senders = []\n receivers = []\n for u in edges:\n for v in edges[u]:\n senders.append(u)\n receivers.append(v)\n\n graph.senders = senders\n graph.receivers = receivers\n return graph","def get_subnodes(self) -> List[SubNode]:\n\t\treturn sorted(self.subnodes, key=lambda x: attrib_key(x.name))","def edges_to_boundary(edges):\n graph = nx.from_edgelist(edges)\n # import matplotlib.pyplot as plt\n # plt.subplot(111)\n # nx.draw(graph, with_labels=True, font_weight='bold')\n # plt.show()\n\n sub_graphs = [graph.subgraph(c).copy() for c in nx.connected_components(graph)]\n sub_graphs_path = list()\n for sub_graph in sub_graphs:\n sub_graph_nodes = list(sub_graph.nodes)\n paths = sorted(list(nx.all_simple_paths(sub_graph, source=sub_graph_nodes[0], target=sub_graph_nodes[1])), key=len, reverse=True)\n sub_graphs_path.append(paths[0])\n\n return sorted(sub_graphs_path, key=len)","def _subgraph_isomorphism_matcher(digraph, nxpattern, node_pred, edge_pred):\n graph_matcher = iso.DiGraphMatcher(digraph, nxpattern, node_match=node_pred, edge_match=edge_pred)\n yield from graph_matcher.subgraph_isomorphisms_iter()","def get_induced_subgraph(graph: Graph, nodes: Nodes):\n return {node: graph[node].intersection(nodes) for node in nodes}","def find_subgraph(node, graph, draw_graph=True, save_graph=False):\r\n\r\n try:\r\n stack = [node]\r\n\r\n # the list that stores the nodes\r\n result = []\r\n\r\n while stack:\r\n for i in graph.edges():\r\n if stack[0] == i[0]:\r\n result.append(i)\r\n stack.append(i[1])\r\n stack.pop(0)\r\n\r\n # build the new graph\r\n n = nx.Graph()\r\n n.add_edges_from(result)\r\n\r\n # draw the graph\r\n if draw_graph:\r\n nx.draw_networkx(n)\r\n plt.show()\r\n \r\n if save_graph:\r\n return n\r\n\r\n except:\r\n print(\"The node you are looking for is not in the graph. Try again\")","def __induced_subgraph_helper(G, edge):\n first_incident_node = \\\n GraphProcessing.search_node_names(\n G.get_nodeset(),\n edge.get_first_incident_node().get_name()\n ).pop() # obtain the disconnected copy of the first incident node\n\n second_incident_node = \\\n GraphProcessing.search_node_names(\n G.get_nodeset(),\n edge.get_second_incident_node().get_name()\n ).pop() # obtain the disconnected copy of the second incident node\n\n G.add_edge(\n edge.get_weight(),\n dict(edge.get_attributes()),\n first_incident_node,\n second_incident_node\n ) # create and add the duplicate edge to the subgraph\n\n return G","def draw_relation_graph(database_name, table_name, primary_key, group_name) -> Graph:\n\n nodes = []\n links = []\n disease_list = get_icd_diseasegroup_diseaseinfo(database_name, table_name, primary_key, group_name)[1]\n disease_list = disease_list.split(',')\n # print(disease_list)\n\n for disease in disease_list:\n disease_node = {\n \"name\": disease,\n \"symbolSize\": 50\n }\n\n if disease_node not in nodes:\n nodes.append(disease_node)\n\n gene_list = get_mesh_disease_info(database_name, 'mesh_gene', disease, 'DISEASE_ID')[1]\n gene_list = gene_list.split(',')\n for gene in gene_list:\n gene_node = {\n 'name': gene,\n 'symbolSize': 10\n }\n\n if gene_node not in nodes:\n nodes.append(gene_node)\n\n for gene in gene_list:\n links.append({\"source\": disease, \"target\": gene})\n\n print(nodes)\n print(links)\n\n c = (\n Graph(init_opts=opts.InitOpts(width=\"1440px\", height=\"900px\")).add(\"\", nodes, links, repulsion=3000)\n .set_global_opts(title_opts=opts.TitleOpts(title=\"gene-disease association network\"))\n )\n\n return c","def merge_graphs(\n graph: DiGraph,\n ) -> Tuple[list[str], GraphAccess, Generator[Tuple[str, GraphAccess], None, None]]:\n\n # Find merge nodes: all nodes that are marked as merge node -> all children (merge roots) should be merged.\n # This method returns all merge roots as key, with the respective predecessor nodes as value.\n def merge_roots() -> dict[str, set[str]]:\n graph_root = GraphAccess.root_id(graph)\n merge_nodes = [node_id for node_id, data in graph.nodes(data=True) if data.get(\"merge\", False)]\n assert len(merge_nodes) > 0, \"No merge nodes provided in the graph. Mark at least one node with merge=true!\"\n result: dict[str, set[str]] = {}\n for node in merge_nodes:\n # compute the shortest path from root to here and sort out all successors that are also predecessors\n pres: set[str] = reduce(lambda res, p: res | set(p), all_shortest_paths(graph, graph_root, node), set())\n for a in graph.successors(node):\n if a not in pres:\n result[a] = pres\n return result\n\n # Walk the graph from given starting node and return all successors.\n # A successor which is also a predecessor is not followed.\n def sub_graph_nodes(from_node: str, parent_ids: set[str]) -> set[str]:\n to_visit = [from_node]\n visited: set[str] = {from_node}\n\n def successors(node: str) -> list[str]:\n return [a for a in graph.successors(node) if a not in visited and a not in parent_ids]\n\n while to_visit:\n to_visit = reduce(lambda li, node: li + successors(node), to_visit, [])\n visited.update(to_visit)\n return visited\n\n # Create a generator for all given merge roots by:\n # - creating the set of all successors\n # - creating a subgraph which contains all predecessors and all succors\n # - all predecessors are marked as visited\n # - all predecessor edges are marked as visited\n # This way it is possible to have nodes in the graph that will not be touched by the update\n # while edges will be created from successors of the merge node to predecessors of the merge node.\n def merge_sub_graphs(\n root_nodes: dict[str, set[str]], parent_nodes: set[str], parent_edges: set[Tuple[str, str, str]]\n ) -> Generator[Tuple[str, GraphAccess], None, None]:\n all_successors: Set[str] = set()\n for root, predecessors in root_nodes.items():\n successors: set[str] = sub_graph_nodes(root, predecessors)\n # make sure nodes are not \"mixed\" between different merge nodes\n overlap = successors & all_successors\n if overlap:\n raise AttributeError(f\"Nodes are referenced in more than one merge node: {overlap}\")\n all_successors |= successors\n # create subgraph with all successors and all parents, where all parents are already marked as visited\n sub = GraphAccess(graph.subgraph(successors | parent_nodes), root, parent_nodes, parent_edges)\n yield root, sub\n\n roots = merge_roots()\n parents: set[str] = reduce(lambda res, ps: res | ps, roots.values(), set())\n parent_graph = graph.subgraph(parents)\n graphs = merge_sub_graphs(roots, parents, set(parent_graph.edges(data=\"edge_type\")))\n return list(roots.keys()), GraphAccess(parent_graph, GraphAccess.root_id(graph)), graphs","def get_subgraph_from_paths(self, paths):\n nodes, edges = graph_elements_from_paths(paths)\n subgraph = self.graph.subgraph(nodes).edge_subgraph(edges)\n return subgraph","def reverse_graph(self):\n rgraph = DGraph()\n rgraph.graph = deepcopy(self.graph)\n\n for node in rgraph.graph:\n node.data.children, node.data.parents = node.data.parents, node.data.children\n\n return rgraph","def ExtractSubmatrix(adjmatrix, nodelist1, nodelist2=[]):\n # 0) CHECK WHETHER LISTS OF NODES ARE GIVEN AS ARRAYS. OTHERWISE, CONVERT.\n # Check nodelist1\n if type(nodelist1) != np.ndarray:\n # warnings.simplefilter('once', UserWarning)\n # warnings.warn(\"Prefered type for parameter 'nodelist1' is numpy.ndarray. Lists, tuples and sets are allowed but are converted to ndarrays.\", \\\n # stacklevel=2)\n\n if type(nodelist1) == set:\n nodelist1 = list(nodelist1)\n if type(nodelist1) in [list, tuple]:\n nodelist1 = np.array(nodelist1,np.int)\n\n # Check nodelist2\n if len(nodelist2) == 0:\n nodelist2 = nodelist1.copy()\n else:\n if type(nodelist2) != np.ndarray:\n # warnings.simplefilter('once', UserWarning)\n # warnings.warn(\"Prefered type for parameter 'nodelist2' is numpy.ndarray. Lists, tuples and sets are allowed but are converted to ndarrays.\", \\\n # stacklevel=2)\n\n if type(nodelist2) == set:\n nodelist2 = list(nodelist2)\n if type(nodelist2) in [list, tuple]:\n nodelist2 = np.array(nodelist2,np.int)\n\n # 1) CREATE LISTS OF INDICES FOR SLICING\n N1 = len(nodelist1)\n N2 = len(nodelist2)\n xindices = np.zeros(N1*N2, np.int)\n for ncounter, node in enumerate(nodelist1):\n startidx = ncounter*N2\n endidx = startidx + N2\n xindices[startidx:endidx] = node\n\n yindices = np.zeros(N1*N2, np.int)\n for n in range(N1):\n startidx = n*N2\n endidx = startidx + N2\n yindices[startidx:endidx] = nodelist2\n\n # 2) EXTRACT THE SUBMATRIX AND FINISH\n return adjmatrix[xindices, yindices].reshape(N1, N2)","def subgroups(self):\n db = self['__store'].db\n my_subgroups = {\n group_id\n for group_id, in db(\"\"\"\n select distinct\n subgroup_id\n from subgroups, groups\n where\n id = group_id\n and group_id = %s\n and groups.type = 'U'\n \"\"\",\n self._id)\n }\n return my_subgroups","def parse_subgraph(subgraph_nodes, graph, ass_matrix):\n\n sg = graph.subgraph(subgraph_nodes)\n sg_adj = nx.to_scipy_sparse_matrix(sg, format='csc') # New adjacency matrix.\n sg_ass = ass_matrix[list(sg.nodes)]\n\n return sg_adj, sg_ass","def test_documentation_popxl_create_multi_subgraph(self):\n filename = \"create_multi_graphs_from_same_func.py\"\n self.run_python(filename, file_dir=working_dir, working_dir=working_dir)","def _format_subgraph_dihedral(m, top):\n (sort_by_n_connections, small) = _get_sorted_by_n_connections(m)\n start = sort_by_n_connections[0]\n if sort_by_n_connections[2] in small.neighbors(start):\n mid1 = sort_by_n_connections[2]\n mid2 = sort_by_n_connections[3]\n else:\n mid1 = sort_by_n_connections[3]\n mid2 = sort_by_n_connections[2]\n\n end = sort_by_n_connections[1]\n return (\n top.get_index(start),\n top.get_index(mid1),\n top.get_index(mid2),\n top.get_index(end),\n )","def _filter_edges(self, edges_filtered):\n return [\n edge\n for edge in edges_filtered\n if edge[0] in self.nodes_ids and edge[1] in self.nodes_ids\n ]","def extract_edges(graph):\n return graph.get_edges()","def subgraph_is_isomorphic(graph, subgraph):\n graph_gspan = networkx_to_gspan(graph, 0)\n subgraph_gspan = networkx_to_gspan(subgraph, 1)\n\n # create temporary files during gspan processing\n input_fd, input_filename = tempfile.mkstemp()\n output_fd, output_filename = tempfile.mkstemp()\n\n with os.fdopen(input_fd, 'w', encoding='utf-8') as input_handler:\n input_handler.write(graph_gspan + subgraph_gspan)\n orig_stdout = sys.stdout\n sys.stdout = os.fdopen(output_fd, 'w', encoding='utf-8')\n subgraph_miner = gSpan(input_filename, 2, where=True)\n subgraph_miner.run()\n sys.stdout = orig_stdout\n mined_subgraphs = parse_mined_gspan_file(output_filename)\n\n # remove temporary files\n os.remove(input_filename)\n os.remove(output_filename)\n\n em = iso.numerical_edge_match('weight', 0)\n nm = iso.categorical_node_match('name', None)\n for mined_subgraph in mined_subgraphs:\n graph_matcher = iso.GraphMatcher(mined_subgraph, subgraph, node_match=nm, edge_match=em)\n if graph_matcher.is_isomorphic():\n return True\n return False","def nodegraph(self):\n return self._nodegraph","def subsets(self, sub_ids, sub_args_lst=None):\n\n indices = [[self.ids.index(id_) for id_ in ids] for ids in sub_ids]\n if sub_args_lst is not None:\n subsets = [Subset(dataset=self, indices=index, sub_attrib_args=args)\n for index, args in zip(indices, sub_args_lst)]\n else:\n subsets = [Subset(dataset=self, indices=index) for index in indices]\n return subsets","def sub_set(self, idcs):\n return SubSet(dset=self, idcs=idcs)","def dump_subgraph_for_debug(self):\n\n import pypipegraph2 as ppg\n\n nodes = []\n seen = set()\n edges = []\n counter = [0]\n node_to_counters = {}\n\n def descend(node):\n if node in seen:\n return\n seen.add(node)\n j = self.runner.jobs[node]\n if isinstance(j, ppg.FileInvariant):\n nodes.append(f\"Path('{counter[0]}').write_text('A')\")\n nodes.append(f\"job_{counter[0]} = ppg.FileInvariant('{counter[0]}')\")\n elif isinstance(j, ppg.ParameterInvariant):\n nodes.append(\n f\"job_{counter[0]} = ppg.ParameterInvariant('{counter[0]}', 55)\"\n )\n elif isinstance(j, ppg.FunctionInvariant):\n nodes.append(\n f\"job_{counter[0]} = ppg.FunctionInvariant('{counter[0]}', lambda: 55)\"\n )\n elif isinstance(j, ppg.SharedMultiFileGeneratingJob):\n nodes.append(\n f\"job_{counter[0]} = ppg.SharedMultiFileGeneratingJob('{counter[0]}', {[x.name for x in j.files]!r}, dummy_smfg, depend_on_function=False)\"\n )\n elif isinstance(j, ppg.TempFileGeneratingJob):\n nodes.append(\n f\"job_{counter[0]} = ppg.TempFileGeneratingJob('{counter[0]}', dummy_fg, depend_on_function=False)\"\n )\n elif isinstance(j, ppg.FileGeneratingJob):\n nodes.append(\n f\"job_{counter[0]} = ppg.FileGeneratingJob('{counter[0]}', dummy_fg, depend_on_function=False)\"\n )\n elif isinstance(j, ppg.MultiTempFileGeneratingJob):\n files = [counter[0] + \"/\" + x.name for x in j.files]\n nodes.append(\n f\"job_{counter[0]} = ppg.MultiTempFileGeneratingJob({files!r}, dummy_mfg, depend_on_function=False)\"\n )\n elif isinstance(j, ppg.MultiFileGeneratingJob):\n files = [str(counter[0]) + \"/\" + x.name for x in j.files]\n nodes.append(\n f\"job_{counter[0]} = ppg.MultiFileGeneratingJob({files!r}, dummy_mfg, depend_on_function=False)\"\n )\n elif isinstance(j, ppg.DataLoadingJob):\n nodes.append(\n f\"job_{counter[0]} = ppg.DataLoadingJob('{counter[0]}', lambda: None, depend_on_function=False)\"\n )\n elif isinstance(j, ppg.AttributeLoadingJob):\n nodes.append(\n f\"job_{counter[0]} = ppg.AttributeLoadingJob('{counter[0]}', DummyObject(), 'attr_{counter[0]}', lambda: None, depend_on_function=False)\"\n )\n else:\n raise ValueError(j)\n node_to_counters[node] = counter[0]\n counter[0] += 1\n for parent in self.runner.dag.predecessors(node):\n descend(parent)\n\n def build_edges(node):\n for parent in self.runner.dag.predecessors(node):\n edges.append(\n f\"edges.append(('{node_to_counters[node]}', '{node_to_counters[parent]}'))\"\n )\n build_edges(parent)\n\n descend(self.job_id)\n edges.append(\"edges = []\")\n build_edges(self.job_id)\n edges.extend(\n [\n \"for (a,b) in edges:\",\n \" if a in ppg.global_pipegraph.jobs and b in ppg.global_pipegraph.jobs:\",\n \" ppg.global_pipegraph.jobs[a].depends_on(ppg.global_pipegraph.jobs[b])\",\n ]\n )\n with open(\"subgraph_debug.py\", \"w\") as op:\n lines = \"\"\"\nclass DummyObject:\n pass\n\ndef dummy_smfg(files, prefix):\n Path(prefix).mkdir(exist_ok=True, parents=True)\n for f in files:\n f.write_text(\"hello\")\n\n\ndef dummy_mfg(files):\n for f in files:\n f.parent.mkdir(exist_ok=True, parents=True)\n f.write_text(\"hello\")\n\ndef dummy_fg(of):\n of.parent.mkdir(exist_ok=True, parents=True)\n of.write_text(\"fg\")\n\n\"\"\".split(\n \"\\n\"\n )\n lines += nodes\n lines += edges\n lines += [\"\", \"ppg.run()\", \"ppg.run\"]\n\n op.write(\"\\n\".join(\" \" + l for l in lines))","def get_children_from_redis(gmac_id, as_objects=True):\n conn = get_redis_connection()\n klass = GoogleMapsAddressComponent\n results = []\n queue = []\n children = klass.get_children_id_list_from_redis_by_pk(gmac_id)\n results.extend(children)\n queue.extend(children)\n while len(queue) > 0:\n node = queue.pop()\n children = klass.get_children_id_list_from_redis_by_pk(node)\n results.extend(children)\n queue.extend(children)\n if as_objects:\n results = klass.objects.filter(pk__in=results)\n return results","def link_entities_to_publication(entities: list, publication: Node, sub_graph) -> Subgraph:\n for entity in entities:\n if 'OntologyClass' not in list(entity.labels):\n sub_graph |= Relationship(entity, 'located_in', publication)\n return sub_graph","def test_DRGEP_GraphSearchDouble(self):\n graph = nx.DiGraph()\n graph.add_nodes_from(['A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', \n 'L', 'M', 'N', 'O'\n ])\n\n graph.add_weighted_edges_from([('A','B', 2), ('B','C',2), ('C','D',2),\n ('D','E',2), ('E','F',2)\n ])\n\n subgraph = nx.DiGraph([(u,v,d) for u,v,d in graph.edges(data=True) if d['weight'] > 0])\n\n\n #temporary solution\n max_dic = graph_search_drgep(subgraph, 'A')\n\n assert 'A' in max_dic\n assert max_dic['A']==1\n assert max_dic['B']==2\n assert max_dic['C']==4\n assert max_dic['D']==8\n assert max_dic['E']==16\n assert max_dic['F']==32"],"string":"[\n \"def get_subgraphs(graph):\\n nodes_powerset = get_nodes_combinations(graph)\\n #print(\\\"Doing\\\")\\n #draw_graph(graph)\\n subgraphs = []\\n for nodes in nodes_powerset:\\n subg = graph.subgraph(nodes)\\n nodes = subg.nodes(data=True)\\n if nx.is_weakly_connected(subg):\\n subgraphs.append(subg)\\n return subgraphs\",\n \"def getSubGraphs(self):\\n\\n self.subGraphs = []\\n visited = {}\\n queue = deque()\\n\\n for s in self.nodes:\\n\\n if s not in visited:\\n subGraph = SubGraph()\\n self.subGraphs.append(subGraph)\\n else:\\n continue\\n\\n queue.append(s)\\n\\n while len (queue) > 0:\\n outDegree = 0\\n node = queue.popleft()\\n if node in visited:\\n continue\\n\\n for u in node.adj:\\n if u not in visited:\\n outDegree += 1\\n queue.append(u)\\n\\n\\n subGraph.addNode(node, outDegree)\\n visited[node] = True\",\n \"def get_subgraphs(self):\\n if hasattr(self, 'subgraphs') is False:\\n self._get_subgraphs()\\n for sub in self.subgraphs:\\n yield sub\",\n \"def subgraph(self, nodes, relabel_nodes=False, output_device=None):\\n raise NotImplementedError(\\\"subgraph is not implemented yet\\\")\",\n \"def sub_graph_merging(self):\",\n \"def get_subgraph(self, node,subgraph=None):\\n\\t\\tif subgraph == None:\\n\\t\\t\\tsubgraph = nx.DiGraph(database=self.database, server=self.server, root=node)\\n\\t\\tfor edge in self.DiG.out_edges(node):\\n\\t\\t\\t# subgraph.add_node(edge[1],{'alias':get_alias(edge[1])})\\n\\t\\t\\t# if edge[0] in subgraph:\\n\\t\\t\\t# \\tprint('child node: {} already in subgraph'.format(edge[0]))\\n\\t\\t\\t# if edge[1] in subgraph:\\n\\t\\t\\t# \\tprint('parent node: {} already in subgraph'.format(edge[1]))\\n\\t\\t\\t# get_alias(edge[0])\\n\\t\\t\\tsubgraph.add_edge(node, edge[1],{'Column':self.DiG.get_edge_data(*edge)['Column']})\\n\\t\\t\\tself.get_subgraph(edge[1],subgraph)\\n\\t\\t# for node in subgraph:\\n\\t\\t# \\tsubgraph[node]['alias'] = get_alias(node)\\n\\t\\treturn subgraph\",\n \"def get_subgraph(graph, min_degree):\\n ###TODO\\n pass\",\n \"def find_all_subgraphs(graph, match):\\n if not match:\\n return []\\n\\n return _find(graph, match, {}, match)\",\n \"def create_sub_graph_copy(graph: nx.MultiDiGraph, nodes_to_extract: list):\\n return graph.subgraph(nodes_to_extract).copy()\",\n \"def edge_subgraph(self, edges, relabel_nodes=False, output_device=None):\\n raise NotImplementedError(\\\"edge_subgraph is not implemented yet\\\")\",\n \"def sub_graph_merging(self):\\n raise NotImplementedError()\",\n \"def get_induced_subgraph(graph, subset):\\n\\t\\n\\tgraph_edges = graph.E\\n\\tvertices = list(graph.V)\\n\\n\\t# construct the induced subgraph\\n\\n\\tnew_graph_edge = {}\\n\\tnew_graph_vertices = subset\\n\\n\\tfor start in graph_edges.keys():\\n\\t\\tif start in new_graph_vertices:\\n\\t\\t\\tfor stop in graph_edges[start]:\\n\\t\\t\\t\\tif stop in new_graph_vertices:\\n\\t\\t\\t\\t\\t# add it to new_graph_edge\\n\\t\\t\\t\\t\\tif start in new_graph_edge:\\n\\t\\t\\t\\t\\t\\tnew_graph_edge[start].append(stop)\\n\\t\\t\\t\\t\\telse:\\n\\t\\t\\t\\t\\t\\tnew_graph_edge[start] = [stop]\\n\\n\\t#print new_graph_vertices\\t\\t\\t\\t\\t\\n\\t#print new_graph_edge\\n\\treturn UndirectedGraph(new_graph_vertices, new_graph_edge)\",\n \"def subgraph(self, nodes_to_include=None, edges_to_include=None,\\n nodes_to_exclude=None, edges_to_exclude=None):\\n if nodes_to_include is None:\\n node_filter_prop = self.graph.new_vertex_property(\\n \\\"bool\\\", val=True)\\n if nodes_to_exclude is not None:\\n indices_to_exclude = [\\n _get_vertex_obj(self.graph, n)\\n for n in nodes_to_exclude\\n ]\\n for i in indices_to_exclude:\\n node_filter_prop[i] = False\\n else:\\n node_filter_prop = self.graph.new_vertex_property(\\n \\\"bool\\\", val=False)\\n indices_to_include = [\\n _get_vertex_obj(self.graph, n)\\n for n in nodes_to_include\\n ]\\n for i in indices_to_include:\\n node_filter_prop[i] = True\\n\\n if edges_to_include is None:\\n edge_filter_prop = self.graph.new_edge_property(\\n \\\"bool\\\", val=True)\\n if edges_to_exclude is not None:\\n sources = [\\n _get_vertex_obj(self.graph, s)\\n for s, _ in edges_to_exclude\\n ]\\n targets = [\\n _get_vertex_obj(self.graph, t)\\n for _, t in edges_to_exclude\\n ]\\n for s, t in zip(sources, targets):\\n edge_filter_prop[self.graph.edge(s, t)] = False\\n else:\\n edge_filter_prop = self.graph.new_edge_property(\\n \\\"bool\\\", val=False)\\n sources = [\\n _get_vertex_obj(self.graph, s)\\n for s, _ in edges_to_include\\n ]\\n targets = [\\n _get_vertex_obj(self.graph, t)\\n for _, t in edges_to_include\\n ]\\n for s, t in zip(sources, targets):\\n edge_filter_prop[self.graph.edge(s, t)] = True\\n\\n return GraphView(\\n self.graph,\\n vfilt=node_filter_prop,\\n efilt=edge_filter_prop)\",\n \"def get_subgraph_between_nodes(self, start, end):\\n nodes = set()\\n nodes.add(start)\\n\\n to_visit = set()\\n to_visit.add(start)\\n\\n while len(to_visit) > 0:\\n current_visit = copy.copy(to_visit)\\n for tv in current_visit:\\n to_visit.remove(tv)\\n if tv is not end:\\n for s in self.successors(tv):\\n to_visit.add(s)\\n nodes.add(s)\\n\\n nodes.add(end)\\n\\n return self.subgraph(nodes)\",\n \"def _subgraph(self):\\n return {\\n 'type': 'SubgraphTask',\\n 'id': 0,\\n 'dependencies': [],\\n 'parameters': {\\n 'info': {},\\n 'current_retries': 0,\\n 'send_task_events': False,\\n 'containing_subgraph': None,\\n 'task_kwargs': {}\\n }\\n }\",\n \"def strongly_connected_components_subgraphs(self):\\n return [self.subgraph(_) for _ in self.strongly_connected_components()]\",\n \"def build_drop_fullgraphs(self, do_subgraph=False, graph_lib='pygraphviz'):\\n if 'pygraphviz' == graph_lib:\\n G = pgv.AGraph(strict=True, directed=True)\\n else:\\n G = nx.Graph()\\n do_subgraph = False\\n subgraph_dict = defaultdict(list) # k - node-ip, v - a list of graph nodes\\n oid_gnid_dict = dict()\\n\\n for i, oid in enumerate(self.pg_spec.keys()):\\n oid_gnid_dict[oid] = str(i)\\n logger.info(\\\"oid to gid mapping done\\\")\\n\\n for dropspec in self.pg_spec.itervalues():\\n gid = oid_gnid_dict[dropspec['oid']]\\n ip = dropspec['node']\\n subgraph_dict[ip].append(gid)\\n if (dropspec['type'] == 'app'):\\n G.add_node(gid, shape='rect', label='')#, fixedsize=True, hight=.05, width=.05)\\n elif (dropspec['type'] == 'plain'): #parallelogram\\n G.add_node(gid, shape='circle', label='')#, fixedsize=True, hight=.05, width=.05)\\n logger.info(\\\"Graph nodes added\\\")\\n\\n for dropspec in self.pg_spec.itervalues():\\n gid = oid_gnid_dict[dropspec['oid']]\\n if (dropspec['type'] == 'app'):\\n ds_kw = 'outputs' #down stream key word\\n elif (dropspec['type'] == 'plain'):\\n ds_kw = 'consumers'\\n else:\\n ds_kw = 'None'\\n if (ds_kw in dropspec):\\n for doid in dropspec[ds_kw]:\\n G.add_edge(gid, oid_gnid_dict[doid])\\n logger.info(\\\"Graph edges added\\\")\\n\\n if (do_subgraph):\\n for i, subgraph_nodes in enumerate(subgraph_dict.values()):\\n # we don't care about the subgraph label or rank\\n subgraph = G.add_subgraph(subgraph_nodes, label='%d' % i, name=\\\"cluster_%d\\\" % i, rank=\\\"same\\\")\\n subgraph.graph_attr['rank']='same'\\n logger.info(\\\"Subgraph added\\\")\\n\\n return G\",\n \"def subsets(self):\\n \\n # note subsets have an unusual encoding\\n query = \\\"\\\"\\\"\\n prefix oboInOwl: <http://www.geneontology.org/formats/oboInOwl#>\\n SELECT DISTINCT ?s WHERE {{\\n GRAPH <{g}> {{\\n ?c oboInOwl:inSubset ?s \\n }}\\n }}\\n \\\"\\\"\\\".format(g=self.graph_name)\\n bindings = run_sparql(query)\\n return [r['s']['value'] for r in bindings]\",\n \"def create_labeled_subgraph(graph):\\n labeled_nodes = []\\n for (p, d) in graph.nodes(data=True):\\n if (d['leaning'] == 'R') or (d['leaning'] == 'D'):\\n labeled_nodes.append(p)\\n return nx.subgraph(graph, labeled_nodes)\",\n \"def create_subbasin_graph():\\n subbasin_to_downstream = pd.read_csv(module_dir + '/../data/simulations_shervan/test.rvh', sep='\\\\s+', skiprows=7, nrows=724, names=['subbasin', 'downstream_subbasin'], usecols=[1,2])\\n subbasin_to_downstream['subbasin'] = subbasin_to_downstream['subbasin']\\n subbasin_to_downstream['downstream_subbasin'] = 'sub' + subbasin_to_downstream['downstream_subbasin'].astype(str)\\n subbasin_to_downstream['edge'] = 1\\n\\n for subbasin in subbasin_to_downstream['subbasin'].unique():\\n is_sink = 1 if len(subbasin_to_downstream[(subbasin_to_downstream['subbasin'] == subbasin) & subbasin_to_downstream['edge'] == 1]) == 0 else 0\\n subbasin_to_downstream = subbasin_to_downstream.append({'subbasin': subbasin, 'downstream_subbasin': subbasin, 'edge': is_sink}, ignore_index=True)\\n subbasin_to_downstream = subbasin_to_downstream.append({'subbasin': 'sub-1', 'downstream_subbasin': 'sub-1', 'edge': 1}, ignore_index=True)\\n \\n adj = subbasin_to_downstream.pivot(index='subbasin', columns='downstream_subbasin', values='edge').fillna(0) \\n adj = adj.sort_index(axis=0).sort_index(axis=1)\\n \\n G = nx.from_numpy_matrix(adj.values, parallel_edges=False, create_using=nx.DiGraph())\\n label_mapping = dict(zip(range(len(adj.values)), adj.index))\\n G = nx.relabel_nodes(G, label_mapping)\\n \\n return G\",\n \"def subgraph(self, v):\\n\\n from pygraph.algorithms.traversal import NodeVisitor, dfs\\n\\n\\n class Visitor(NodeVisitor):\\n def __init__(self, result):\\n self.result = result\\n\\n def visit_node(self, dg, v):\\n self.result.add_node(v)\\n\\n def visit_edge(self, dg, v, w):\\n self.result.add_edge(v, w)\\n\\n dg = Digraph()\\n visitor = Visitor(dg)\\n\\n dfs(self, v, visitor)\\n return dg\",\n \"def semantics_subgraph(self) -> DiGraph:\\n\\n return self.graph.subgraph(list(self.semantics_nodes))\",\n \"def subgraph_within_dates(self, start_date, end_date):\\n new = Graph.graph_with_graph(self)\\n for u, v in self.nx_graph.edges_iter():\\n edge = new.nx_graph.edge[u][v]\\n done = False\\n while len(edge['timestamps']) and not done:\\n top = bottom = False\\n if edge['timestamps'][0] >= end_date:\\n edge['timestamps'].pop(0)\\n else:\\n top = True\\n\\n if len(edge['timestamps']) and edge['timestamps'][-1] < start_date:\\n edge['timestamps'].pop(-1)\\n else:\\n bottom = True\\n\\n done = top and bottom\\n\\n if not len(edge['timestamps']):\\n new.nx_graph.remove_edge(u, v)\\n\\n # min = 100000000\\n # max = -100000000\\n # for u,v, data in new.nx_graph.edges_iter(data=True):\\n # for time in data['timestamps']:\\n # if time < min:\\n # min = time\\n # elif time > max:\\n # max = time\\n\\n new.max_date = end_date\\n new.min_date = start_date\\n return new\",\n \"def extract_workload_subgraphs(workload_names, ts_from, ts_to):\\n ts_from = int(ts_from)\\n ts_to = int(ts_to)\\n\\n # Getting configuration for the ApexLake Landscape\\n landscape_ip = ConfigHelper.get(\\\"LANDSCAPE\\\", \\\"host\\\")\\n landscape_port = ConfigHelper.get(\\\"LANDSCAPE\\\", \\\"port\\\")\\n\\n # Manage the extraction of the subgraph\\n subgraph_extraction = SubGraphExtraction(landscape_ip=landscape_ip,\\n landscape_port=landscape_port)\\n res = subgraph_extraction.get_workload_view_graph(\\n workload_names, int(ts_from), int(ts_to),\\n name_filtering_support=True)\\n\\n return res\",\n \"def get_subgraphs(nodes):\\n subs = collections.defaultdict(dict)\\n for name, node in nodes.items():\\n subs[node['sg']][name] = node\\n return subs\",\n \"def strongly_connected_component_subgraphs(G):\\n cc=strongly_connected_components(G)\\n graph_list=[]\\n for c in cc:\\n graph_list.append(G.subgraph(c))\\n return graph_list\",\n \"def line_graph_forbidden_subgraphs():\\n from sage.graphs.all import Graph\\n from sage.graphs.generators.basic import ClawGraph\\n graphs = [ClawGraph()]\\n\\n graphs.append(Graph({\\n 0: [1, 2, 3],\\n 1: [2, 3],\\n 4: [2],\\n 5: [3]\\n }))\\n\\n graphs.append(Graph({\\n 0: [1, 2, 3, 4],\\n 1: [2, 3, 4],\\n 3: [4],\\n 2: [5]\\n }))\\n\\n graphs.append(Graph({\\n 0: [1, 2, 3],\\n 1: [2, 3],\\n 4: [2, 3]\\n }))\\n\\n graphs.append(Graph({\\n 0: [1, 2, 3],\\n 1: [2, 3],\\n 4: [2],\\n 5: [3, 4]\\n }))\\n\\n graphs.append(Graph({\\n 0: [1, 2, 3, 4],\\n 1: [2, 3, 4],\\n 3: [4],\\n 5: [2, 0, 1]\\n }))\\n\\n graphs.append(Graph({\\n 5: [0, 1, 2, 3, 4],\\n 0: [1, 4],\\n 2: [1, 3],\\n 3: [4]\\n }))\\n\\n graphs.append(Graph({\\n 1: [0, 2, 3, 4],\\n 3: [0, 4],\\n 2: [4, 5],\\n 4: [5]\\n }))\\n\\n graphs.append(Graph({\\n 0: [1, 2, 3],\\n 1: [2, 3, 4],\\n 2: [3, 4],\\n 3: [4]\\n }))\\n\\n return graphs\",\n \"def get_subdiagrams(self, depth):\\n subdiagrams = set()\\n\\n def get_sds_rec(node, sds, level, cur_level):\\n if level == cur_level:\\n return sds.union({node})\\n else:\\n # the children have to be sorted for some usages\\n children = set()\\n for child in node.child_nodes:\\n children = children.union(get_sds_rec(node.child_nodes[child], sds, level, cur_level+1))\\n return children\\n subdiagrams = get_sds_rec(self, subdiagrams, depth, 0)\\n return subdiagrams\",\n \"def get_dependency_subgraphs(graph, node_attrib='label', edge_attrib='label'):\\n assert nx.is_directed_acyclic_graph(graph)\\n for n in xrange(graph.number_of_nodes()):\\n for subnodes in itertools.combinations(graph.nodes(), n+1):\\n subgraph_candidate = graph.subgraph(subnodes)\\n if is_dependency_subgraph(graph, subgraph_candidate,\\n node_attrib=node_attrib,\\n edge_attrib=edge_attrib):\\n yield subgraph_candidate\",\n \"def __deepcopy__(self):\\n return UndirectedGraph.extract_edge_induced_subgraph(self, lambda edge: True) # copy all edges\",\n \"def get_related_edges(nodes_list, graph):\\n\\n node_id_list = map(lambda x: x.id, nodes_list)\\n node_id_set = set(node_id_list)\\n edges = []\\n\\n for node in nodes_list:\\n if node.id in graph.incoming_edges:\\n for edge in graph.incoming_edges[node.id]:\\n\\n if edge.start in node_id_set:\\n edges.append(edge)\\n\\n return edges\",\n \"def get_subgraph(self, agglomeration_id: np.uint64,\\n bounding_box: Optional[Sequence[Sequence[int]]] = None,\\n bb_is_coordinate: bool = False,\\n stop_lvl: int = 1,\\n get_edges: bool = False, verbose: bool = True\\n ) -> Union[Tuple[np.ndarray, np.ndarray], np.ndarray]:\\n # Helper functions for multithreading\\n def _handle_subgraph_children_layer2_edges_thread(\\n child_ids: Iterable[np.uint64]) -> Tuple[List[np.ndarray],\\n List[np.float32]]:\\n\\n _edges = []\\n _affinities = []\\n for child_id in child_ids:\\n this_edges, this_affinities = self.get_subgraph_chunk(\\n child_id, time_stamp=time_stamp)\\n _edges.extend(this_edges)\\n _affinities.extend(this_affinities)\\n return _edges, _affinities\\n\\n def _handle_subgraph_children_layer2_thread(\\n child_ids: Iterable[np.uint64]) -> None:\\n\\n for child_id in child_ids:\\n atomic_ids.extend(self.get_children(child_id))\\n\\n def _handle_subgraph_children_higher_layers_thread(\\n child_ids: Iterable[np.uint64]) -> None:\\n\\n for child_id in child_ids:\\n _children = self.get_children(child_id)\\n\\n if bounding_box is not None:\\n chunk_ids = self.get_chunk_ids_from_node_ids(_children)\\n chunk_ids = np.array([self.get_chunk_coordinates(c)\\n for c in chunk_ids])\\n chunk_ids = np.array(chunk_ids)\\n\\n bounding_box_layer = bounding_box / self.fan_out ** np.max([0, (layer - 3)])\\n\\n bound_check = np.array([\\n np.all(chunk_ids < bounding_box_layer[1], axis=1),\\n np.all(chunk_ids + 1 > bounding_box_layer[0], axis=1)]).T\\n\\n bound_check_mask = np.all(bound_check, axis=1)\\n _children = _children[bound_check_mask]\\n\\n new_childs.extend(_children)\\n\\n # Make sure that edges are not requested if we should stop on an\\n # intermediate level\\n assert stop_lvl == 1 or not get_edges\\n\\n if get_edges:\\n time_stamp = self.read_row(agglomeration_id, \\\"children\\\",\\n get_time_stamp=True)[1]\\n\\n if bounding_box is not None:\\n\\n if bb_is_coordinate:\\n bounding_box = np.array(bounding_box,\\n dtype=np.float32) / self.chunk_size\\n bounding_box[0] = np.floor(bounding_box[0])\\n bounding_box[1] = np.ceil(bounding_box[1])\\n bounding_box = bounding_box.astype(np.int)\\n else:\\n bounding_box = np.array(bounding_box, dtype=np.int)\\n\\n edges = np.array([], dtype=np.uint64).reshape(0, 2)\\n atomic_ids = []\\n affinities = np.array([], dtype=np.float32)\\n child_ids = [agglomeration_id]\\n\\n time_start = time.time()\\n while len(child_ids) > 0:\\n new_childs = []\\n layer = self.get_chunk_layer(child_ids[0])\\n\\n if stop_lvl == layer:\\n atomic_ids = child_ids\\n break\\n\\n # Use heuristic to guess the optimal number of threads\\n n_child_ids = len(child_ids)\\n this_n_threads = np.min([int(n_child_ids // 20) + 1, mu.n_cpus])\\n\\n if layer == 2:\\n if get_edges:\\n edges_and_affinities = mu.multithread_func(\\n _handle_subgraph_children_layer2_edges_thread,\\n np.array_split(child_ids, this_n_threads),\\n n_threads=this_n_threads, debug=this_n_threads == 1)\\n\\n for edges_and_affinities_pair in edges_and_affinities:\\n _edges, _affinities = edges_and_affinities_pair\\n affinities = np.concatenate([affinities, _affinities])\\n edges = np.concatenate([edges, _edges])\\n else:\\n mu.multithread_func(\\n _handle_subgraph_children_layer2_thread,\\n np.array_split(child_ids, this_n_threads),\\n n_threads=this_n_threads, debug=this_n_threads == 1)\\n else:\\n mu.multithread_func(\\n _handle_subgraph_children_higher_layers_thread,\\n np.array_split(child_ids, this_n_threads),\\n n_threads=this_n_threads, debug=this_n_threads == 1)\\n\\n child_ids = new_childs\\n\\n if verbose:\\n print(\\\"Layer %d: %.3fms for %d children with %d threads\\\" %\\n (layer, (time.time() - time_start) * 1000, n_child_ids,\\n this_n_threads))\\n\\n # if len(child_ids) != len(np.unique(child_ids)):\\n # print(\\\"N children %d - %d\\\" % (len(child_ids), len(np.unique(child_ids))))\\n # # print(agglomeration_id, child_ids)\\n #\\n # assert len(child_ids) == len(np.unique(child_ids))\\n\\n time_start = time.time()\\n\\n atomic_ids = np.array(atomic_ids, np.uint64)\\n\\n if get_edges:\\n return edges, affinities\\n else:\\n return atomic_ids\",\n \"def subgraphs_of_length(self, days=None, periods=None):\\n graphs = []\\n if days:\\n sg_length = datetime.timedelta(days=days)\\n else:\\n sg_length = periods\\n\\n start_date = self.min_date\\n end_date = start_date + sg_length\\n done = False\\n while not done:\\n if start_date > self.max_date:\\n break\\n if end_date > self.max_date:\\n # end_date = self.max_date\\n done = True\\n print(start_date, end_date)\\n new = self.subgraph_within_dates(start_date, end_date)\\n if new.nx_graph.number_of_edges():\\n graphs.append(new)\\n start_date += sg_length\\n end_date += sg_length\\n return graphs\",\n \"def _get_subgraph(entities, kb_r, multigraph_W):\\n seed = np.zeros((multigraph_W.shape[0], 1))\\n if not SEED_WEIGHTING:\\n seed[entities] = 1. / len(set(entities))\\n else:\\n seed[entities] = np.expand_dims(np.arange(len(entities), 0, -1),\\n axis=1)\\n seed = seed / seed.sum()\\n ppr = _personalized_pagerank(seed, multigraph_W)\\n sorted_idx = np.argsort(ppr)[::-1]\\n extracted_ents = sorted_idx[:MAX_ENT]\\n extracted_scores = ppr[sorted_idx[:MAX_ENT]]\\n # check if any ppr values are nearly zero\\n zero_idx = np.where(ppr[extracted_ents] < 1e-6)[0]\\n if zero_idx.shape[0] > 0:\\n extracted_ents = extracted_ents[:zero_idx[0]]\\n extracted_tuples = []\\n ents_in_tups = set()\\n for relation in kb_r:\\n submat = kb_r[relation][extracted_ents, :]\\n submat = submat[:, extracted_ents]\\n row_idx, col_idx = submat.nonzero()\\n for ii in range(row_idx.shape[0]):\\n extracted_tuples.append(\\n (extracted_ents[row_idx[ii]], relation,\\n extracted_ents[col_idx[ii]]))\\n ents_in_tups.add((extracted_ents[row_idx[ii]],\\n extracted_scores[row_idx[ii]]))\\n ents_in_tups.add((extracted_ents[col_idx[ii]],\\n extracted_scores[col_idx[ii]]))\\n return extracted_tuples, list(ents_in_tups)\",\n \"def create_unlabeled_subgraph(graph):\\n unlabeled_nodes = []\\n for (p, d) in graph.nodes(data=True):\\n if (d['leaning'] == 'Unknown'):\\n unlabeled_nodes.append(p)\\n return nx.subgraph(graph, unlabeled_nodes)\",\n \"def _recv_subgraph(receiver, graph):\\n # hdl is a list of ptr\\n hdl = unwrap_to_ptr_list(_CAPI_ReceiverRecvSubgraph(receiver))\\n return NodeFlow(graph, hdl[0])\",\n \"def _subnode_ids(self):\\n for ticket in self:\\n ticket.subnode_ids = self.search([\\n ('parent_id', '=', ticket.id),\\n ('type.has_children', '=', True)])\",\n \"def extract_node_induced_subgraph(self, predicate):\\n # construct the filtered nodeset\\n nodeset = {node.produce_duplicate_disconnected_node() for node in self.get_nodeset() if predicate(node)}\\n\\n G_prime = UndirectedGraph(nodeset) # create a new subgraph\\n\\n for edge in self.get_edges(): # for every edge in the original graph\\n # if the first incident node is in the graph\\n if edge.get_first_incident_node().get_name() in G_prime.get_node_names():\\n # if the second incident node is also in the graph\\n if edge.get_second_incident_node().get_name() in G_prime.get_node_names():\\n # add the edge to the subgraph\\n G_prime = UndirectedGraph.__induced_subgraph_helper(G_prime, edge)\\n return G_prime # return the subgraph\",\n \"def readSubgraph(graph, ctxURI):\\n filename = filenameFromURI(ctxURI)\\n for dateDir in os.listdir(\\\"graph\\\"):\\n f = \\\"graph/%s/%s\\\" % (dateDir, filename)\\n if os.path.exists(f):\\n print \\\"readSubgraph adds\\\", f\\n graph.parse(f, format=SUBGRAPH_FORMAT, publicID=ctxURI)\",\n \"def subgraph(infr, aids):\\n orig_name_labels = list(infr.gen_node_values('orig_name_label', aids))\\n infr2 = AnnotInference(\\n infr.ibs, aids, orig_name_labels, autoinit=False, verbose=infr.verbose\\n )\\n # deep copy the graph structure\\n infr2.graph = infr.graph.subgraph(aids).copy()\\n infr2.readonly = True\\n infr2.verifiers = infr.verifiers\\n infr2.ranker = infr.ranker\\n\\n infr.params = copy.deepcopy(infr.params)\\n infr2._viz_image_config = infr._viz_image_config.copy()\\n\\n # infr2._viz_init_nodes = infr._viz_image_config\\n # infr2._viz_image_config_dirty = infr._viz_image_config_dirty\\n infr2.edge_truth = {\\n e: infr.edge_truth[e] for e in infr2.graph.edges() if e in infr.edge_truth\\n }\\n\\n # TODO: internal/external feedback\\n\\n infr2.nid_counter = infr.nid_counter\\n infr2.dirty = True\\n infr2.cm_list = None\\n infr2.qreq_ = None\\n\\n # TODO:\\n # infr2.nid_to_errors {} # = copy.deepcopy(infr.nid_to_errors)\\n # infr2.recover_graph = copy.deepcopy(infr.recover_graph)\\n # infr2.pos_redun_nids = copy.deepcopy(infr.pos_redun_nids)\\n # infr2.neg_redun_metagraph = copy.deepcopy(infr.neg_redun_metagraph)\\n\\n infr2.review_graphs = {}\\n for k, g in infr.review_graphs.items():\\n if g is None:\\n infr2.review_graphs[k] = None\\n elif k == POSTV:\\n infr2.review_graphs[k] = g.subgraph(aids, dynamic=True)\\n else:\\n infr2.review_graphs[k] = g.subgraph(aids)\\n return infr2\",\n \"def generateGraph(mids, chaptersField, labelsField):\\n output = \\\"digraph G { \\\\n\\\"\\n # On ne traite que les chapitres qui ont actives le graphe\\n chapts = chapters.graphChapters()\\n # le dico nodes contient une liste pour chaque chapitre. Chaque liste\\n # contient tous les neuds (un par note) presents dans ce chapitre, et\\n # representes par des tuples (noteId, label)\\n nodes = {}\\n for mid in mids:\\n chapterField = chaptersField[mid]\\n labelField = labelsField[mid]\\n for id, flds in mw.col.db.execute(\\\"\\\"\\\"\\n SELECT id, flds FROM notes WHERE mid=%d\\n \\\"\\\"\\\" % mid):\\n fields = splitFields(flds)\\n chapter = fields[chapterField]\\n if not chapter in chapts:\\n continue\\n label = fields[labelField]\\n if(not chapter in nodes):\\n nodes[chapter] = []\\n nodes[chapter].append((id, label))\\n # On genere les noeuds, dans des clusters (un par chapitre)\\n notes = []\\n for chap in nodes:\\n output += \\\"\\\"\\\"subgraph cluster_%d {\\n node [style=filled];\\n label = \\\"%s\\\";\\n color=blue;\\n \\\"\\\"\\\" % (chapts[chap], chap)\\n for n in nodes[chap]:\\n output += \\\"\\\"\\\"n%d [label=\\\"%s\\\", URL=\\\"%d\\\"];\\\\n\\\"\\\"\\\" % (n[0], n[1], n[0])\\n notes.append(n)\\n output += \\\"\\\"\\\"\\n }\\\\n\\\"\\\"\\\"\\n # Puis on ajoute tous les liens ..\\n for n in notes:\\n for nid in mw.col.db.execute(\\\"\\\"\\\"SELECT N.noteId FROM `PATH.links` AS L\\n JOIN `PATH.match` AS M ON M.id = L.matchId\\n JOIN `PATH.nodes` AS N ON M.nodeId = N.id\\n WHERE L.noteId = %d\\\"\\\"\\\" % (n[0])):\\n output += \\\"\\\"\\\"n%d -> n%d;\\\\n\\\"\\\"\\\" % (nid[0], n[0])\\n output += \\\"}\\\"\\n generateGraphImage(output)\",\n \"def subgraphs(date):\\n dateDir = \\\"graph/%s\\\" % date\\n if not os.path.isdir(dateDir):\\n return\\n for name in os.listdir(dateDir):\\n filename = \\\"graph/%s/%s\\\" % (date, name)\\n if filename.endswith('.uri'):\\n continue\\n uri, label = open(filename + \\\".uri\\\").read().split(\\\"\\\\0\\\")\\n yield uri, label, filename\",\n \"def get_nodes_to_update(subgraph, graph_name, starter=0):\\n global SUBGRAPHS, PARENTS\\n \\n nodes = extract_nodes(subgraph)\\n \\n for child_subgraph in subgraph.get_subgraph_list():\\n nodes += get_nodes_to_update(child_subgraph, graph_name, 1)\\n \\n parent = PARENTS[subgraph.get_name()].get_name()\\n while(parent != graph_name and starter == 0):\\n nodes += extract_nodes(PARENTS[subgraph.get_name()])\\n parent = PARENTS[parent].get_name()\\n return nodes\",\n \"def get_reverse_slice(self, node_id, nodes_in_slice):\\n node = self.nodes[node_id]\\n\\n for related_node_id in node['relations']:\\n if self.nodes[related_node_id]['distance'] > node['distance']:\\n if not nodes_in_slice.get(node_id):\\n nodes_in_slice[node_id] = [related_node_id]\\n else:\\n nodes_in_slice[node_id].append(related_node_id)\\n if not nodes_in_slice.get(related_node_id):\\n nodes_in_slice[related_node_id] = []\\n self.get_reverse_slice(related_node_id, nodes_in_slice)\\n return nodes_in_slice\",\n \"def subgraph_matching(base_graph, subgraph, matches, validate=False):\\n final_subgraphs = []\\n initial_sg = _create_initial_subgraph(matches,\\n base_graph,\\n subgraph,\\n validate)\\n if not initial_sg:\\n LOG.warning('subgraph_matching:Initial sub-graph creation failed')\\n LOG.warning('subgraph_matching: Known matches: %s', matches)\\n return final_subgraphs\\n queue = [initial_sg]\\n\\n while queue:\\n curr_subgraph = queue.pop(0)\\n\\n # STEP 1: STOPPING CONDITION\\n mapped_vertices = list(filter(\\n lambda v: v.get(MAPPED_V_ID),\\n curr_subgraph.get_vertices()))\\n if len(mapped_vertices) == subgraph.num_vertices():\\n final_subgraphs.append(curr_subgraph)\\n continue\\n\\n # STEP 2: CAN WE THROW THIS SUB-GRAPH?\\n vertices_with_unmapped_neighbors = list(filter(\\n lambda v: not v.get(NEIGHBORS_MAPPED),\\n mapped_vertices))\\n if not vertices_with_unmapped_neighbors:\\n continue\\n\\n # STEP 3: FIND A SUB-GRAPH VERTEX TO MAP\\n v_with_unmapped_neighbors = _choose_vertex(\\n vertices_with_unmapped_neighbors,\\n curr_subgraph)\\n\\n unmapped_neighbors = list(filter(\\n lambda v: not v.get(MAPPED_V_ID),\\n curr_subgraph.neighbors(v_with_unmapped_neighbors.vertex_id)))\\n if not unmapped_neighbors:\\n # Mark vertex as NEIGHBORS_MAPPED=True\\n v_with_unmapped_neighbors[NEIGHBORS_MAPPED] = True\\n curr_subgraph.update_vertex(v_with_unmapped_neighbors)\\n queue.append(curr_subgraph)\\n continue\\n subgraph_vertex_to_map = _choose_vertex(\\n unmapped_neighbors,\\n curr_subgraph,\\n curr_v=v_with_unmapped_neighbors)\\n\\n # STEP 4: PROPERTIES CHECK\\n graph_candidate_vertices = base_graph.neighbors(\\n v_id=v_with_unmapped_neighbors[MAPPED_V_ID],\\n vertex_attr_filter=subgraph_vertex_to_map)\\n\\n graph_candidate_vertices = \\\\\\n _remove_used_graph_candidates(graph_candidate_vertices,\\n curr_subgraph)\\n\\n # STEP 5: STRUCTURE CHECK\\n edges = _get_edges_to_mapped_vertices(curr_subgraph,\\n subgraph_vertex_to_map.vertex_id)\\n neg_edges = set(e for e in edges if e.get(NEG_CONDITION))\\n pos_edges = edges.difference(neg_edges)\\n\\n if not graph_candidate_vertices and neg_edges and not pos_edges:\\n subgraph_vertex_to_map[MAPPED_V_ID] = NEG_VERTEX\\n curr_subgraph.update_vertex(subgraph_vertex_to_map)\\n queue.append(curr_subgraph)\\n continue\\n\\n found_subgraphs = []\\n remaining_items = len(graph_candidate_vertices)\\n for graph_vertex in graph_candidate_vertices:\\n subgraph_vertex_to_map[MAPPED_V_ID] = graph_vertex.vertex_id\\n subgraph_vertex_to_map[GRAPH_VERTEX] = graph_vertex\\n curr_subgraph.update_vertex(subgraph_vertex_to_map)\\n if not _graph_contains_subgraph_edges(base_graph,\\n curr_subgraph,\\n pos_edges):\\n continue\\n if not _graph_contains_subgraph_edges(base_graph,\\n curr_subgraph,\\n neg_edges):\\n del found_subgraphs[:]\\n break\\n if neg_edges and not pos_edges:\\n subgraph_vertex_to_map[MAPPED_V_ID] = NEG_VERTEX\\n curr_subgraph.update_vertex(subgraph_vertex_to_map)\\n\\n remaining_items -= 1 # no need to copy the last one\\n found_subgraphs.append(\\n curr_subgraph.copy() if remaining_items else curr_subgraph)\\n\\n queue.extend(found_subgraphs)\\n\\n # Last thing: Convert results to the expected format!\\n return _generate_result(final_subgraphs)\",\n \"def extract_edge_induced_subgraph(self, predicate):\\n # initialize the new nodeset as sets containing disconnected copies of the original nodes\\n nodeset = {node.produce_duplicate_disconnected_node() for node in self.get_nodeset()}\\n\\n # create a null graph using the nodeset constructed above\\n G_prime = UndirectedGraph(nodeset)\\n\\n # for every edge in the original graph\\n for edge in self.get_edges():\\n if predicate(edge): # if the edge is not filtered out\\n G_prime = UndirectedGraph.__induced_subgraph_helper(G_prime, edge)\\n\\n return G_prime # return the subgraph\",\n \"def test_restore_multiple_in_subgraph(self):\\n subgraph = self._subgraph()\\n subgraph['id'] = 15\\n task1 = self._remote_task()\\n task1['id'] = 1\\n task2 = self._remote_task()\\n task2['id'] = 2\\n task1['parameters']['containing_subgraph'] = 15\\n task2['parameters']['containing_subgraph'] = 15\\n\\n graph = self._restore_graph([subgraph, task1, task2])\\n assert len(graph.tasks) == 3\\n subgraphs = [op for op in graph.tasks if op.is_subgraph]\\n remote_tasks = [op for op in graph.tasks if not op.is_subgraph]\\n\\n # those are all references to the same subgraph, the subgraph was\\n # NOT restored multiple times\\n assert remote_tasks[0].containing_subgraph \\\\\\n is remote_tasks[1].containing_subgraph \\\\\\n is subgraphs[0]\\n\\n assert len(subgraphs[0].tasks) == 2\",\n \"def FeynmanSubgraphs(graph, model):\\n model.SetTypes(graph)\\n model.checktadpoles = False\\n graph.FindSubgraphs(model)\\n\\n subs_toremove = subgraphs.DetectSauseges(graph._subgraphs)\\n graph.RemoveSubgaphs(subs_toremove)\\n\\n subgraphs.RemoveTadpoles(graph)\",\n \"def test_prune_dnnl_subgraph(run_module):\\n\\n def get_graph():\\n x1 = relay.var(\\\"x1\\\", shape=(1, 32, 56, 56))\\n x2 = relay.var(\\\"x2\\\", shape=(1, 32, 56, 56))\\n bias = relay.var(\\\"bias\\\", shape=(32,))\\n weight = relay.var(\\\"weight\\\", shape=(32, 32, 3, 3))\\n y = relay.nn.conv2d(\\n x1,\\n weight,\\n channels=32,\\n kernel_size=(3, 3),\\n padding=(1, 1),\\n )\\n y = relay.nn.bias_add(y, bias)\\n y = relay.nn.relu(y)\\n y = relay.nn.global_max_pool2d(y)\\n y = relay.add(y, x2)\\n dic = {\\n \\\"x1\\\": (1, 32, 56, 56),\\n \\\"x2\\\": (1, 32, 56, 56),\\n \\\"weight\\\": (32, 32, 3, 3),\\n \\\"bias\\\": (32,),\\n }\\n param_lst = [\\\"weight\\\", \\\"bias\\\"]\\n out = tvm.IRModule.from_expr(y)\\n return out, dic, param_lst\\n\\n run_and_verify_func(get_graph(), subgraph_num=1, run_module=run_module, test_bf16=False)\",\n \"def allGraphs(date):\\n g = getGraph()\\n for uri, label, filename in subgraphs(date):\\n if not label:\\n label = \\\"(no label provided)\\\"\\n g.parse(filename, format=SUBGRAPH_FORMAT)\\n return g\",\n \"def add_subgraph(self, subgraph, prefix):\\n for ntype in subgraph.get_types():\\n new_nodes = subgraph.get_node_list(ntype)\\n for node in new_nodes:\\n node.ext_id = node_id(prefix, node.ext_id)\\n self.add_node_list(ntype, new_nodes)\",\n \"def get_subnodes(self) -> List[SubNode]:\\n\\t\\t# Get all SubNodes\\n\\t\\tsubnode_holder = NodeSubNodeHolder()\\n\\t\\tfor rootnode in self.root_nodes:\\n\\t\\t\\tfor subnode in rootnode.get_subnodes():\\n\\t\\t\\t\\tsubnode_holder.add_subnode(subnode)\\n\\n\\t\\t# Return\\n\\t\\treturn subnode_holder.get_subnodes()\",\n \"def show_subgraph(dfs_codes, nsupport, mapper):\\n\\tglobal __subgraph_count\\n\\n\\tg = build_graph(dfs_codes)\\n\\tg.id = __subgraph_count\\n\\t__subgraph_count += 1\\n\\tg.gprint(nsupport, mapper)\",\n \"def _all_subnodes(self):\\n return self.__dict__.values()\",\n \"def to_undirected_graph(self):\\n visited = set() \\n G = Graph.Graph()\\n \\n for node in self.node_set:\\n \\n if node not in visited:\\n visited.add(node)\\n for i in self.suffix[node]:\\n G.add_edge(node, i)\\n \\n return G\",\n \"def _generate_subgraph_sql_parts(self, node, subgraph, i=0,colNames=None,sql=None):\\n\\t\\treferencesPersonFact = False\\n\\t\\tif i == 0:\\n\\t\\t\\tsql=[]\\n\\t\\t\\tcolNames=[]\\n\\t\\t\\t# print('\\\\nSELECT *\\\\nFROM {}'.format(node))\\n\\t\\tfor edge in subgraph.out_edges(node):\\n\\t\\t\\t# print('\\\\tedge: {}->{} {}'.format(*edge,subgraph.get_edge_data(*edge)))\\n\\t\\t\\tcolNames.append('{}.{}'.format(edge[0],subgraph.get_edge_data(*edge)['Column']))\\n\\t\\t\\t# print('{}LEFT JOIN {}\\\\n{}ON {}.{}={}.{}'.format('\\\\t'*i,edge[1],'\\\\t'*i,edge[1],subgraph.get_edge_data(*edge)['Column'],edge[0],subgraph.get_edge_data(*edge)['Column']))\\n\\t\\t\\tsql.append('{}LEFT JOIN {}\\\\n{}ON {}.{}={}.{}'.format('\\\\t'*i,edge[1],'\\\\t'*i,edge[1],subgraph.get_edge_data(*edge)['Column'],edge[0],subgraph.get_edge_data(*edge)['Column']))\\n\\t\\t\\tself._generate_subgraph_sql_parts(edge[1],subgraph,i+1,colNames,sql)\\n\\t\\t\\tif 'dbo.PersonFact' in edge[0] or 'dbo.PersonFact' in edge[1]:\\n\\t\\t\\t\\treferencesPersonFact = True\\n\\t\\t# print('_generate_subgraph_sql_parts')\\n\\t\\t# if referencesPersonFact and 'CommunityMart.dbo.PersonFact.PatientID' not in colNames:\\n\\t\\t\\t# colNames.append('CommunityMart.dbo.PersonFact.PatientID')\\n\\t\\t# remove colNames of already in leaf table\\n\\t\\tnet_new_colNames = []\\n\\t\\tfor colName in colNames:\\n\\t\\t\\tif node not in colName:\\n\\t\\t\\t\\tnet_new_colNames.append(colName)\\n\\t\\treturn net_new_colNames,sql\",\n \"def flat_graph(self) -> dict:\\n return self.pgnode.flat_graph()\",\n \"def single_source_subgraph(g, node):\\n return g.subgraph(nx.single_source_shortest_path(g, node).keys())\",\n \"def subgraph(self, name):\\n\\n self._compiled = None\\n sub = Graph()\\n self.graph[name] = sub\\n return sub\",\n \"def shrink(subgraph: list, graph: nx.Graph) -> list:\\r\\n\\r\\n if not utils.is_subgraph(subgraph, graph):\\r\\n raise ValueError(\\\"Input is not a valid subgraph\\\")\\r\\n\\r\\n subgraph = graph.subgraph(subgraph).copy() # A copy is required to be able to modify the\\r\\n # structure of the subgraph (https://networkx.github.io/documentation/stable/reference/classes/generated/networkx.Graph.subgraph.html)\\r\\n\\r\\n while not utils.is_clique(subgraph):\\r\\n degrees = list(subgraph.degree())\\r\\n np.random.shuffle(degrees) # used to make sure selection of node with lowest degree is not\\r\\n # deterministic in case of a tie (https://docs.python.org/3/library/functions.html#min)\\r\\n\\r\\n to_remove = min(degrees, key=lambda x: x[1])\\r\\n subgraph.remove_node(to_remove[0])\\r\\n\\r\\n return sorted(subgraph.nodes())\",\n \"def test_restore_with_subgraph(self):\\n subgraph = self._subgraph()\\n task = self._remote_task()\\n subgraph['id'] = 15\\n task['parameters']['containing_subgraph'] = 15\\n\\n graph = self._restore_graph([subgraph, task])\\n assert len(graph.tasks) == 2\\n subgraphs = [op for op in graph.tasks if op.is_subgraph]\\n remote_tasks = [op for op in graph.tasks if not op.is_subgraph]\\n\\n assert len(subgraphs) == 1\\n assert len(remote_tasks) == 1\\n\\n assert len(subgraphs[0].tasks) == 1\\n assert remote_tasks[0].containing_subgraph is subgraphs[0]\",\n \"def subgraph(index, query, length=50):\\n\\n \\n # get vertex ids\\n proxs = {}\\n pzeros = []\\n for q in query:\\n if q['form'] in ('', None):\\n raise WrongQueryError(\\\"Un mot doit être sasie pour effectuer une recherche.\\\") \\n \\n result = extract(index, q, 500)\\n if not len(result): \\n raise WrongQueryError(u\\\"Aucun résultat pour le mot '%s'.\\\" % q['form']) \\n\\n p0, vect = result.keys()[0], result.values()[0]\\n for k,v in vect:\\n proxs[k] = proxs.get(k,0.) + v;\\n pzeros.append(p0)\\n \\n proxs = proxs.items()\\n proxs.sort(key=lambda x : x[1], reverse=True)\\n proxs = dict(proxs[:length])\\n \\n ids = proxs.keys()\\n # request es with ids\\n res = search_docs(index, query[0]['graph'], ids)\\n # convert res to docs\\n docs = to_docs(res, pzeros)\\n \\n docs.sort(key=lambda x : proxs[x.docnum], reverse=True)\\n \\n \\n # build graph from docs\\n graph = to_graph(docs)\\n \\n return graph\",\n \"def di_subgraph(self, nbunch):\\n\\t\\t\\n\\t\\t# create new subgraph.\\n\\t\\tg = nx.DiGraph()\\n\\t\\t\\n\\t\\t# add edges and nodes.\\n\\t\\tg.add_edges_from( self.edges(nbunch=nbunch) )\\n\\t\\t\\n\\t\\treturn g\",\n \"def subgraph(self, subset_dict: Dict[NodeType, Tensor]) -> 'HeteroData':\\n data = copy.copy(self)\\n subset_dict = copy.copy(subset_dict)\\n\\n for node_type, subset in subset_dict.items():\\n for key, value in self[node_type].items():\\n if key == 'num_nodes':\\n if subset.dtype == torch.bool:\\n data[node_type].num_nodes = int(subset.sum())\\n else:\\n data[node_type].num_nodes = subset.size(0)\\n elif self[node_type].is_node_attr(key):\\n data[node_type][key] = value[subset]\\n else:\\n data[node_type][key] = value\\n\\n for edge_type in self.edge_types:\\n src, _, dst = edge_type\\n\\n src_subset = subset_dict.get(src)\\n if src_subset is None:\\n src_subset = torch.arange(data[src].num_nodes)\\n dst_subset = subset_dict.get(dst)\\n if dst_subset is None:\\n dst_subset = torch.arange(data[dst].num_nodes)\\n\\n edge_index, _, edge_mask = bipartite_subgraph(\\n (src_subset, dst_subset),\\n self[edge_type].edge_index,\\n relabel_nodes=True,\\n size=(self[src].num_nodes, self[dst].num_nodes),\\n return_edge_mask=True,\\n )\\n\\n for key, value in self[edge_type].items():\\n if key == 'edge_index':\\n data[edge_type].edge_index = edge_index\\n elif self[edge_type].is_edge_attr(key):\\n data[edge_type][key] = value[edge_mask]\\n else:\\n data[edge_type][key] = value\\n\\n return data\",\n \"def create_subsets(self, start_ids):\\n subsets = list()\\n df = self.all_df.copy()\\n for sid in start_ids:\\n df2 = df.loc[sid:, :]\\n subsets.append(df.drop(df2.index, axis=0))\\n df = df2.copy()\\n subsets.append(df)\\n return subsets\",\n \"def get_subdiagrams_grouped_by_level(self):\\n subds = []\\n\\n def get_subds_gbl_rec(node, level):\\n \\\"\\\"\\\"\\n The recursive call\\n \\\"\\\"\\\"\\n try:\\n subds[level] = subds[level].union({node})\\n except IndexError:\\n subds.append({node})\\n if not isinstance(node, Leaf):\\n for child in node.child_nodes:\\n get_subds_gbl_rec(node.child_nodes[child][0], level+1)\\n\\n get_subds_gbl_rec(self, 0)\\n return subds\",\n \"def _get_edges_to_mapped_vertices(graph, vertex_id):\\n subgraph_edges_to_mapped_vertices = []\\n for e in graph.get_edges(vertex_id):\\n t_neighbor = graph.get_vertex(e.other_vertex(vertex_id))\\n if not t_neighbor:\\n raise VitrageAlgorithmError('Cant get vertex for edge %s' % e)\\n if t_neighbor and t_neighbor.get(MAPPED_V_ID):\\n subgraph_edges_to_mapped_vertices.append(e)\\n return set(subgraph_edges_to_mapped_vertices)\",\n \"def get_stable_subgraph(self):\\n if not self._fitted:\\n raise NotFittedError()\\n nbunch = []\\n for node in self.nodes_iter():\\n if len(node) == self._max_length:\\n nbunch.append(node)\\n return self.subgraph(nbunch)\",\n \"def _get_full_graph(self):\",\n \"def generate_subgraph(format):\\n\\n # get business information\\n directorypath = genpath+directory\\n if os.path.isfile(directorypath):\\n \\n bizdata = pd.read_csv( directorypath, escapechar='\\\\\\\\')\\n\\n #create a directory of page-id and object-ids\\n tempdf = bizdata.set_index('pageid')\\n tempdf = tempdf['objectid']\\n dictionary = tempdf.to_dict()\\n\\n uncgraph = pd.read_csv(inpath+graphfile, escapechar='\\\\\\\\')\\n uncgraph = uncgraph.dropna()\\n uncgraph['likee_object_id'] = uncgraph.apply(lambda x: dictionary.get(x['likee_page_id']), axis=1)\\n cgraph = uncgraph.dropna()\\n cgraph = cgraph[['liker_page_id', 'likee_page_id']]\\n cgraph.columns = ['Source', 'Target']\\n\\n \\n print_stats(cgraph)\\n if format == 'networkx' :\\n print \\\"[Generating a networkX graph...]\\\" \\n cgraph.to_csv(genpath+subgraph+'.ntx', index=False, header=False, sep= ' ')\\n else:\\n print \\\"[Generating a csv graph...]\\\" \\n cgraph.to_csv(genpath+subgraph+'.csv', index=False)\\n\\n\\n else:\\n print \\\"Either file is missing or is not readable\\\"\",\n \"def get_child_ids(id,conn):\\n\\n child_ids = ('WITH RECURSIVE children AS '\\n '(SELECT subject_id '\\n 'FROM cvterm_relationship '\\n 'WHERE object_id = %s '\\n 'UNION '\\n 'SELECT cr.subject_id '\\n 'FROM cvterm_relationship cr '\\n 'INNER JOIN children ch ON ch.subject_id = cr.object_id) '\\n 'SELECT * FROM children')\\n ids = connect(child_ids,id,conn)\\n list_of_ids = []\\n for item in ids:\\n list_of_ids.append(item[0])\\n return(list_of_ids)\",\n \"def is_subgraph_of(self, other):\\n # If it is already recognized that it is a subgraph this procedure can be skipped.\\n if other in self.__supergraph :\\n return True\\n \\n if type(self)!=type(other):\\n raise TypeError(\\\"Only works between graphs.\\\")\\n elif other.return_num_vertices() == 0:\\n return False\\n elif self.return_num_vertices() == 0:\\n return True\\n names_to_check = self.return_names()\\n # Checks if the vertices are a subset\\n if not set(names_to_check).issubset(set(other.return_names())):\\n return False\\n \\n # Traverses each node and checks if the adjacencies build a subset.\\n # To do so, the node indices must be replaced by node names.\\n # This is laborious, but only needs to be done once.\\n for name in names_to_check:\\n selflist = set(map(lambda x: (self.return_vertexName(x[0]),x[1]), self.return_adjacencies(self.return_vertexIndex(name))))\\n otherlist = set(map(lambda x: (other.return_vertexName(x[0]),x[1]), other.return_adjacencies(other.return_vertexIndex(name))))\\n if not selflist.issubset(otherlist):\\n return False\\n self.__supergraph.append(other)\\n \\n return True\",\n \"def test_extract_graph(default_plugin_resolver):\\n dpr = default_plugin_resolver\\n nx_graph = nx.Graph()\\n nx_graph.add_weighted_edges_from(\\n [(1, 0, 2), (1, 4, 3), (2, 5, 5), (2, 7, 6), (3, 1, 7), (5, 6, 10), (6, 2, 11),]\\n )\\n desired_nodes = {2, 5, 6}\\n nx_extracted_graph = nx.Graph()\\n nx_extracted_graph.add_weighted_edges_from([(2, 5, 5), (5, 6, 10), (6, 2, 11)])\\n graph = dpr.wrappers.Graph.NetworkXGraph(nx_graph)\\n desired_nodes_wrapped = dpr.wrappers.NodeSet.PythonNodeSet(desired_nodes)\\n extracted_graph = dpr.wrappers.Graph.NetworkXGraph(nx_extracted_graph)\\n MultiVerify(\\n dpr, \\\"subgraph.extract_subgraph\\\", graph, desired_nodes_wrapped\\n ).assert_equals(extracted_graph)\",\n \"def get_descendants(self, node, triples, ignore=\\\"^(rel_|frame_)\\\"):\\n children = defaultdict(list) # parent id : [child ids]\\n inrelation = set() # ids of all nodes in a relation\\n for s, p, o in triples:\\n s, o = int(s.id), int(o.id)\\n if p.startswith(\\\"rel_\\\"):\\n children[o].append(s)\\n elif not re.match(ignore, p):\\n inrelation |= {s, o}\\n seen = set()\\n def getnodes(n):\\n if n in seen:\\n return\\n seen.add(n)\\n yield n\\n for c in children[n]:\\n if c not in inrelation:\\n for n2 in getnodes(c):\\n yield n2\\n return getnodes(node)\",\n \"def subsample_graph(graph, max_degree,\\n rng):\\n edges = sampler.get_adjacency_lists(graph)\\n edges = sampler.sample_adjacency_lists(edges, graph.train_nodes, max_degree,\\n rng)\\n senders = []\\n receivers = []\\n for u in edges:\\n for v in edges[u]:\\n senders.append(u)\\n receivers.append(v)\\n\\n graph.senders = senders\\n graph.receivers = receivers\\n return graph\",\n \"def get_subnodes(self) -> List[SubNode]:\\n\\t\\treturn sorted(self.subnodes, key=lambda x: attrib_key(x.name))\",\n \"def edges_to_boundary(edges):\\n graph = nx.from_edgelist(edges)\\n # import matplotlib.pyplot as plt\\n # plt.subplot(111)\\n # nx.draw(graph, with_labels=True, font_weight='bold')\\n # plt.show()\\n\\n sub_graphs = [graph.subgraph(c).copy() for c in nx.connected_components(graph)]\\n sub_graphs_path = list()\\n for sub_graph in sub_graphs:\\n sub_graph_nodes = list(sub_graph.nodes)\\n paths = sorted(list(nx.all_simple_paths(sub_graph, source=sub_graph_nodes[0], target=sub_graph_nodes[1])), key=len, reverse=True)\\n sub_graphs_path.append(paths[0])\\n\\n return sorted(sub_graphs_path, key=len)\",\n \"def _subgraph_isomorphism_matcher(digraph, nxpattern, node_pred, edge_pred):\\n graph_matcher = iso.DiGraphMatcher(digraph, nxpattern, node_match=node_pred, edge_match=edge_pred)\\n yield from graph_matcher.subgraph_isomorphisms_iter()\",\n \"def get_induced_subgraph(graph: Graph, nodes: Nodes):\\n return {node: graph[node].intersection(nodes) for node in nodes}\",\n \"def find_subgraph(node, graph, draw_graph=True, save_graph=False):\\r\\n\\r\\n try:\\r\\n stack = [node]\\r\\n\\r\\n # the list that stores the nodes\\r\\n result = []\\r\\n\\r\\n while stack:\\r\\n for i in graph.edges():\\r\\n if stack[0] == i[0]:\\r\\n result.append(i)\\r\\n stack.append(i[1])\\r\\n stack.pop(0)\\r\\n\\r\\n # build the new graph\\r\\n n = nx.Graph()\\r\\n n.add_edges_from(result)\\r\\n\\r\\n # draw the graph\\r\\n if draw_graph:\\r\\n nx.draw_networkx(n)\\r\\n plt.show()\\r\\n \\r\\n if save_graph:\\r\\n return n\\r\\n\\r\\n except:\\r\\n print(\\\"The node you are looking for is not in the graph. Try again\\\")\",\n \"def __induced_subgraph_helper(G, edge):\\n first_incident_node = \\\\\\n GraphProcessing.search_node_names(\\n G.get_nodeset(),\\n edge.get_first_incident_node().get_name()\\n ).pop() # obtain the disconnected copy of the first incident node\\n\\n second_incident_node = \\\\\\n GraphProcessing.search_node_names(\\n G.get_nodeset(),\\n edge.get_second_incident_node().get_name()\\n ).pop() # obtain the disconnected copy of the second incident node\\n\\n G.add_edge(\\n edge.get_weight(),\\n dict(edge.get_attributes()),\\n first_incident_node,\\n second_incident_node\\n ) # create and add the duplicate edge to the subgraph\\n\\n return G\",\n \"def draw_relation_graph(database_name, table_name, primary_key, group_name) -> Graph:\\n\\n nodes = []\\n links = []\\n disease_list = get_icd_diseasegroup_diseaseinfo(database_name, table_name, primary_key, group_name)[1]\\n disease_list = disease_list.split(',')\\n # print(disease_list)\\n\\n for disease in disease_list:\\n disease_node = {\\n \\\"name\\\": disease,\\n \\\"symbolSize\\\": 50\\n }\\n\\n if disease_node not in nodes:\\n nodes.append(disease_node)\\n\\n gene_list = get_mesh_disease_info(database_name, 'mesh_gene', disease, 'DISEASE_ID')[1]\\n gene_list = gene_list.split(',')\\n for gene in gene_list:\\n gene_node = {\\n 'name': gene,\\n 'symbolSize': 10\\n }\\n\\n if gene_node not in nodes:\\n nodes.append(gene_node)\\n\\n for gene in gene_list:\\n links.append({\\\"source\\\": disease, \\\"target\\\": gene})\\n\\n print(nodes)\\n print(links)\\n\\n c = (\\n Graph(init_opts=opts.InitOpts(width=\\\"1440px\\\", height=\\\"900px\\\")).add(\\\"\\\", nodes, links, repulsion=3000)\\n .set_global_opts(title_opts=opts.TitleOpts(title=\\\"gene-disease association network\\\"))\\n )\\n\\n return c\",\n \"def merge_graphs(\\n graph: DiGraph,\\n ) -> Tuple[list[str], GraphAccess, Generator[Tuple[str, GraphAccess], None, None]]:\\n\\n # Find merge nodes: all nodes that are marked as merge node -> all children (merge roots) should be merged.\\n # This method returns all merge roots as key, with the respective predecessor nodes as value.\\n def merge_roots() -> dict[str, set[str]]:\\n graph_root = GraphAccess.root_id(graph)\\n merge_nodes = [node_id for node_id, data in graph.nodes(data=True) if data.get(\\\"merge\\\", False)]\\n assert len(merge_nodes) > 0, \\\"No merge nodes provided in the graph. Mark at least one node with merge=true!\\\"\\n result: dict[str, set[str]] = {}\\n for node in merge_nodes:\\n # compute the shortest path from root to here and sort out all successors that are also predecessors\\n pres: set[str] = reduce(lambda res, p: res | set(p), all_shortest_paths(graph, graph_root, node), set())\\n for a in graph.successors(node):\\n if a not in pres:\\n result[a] = pres\\n return result\\n\\n # Walk the graph from given starting node and return all successors.\\n # A successor which is also a predecessor is not followed.\\n def sub_graph_nodes(from_node: str, parent_ids: set[str]) -> set[str]:\\n to_visit = [from_node]\\n visited: set[str] = {from_node}\\n\\n def successors(node: str) -> list[str]:\\n return [a for a in graph.successors(node) if a not in visited and a not in parent_ids]\\n\\n while to_visit:\\n to_visit = reduce(lambda li, node: li + successors(node), to_visit, [])\\n visited.update(to_visit)\\n return visited\\n\\n # Create a generator for all given merge roots by:\\n # - creating the set of all successors\\n # - creating a subgraph which contains all predecessors and all succors\\n # - all predecessors are marked as visited\\n # - all predecessor edges are marked as visited\\n # This way it is possible to have nodes in the graph that will not be touched by the update\\n # while edges will be created from successors of the merge node to predecessors of the merge node.\\n def merge_sub_graphs(\\n root_nodes: dict[str, set[str]], parent_nodes: set[str], parent_edges: set[Tuple[str, str, str]]\\n ) -> Generator[Tuple[str, GraphAccess], None, None]:\\n all_successors: Set[str] = set()\\n for root, predecessors in root_nodes.items():\\n successors: set[str] = sub_graph_nodes(root, predecessors)\\n # make sure nodes are not \\\"mixed\\\" between different merge nodes\\n overlap = successors & all_successors\\n if overlap:\\n raise AttributeError(f\\\"Nodes are referenced in more than one merge node: {overlap}\\\")\\n all_successors |= successors\\n # create subgraph with all successors and all parents, where all parents are already marked as visited\\n sub = GraphAccess(graph.subgraph(successors | parent_nodes), root, parent_nodes, parent_edges)\\n yield root, sub\\n\\n roots = merge_roots()\\n parents: set[str] = reduce(lambda res, ps: res | ps, roots.values(), set())\\n parent_graph = graph.subgraph(parents)\\n graphs = merge_sub_graphs(roots, parents, set(parent_graph.edges(data=\\\"edge_type\\\")))\\n return list(roots.keys()), GraphAccess(parent_graph, GraphAccess.root_id(graph)), graphs\",\n \"def get_subgraph_from_paths(self, paths):\\n nodes, edges = graph_elements_from_paths(paths)\\n subgraph = self.graph.subgraph(nodes).edge_subgraph(edges)\\n return subgraph\",\n \"def reverse_graph(self):\\n rgraph = DGraph()\\n rgraph.graph = deepcopy(self.graph)\\n\\n for node in rgraph.graph:\\n node.data.children, node.data.parents = node.data.parents, node.data.children\\n\\n return rgraph\",\n \"def ExtractSubmatrix(adjmatrix, nodelist1, nodelist2=[]):\\n # 0) CHECK WHETHER LISTS OF NODES ARE GIVEN AS ARRAYS. OTHERWISE, CONVERT.\\n # Check nodelist1\\n if type(nodelist1) != np.ndarray:\\n # warnings.simplefilter('once', UserWarning)\\n # warnings.warn(\\\"Prefered type for parameter 'nodelist1' is numpy.ndarray. Lists, tuples and sets are allowed but are converted to ndarrays.\\\", \\\\\\n # stacklevel=2)\\n\\n if type(nodelist1) == set:\\n nodelist1 = list(nodelist1)\\n if type(nodelist1) in [list, tuple]:\\n nodelist1 = np.array(nodelist1,np.int)\\n\\n # Check nodelist2\\n if len(nodelist2) == 0:\\n nodelist2 = nodelist1.copy()\\n else:\\n if type(nodelist2) != np.ndarray:\\n # warnings.simplefilter('once', UserWarning)\\n # warnings.warn(\\\"Prefered type for parameter 'nodelist2' is numpy.ndarray. Lists, tuples and sets are allowed but are converted to ndarrays.\\\", \\\\\\n # stacklevel=2)\\n\\n if type(nodelist2) == set:\\n nodelist2 = list(nodelist2)\\n if type(nodelist2) in [list, tuple]:\\n nodelist2 = np.array(nodelist2,np.int)\\n\\n # 1) CREATE LISTS OF INDICES FOR SLICING\\n N1 = len(nodelist1)\\n N2 = len(nodelist2)\\n xindices = np.zeros(N1*N2, np.int)\\n for ncounter, node in enumerate(nodelist1):\\n startidx = ncounter*N2\\n endidx = startidx + N2\\n xindices[startidx:endidx] = node\\n\\n yindices = np.zeros(N1*N2, np.int)\\n for n in range(N1):\\n startidx = n*N2\\n endidx = startidx + N2\\n yindices[startidx:endidx] = nodelist2\\n\\n # 2) EXTRACT THE SUBMATRIX AND FINISH\\n return adjmatrix[xindices, yindices].reshape(N1, N2)\",\n \"def subgroups(self):\\n db = self['__store'].db\\n my_subgroups = {\\n group_id\\n for group_id, in db(\\\"\\\"\\\"\\n select distinct\\n subgroup_id\\n from subgroups, groups\\n where\\n id = group_id\\n and group_id = %s\\n and groups.type = 'U'\\n \\\"\\\"\\\",\\n self._id)\\n }\\n return my_subgroups\",\n \"def parse_subgraph(subgraph_nodes, graph, ass_matrix):\\n\\n sg = graph.subgraph(subgraph_nodes)\\n sg_adj = nx.to_scipy_sparse_matrix(sg, format='csc') # New adjacency matrix.\\n sg_ass = ass_matrix[list(sg.nodes)]\\n\\n return sg_adj, sg_ass\",\n \"def test_documentation_popxl_create_multi_subgraph(self):\\n filename = \\\"create_multi_graphs_from_same_func.py\\\"\\n self.run_python(filename, file_dir=working_dir, working_dir=working_dir)\",\n \"def _format_subgraph_dihedral(m, top):\\n (sort_by_n_connections, small) = _get_sorted_by_n_connections(m)\\n start = sort_by_n_connections[0]\\n if sort_by_n_connections[2] in small.neighbors(start):\\n mid1 = sort_by_n_connections[2]\\n mid2 = sort_by_n_connections[3]\\n else:\\n mid1 = sort_by_n_connections[3]\\n mid2 = sort_by_n_connections[2]\\n\\n end = sort_by_n_connections[1]\\n return (\\n top.get_index(start),\\n top.get_index(mid1),\\n top.get_index(mid2),\\n top.get_index(end),\\n )\",\n \"def _filter_edges(self, edges_filtered):\\n return [\\n edge\\n for edge in edges_filtered\\n if edge[0] in self.nodes_ids and edge[1] in self.nodes_ids\\n ]\",\n \"def extract_edges(graph):\\n return graph.get_edges()\",\n \"def subgraph_is_isomorphic(graph, subgraph):\\n graph_gspan = networkx_to_gspan(graph, 0)\\n subgraph_gspan = networkx_to_gspan(subgraph, 1)\\n\\n # create temporary files during gspan processing\\n input_fd, input_filename = tempfile.mkstemp()\\n output_fd, output_filename = tempfile.mkstemp()\\n\\n with os.fdopen(input_fd, 'w', encoding='utf-8') as input_handler:\\n input_handler.write(graph_gspan + subgraph_gspan)\\n orig_stdout = sys.stdout\\n sys.stdout = os.fdopen(output_fd, 'w', encoding='utf-8')\\n subgraph_miner = gSpan(input_filename, 2, where=True)\\n subgraph_miner.run()\\n sys.stdout = orig_stdout\\n mined_subgraphs = parse_mined_gspan_file(output_filename)\\n\\n # remove temporary files\\n os.remove(input_filename)\\n os.remove(output_filename)\\n\\n em = iso.numerical_edge_match('weight', 0)\\n nm = iso.categorical_node_match('name', None)\\n for mined_subgraph in mined_subgraphs:\\n graph_matcher = iso.GraphMatcher(mined_subgraph, subgraph, node_match=nm, edge_match=em)\\n if graph_matcher.is_isomorphic():\\n return True\\n return False\",\n \"def nodegraph(self):\\n return self._nodegraph\",\n \"def subsets(self, sub_ids, sub_args_lst=None):\\n\\n indices = [[self.ids.index(id_) for id_ in ids] for ids in sub_ids]\\n if sub_args_lst is not None:\\n subsets = [Subset(dataset=self, indices=index, sub_attrib_args=args)\\n for index, args in zip(indices, sub_args_lst)]\\n else:\\n subsets = [Subset(dataset=self, indices=index) for index in indices]\\n return subsets\",\n \"def sub_set(self, idcs):\\n return SubSet(dset=self, idcs=idcs)\",\n \"def dump_subgraph_for_debug(self):\\n\\n import pypipegraph2 as ppg\\n\\n nodes = []\\n seen = set()\\n edges = []\\n counter = [0]\\n node_to_counters = {}\\n\\n def descend(node):\\n if node in seen:\\n return\\n seen.add(node)\\n j = self.runner.jobs[node]\\n if isinstance(j, ppg.FileInvariant):\\n nodes.append(f\\\"Path('{counter[0]}').write_text('A')\\\")\\n nodes.append(f\\\"job_{counter[0]} = ppg.FileInvariant('{counter[0]}')\\\")\\n elif isinstance(j, ppg.ParameterInvariant):\\n nodes.append(\\n f\\\"job_{counter[0]} = ppg.ParameterInvariant('{counter[0]}', 55)\\\"\\n )\\n elif isinstance(j, ppg.FunctionInvariant):\\n nodes.append(\\n f\\\"job_{counter[0]} = ppg.FunctionInvariant('{counter[0]}', lambda: 55)\\\"\\n )\\n elif isinstance(j, ppg.SharedMultiFileGeneratingJob):\\n nodes.append(\\n f\\\"job_{counter[0]} = ppg.SharedMultiFileGeneratingJob('{counter[0]}', {[x.name for x in j.files]!r}, dummy_smfg, depend_on_function=False)\\\"\\n )\\n elif isinstance(j, ppg.TempFileGeneratingJob):\\n nodes.append(\\n f\\\"job_{counter[0]} = ppg.TempFileGeneratingJob('{counter[0]}', dummy_fg, depend_on_function=False)\\\"\\n )\\n elif isinstance(j, ppg.FileGeneratingJob):\\n nodes.append(\\n f\\\"job_{counter[0]} = ppg.FileGeneratingJob('{counter[0]}', dummy_fg, depend_on_function=False)\\\"\\n )\\n elif isinstance(j, ppg.MultiTempFileGeneratingJob):\\n files = [counter[0] + \\\"/\\\" + x.name for x in j.files]\\n nodes.append(\\n f\\\"job_{counter[0]} = ppg.MultiTempFileGeneratingJob({files!r}, dummy_mfg, depend_on_function=False)\\\"\\n )\\n elif isinstance(j, ppg.MultiFileGeneratingJob):\\n files = [str(counter[0]) + \\\"/\\\" + x.name for x in j.files]\\n nodes.append(\\n f\\\"job_{counter[0]} = ppg.MultiFileGeneratingJob({files!r}, dummy_mfg, depend_on_function=False)\\\"\\n )\\n elif isinstance(j, ppg.DataLoadingJob):\\n nodes.append(\\n f\\\"job_{counter[0]} = ppg.DataLoadingJob('{counter[0]}', lambda: None, depend_on_function=False)\\\"\\n )\\n elif isinstance(j, ppg.AttributeLoadingJob):\\n nodes.append(\\n f\\\"job_{counter[0]} = ppg.AttributeLoadingJob('{counter[0]}', DummyObject(), 'attr_{counter[0]}', lambda: None, depend_on_function=False)\\\"\\n )\\n else:\\n raise ValueError(j)\\n node_to_counters[node] = counter[0]\\n counter[0] += 1\\n for parent in self.runner.dag.predecessors(node):\\n descend(parent)\\n\\n def build_edges(node):\\n for parent in self.runner.dag.predecessors(node):\\n edges.append(\\n f\\\"edges.append(('{node_to_counters[node]}', '{node_to_counters[parent]}'))\\\"\\n )\\n build_edges(parent)\\n\\n descend(self.job_id)\\n edges.append(\\\"edges = []\\\")\\n build_edges(self.job_id)\\n edges.extend(\\n [\\n \\\"for (a,b) in edges:\\\",\\n \\\" if a in ppg.global_pipegraph.jobs and b in ppg.global_pipegraph.jobs:\\\",\\n \\\" ppg.global_pipegraph.jobs[a].depends_on(ppg.global_pipegraph.jobs[b])\\\",\\n ]\\n )\\n with open(\\\"subgraph_debug.py\\\", \\\"w\\\") as op:\\n lines = \\\"\\\"\\\"\\nclass DummyObject:\\n pass\\n\\ndef dummy_smfg(files, prefix):\\n Path(prefix).mkdir(exist_ok=True, parents=True)\\n for f in files:\\n f.write_text(\\\"hello\\\")\\n\\n\\ndef dummy_mfg(files):\\n for f in files:\\n f.parent.mkdir(exist_ok=True, parents=True)\\n f.write_text(\\\"hello\\\")\\n\\ndef dummy_fg(of):\\n of.parent.mkdir(exist_ok=True, parents=True)\\n of.write_text(\\\"fg\\\")\\n\\n\\\"\\\"\\\".split(\\n \\\"\\\\n\\\"\\n )\\n lines += nodes\\n lines += edges\\n lines += [\\\"\\\", \\\"ppg.run()\\\", \\\"ppg.run\\\"]\\n\\n op.write(\\\"\\\\n\\\".join(\\\" \\\" + l for l in lines))\",\n \"def get_children_from_redis(gmac_id, as_objects=True):\\n conn = get_redis_connection()\\n klass = GoogleMapsAddressComponent\\n results = []\\n queue = []\\n children = klass.get_children_id_list_from_redis_by_pk(gmac_id)\\n results.extend(children)\\n queue.extend(children)\\n while len(queue) > 0:\\n node = queue.pop()\\n children = klass.get_children_id_list_from_redis_by_pk(node)\\n results.extend(children)\\n queue.extend(children)\\n if as_objects:\\n results = klass.objects.filter(pk__in=results)\\n return results\",\n \"def link_entities_to_publication(entities: list, publication: Node, sub_graph) -> Subgraph:\\n for entity in entities:\\n if 'OntologyClass' not in list(entity.labels):\\n sub_graph |= Relationship(entity, 'located_in', publication)\\n return sub_graph\",\n \"def test_DRGEP_GraphSearchDouble(self):\\n graph = nx.DiGraph()\\n graph.add_nodes_from(['A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', \\n 'L', 'M', 'N', 'O'\\n ])\\n\\n graph.add_weighted_edges_from([('A','B', 2), ('B','C',2), ('C','D',2),\\n ('D','E',2), ('E','F',2)\\n ])\\n\\n subgraph = nx.DiGraph([(u,v,d) for u,v,d in graph.edges(data=True) if d['weight'] > 0])\\n\\n\\n #temporary solution\\n max_dic = graph_search_drgep(subgraph, 'A')\\n\\n assert 'A' in max_dic\\n assert max_dic['A']==1\\n assert max_dic['B']==2\\n assert max_dic['C']==4\\n assert max_dic['D']==8\\n assert max_dic['E']==16\\n assert max_dic['F']==32\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.7035432","0.6588273","0.651714","0.6372824","0.6290915","0.6162915","0.5933553","0.59246063","0.59132445","0.5816567","0.57999897","0.57736963","0.57541233","0.5741261","0.566491","0.5662782","0.5647418","0.5560412","0.5558986","0.5549748","0.55334896","0.55267966","0.5501927","0.5494239","0.54907703","0.5477043","0.5476478","0.547607","0.54426557","0.5414528","0.54135996","0.54078424","0.53960705","0.5387023","0.5374935","0.53479904","0.5342718","0.5320929","0.53113645","0.5295102","0.5275289","0.52697897","0.52610505","0.5245657","0.5243684","0.52393425","0.52354854","0.5216431","0.5214494","0.5203827","0.5189648","0.5181484","0.51814735","0.5167224","0.5166841","0.51624674","0.51615214","0.5154311","0.5152292","0.5148293","0.51451373","0.5143402","0.5143039","0.51030844","0.5102845","0.50948876","0.50883245","0.50870985","0.50759536","0.5065187","0.5062148","0.50506604","0.5043859","0.5043744","0.5040984","0.5038121","0.503291","0.5028334","0.5010997","0.5006934","0.5005047","0.49727574","0.49636835","0.49621436","0.4958462","0.4951507","0.492984","0.49294233","0.4927989","0.4925036","0.4910316","0.48911384","0.48870966","0.4880161","0.4876012","0.48721418","0.48704293","0.48695022","0.48690486","0.48533982"],"string":"[\n \"0.7035432\",\n \"0.6588273\",\n \"0.651714\",\n \"0.6372824\",\n \"0.6290915\",\n \"0.6162915\",\n \"0.5933553\",\n \"0.59246063\",\n \"0.59132445\",\n \"0.5816567\",\n \"0.57999897\",\n \"0.57736963\",\n \"0.57541233\",\n \"0.5741261\",\n \"0.566491\",\n \"0.5662782\",\n \"0.5647418\",\n \"0.5560412\",\n \"0.5558986\",\n \"0.5549748\",\n \"0.55334896\",\n \"0.55267966\",\n \"0.5501927\",\n \"0.5494239\",\n \"0.54907703\",\n \"0.5477043\",\n \"0.5476478\",\n \"0.547607\",\n \"0.54426557\",\n \"0.5414528\",\n \"0.54135996\",\n \"0.54078424\",\n \"0.53960705\",\n \"0.5387023\",\n \"0.5374935\",\n \"0.53479904\",\n \"0.5342718\",\n \"0.5320929\",\n \"0.53113645\",\n \"0.5295102\",\n \"0.5275289\",\n \"0.52697897\",\n \"0.52610505\",\n \"0.5245657\",\n \"0.5243684\",\n \"0.52393425\",\n \"0.52354854\",\n \"0.5216431\",\n \"0.5214494\",\n \"0.5203827\",\n \"0.5189648\",\n \"0.5181484\",\n \"0.51814735\",\n \"0.5167224\",\n \"0.5166841\",\n \"0.51624674\",\n \"0.51615214\",\n \"0.5154311\",\n \"0.5152292\",\n \"0.5148293\",\n \"0.51451373\",\n \"0.5143402\",\n \"0.5143039\",\n \"0.51030844\",\n \"0.5102845\",\n \"0.50948876\",\n \"0.50883245\",\n \"0.50870985\",\n \"0.50759536\",\n \"0.5065187\",\n \"0.5062148\",\n \"0.50506604\",\n \"0.5043859\",\n \"0.5043744\",\n \"0.5040984\",\n \"0.5038121\",\n \"0.503291\",\n \"0.5028334\",\n \"0.5010997\",\n \"0.5006934\",\n \"0.5005047\",\n \"0.49727574\",\n \"0.49636835\",\n \"0.49621436\",\n \"0.4958462\",\n \"0.4951507\",\n \"0.492984\",\n \"0.49294233\",\n \"0.4927989\",\n \"0.4925036\",\n \"0.4910316\",\n \"0.48911384\",\n \"0.48870966\",\n \"0.4880161\",\n \"0.4876012\",\n \"0.48721418\",\n \"0.48704293\",\n \"0.48695022\",\n \"0.48690486\",\n \"0.48533982\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.819001"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":89897,"cells":{"query":{"kind":"string","value":"Finds matching pairs of nodeids between small_dmrs and large_dmrs."},"document":{"kind":"string","value":"def get_matching_nodeids(small_dmrs, large_dmrs, all_surface=False):\n sorted_small_nodes = sort_nodes(small_dmrs.nodes)\n sorted_large_nodes = sort_nodes(large_dmrs.nodes)\n\n longest_matches = find_longest_matches(sorted_small_nodes, sorted_large_nodes) # list (of lists) of tuples (id_from_sub, id)\n\n all_matched_nodeids = []\n for match in longest_matches:\n matched_large_orderids = list(zip(*match))[1] # [(order ids from small dmrs), (order ids from the\n paired_nodeids = get_matched_nodeids_from_orderids(sorted_small_nodes, sorted_large_nodes, match)\n if all_surface:\n extra_overlap_nodeids = find_extra_surface_overlap(matched_large_nodeids, sorted_large_nodes)\n paired_nodeids.extend([(None, nodeid) for nodeid in extra_overlap_nodeids])\n all_matched_nodeids.append(paired_nodeids)\n\n return all_matched_nodeids"},"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 get_matched_nodeids_from_orderids(sorted_small_nodes, sorted_large_nodes, matched_orderids):\n orderid2nodeid_func = lambda order_pair: (sorted_small_nodes[order_pair[0]].nodeid, sorted_large_nodes[order_pair[1]].nodeid)\n return list(map(orderid2nodeid_func, matched_orderids))","def get_matches(self, first, second):\n matches = self._match_table.dropna(0)[\n [first.position.id, second.position.id]].astype(int).values\n return matches","def sm_get_matching_blocks(s1,s2,min_length=1):\n anslist= list(SM(None, s1, s2).get_matching_blocks())\n\n\n anslist = [ l for l in anslist if l.size>=min_length]\n\n anslist=[ (s1[l.a:l.a+l.size], l.a, l.b, l.size) for l in anslist]\n return anslist","def compare_nodes(G,all_match_pairs,match_pair,traversed,node1,node2, ports_weight):\n logger.debug(f\"comparing {node1},{node2}, traversed {traversed}\")\n nbrs1 = sorted(set(G.neighbors(node1)) - set(traversed))\n #remove dummies\n nbrs1 = sorted(set([nbr for nbr in nbrs1 if G.get_edge_data(node1, nbr)['weight'] !=7]))\n nbrs2 = sorted(set(G.neighbors(node2)) - set(traversed))\n #remove dummies\n nbrs2 = sorted(set([nbr for nbr in nbrs2 if G.get_edge_data(node2, nbr)['weight'] !=7]))\n logger.debug(f\"node1:{node1},property: {G.nodes[node1]},neigbors1: {nbrs1}\")\n logger.debug(f\"node2:{node2},property: {G.nodes[node2]},neigbors2: {nbrs2}\")\n if not nbrs1 or not nbrs2:\n if compare_two_nodes(G, node1, node2, ports_weight):\n match_pair[node1] = node2\n logger.debug(f\"no new neihbours, returning recursion {match_pair}\")\n return\n elif len(nbrs1)> 10:\n if \"start_point\" in match_pair.keys():\n match_pair[\"start_point\"]+=[node1,node2]\n else:\n match_pair[\"start_point\"]=[node1,node2]\n logger.debug(f\"skipping high fanout nets due to large computation, {node1} {nbrs1}\")\n traversed.append(node1)\n return\n elif len(nbrs2)> 10:\n if \"start_point\" in match_pair.keys():\n match_pair[\"start_point\"]+=[node1,node2]\n else:\n match_pair[\"start_point\"]=[node1,node2]\n traversed.append(node2)\n logger.debug(f\"skipping high fanout nets due to large computation, {node2} {nbrs2}\")\n return\n\n if node1 == node2:\n if node1 in match_pair.keys() or node1 in match_pair.values():\n logger.debug(\"avoid existing pair wise symmetry\")\n return\n logger.debug(f\"single node {node1}, nbrs {nbrs1}, nbr_weight {[G.get_edge_data(node1,nbr) for nbr in nbrs1]}\")\n SD_nbrs= [nbr for nbr in nbrs1 if G.get_edge_data(node1, nbr)['weight'] !=2]\n ## TBD: filter based on primitive constraints\n ## Right now will try to figure out S/D paths\n if len(SD_nbrs) ==0:\n logger.debug(f\"No SD paths found to traverse\")\n match_pair[node1]=node1\n elif len(SD_nbrs) ==1:\n logger.debug(f\"traversing single S/D path {SD_nbrs}\")\n match_pair[node1]=node1\n traversed.append(node1)\n compare_nodes(G,all_match_pairs,match_pair,traversed,SD_nbrs[0],SD_nbrs[0],ports_weight)\n else:\n logger.debug(f\" multiple nodes diverging {SD_nbrs}\")\n logger.debug(f\"nbr weights: {SD_nbrs} {[G.get_edge_data(node1, nbr)['weight'] for nbr in SD_nbrs ]}\")\n match_pair[node1]=node1\n traversed.append(node1)\n new_sp=sorted(set(SD_nbrs)-set(traversed))\n all_match_pairs_local={}\n for nbr1,nbr2 in combinations(new_sp, 2):\n logger.debug(f\"recursive pair call from single branch {nbr1} {nbr2}\")\n new_pair={}\n compare_nodes(G,all_match_pairs,new_pair,traversed.copy(),nbr1,nbr2,ports_weight)\n if new_pair:\n #new_pair[nbr1]=nbr2\n all_match_pairs_local[nbr1+'_'+nbr2] = new_pair\n all_match_pairs_local={k: v for k, v in all_match_pairs_local.items() if len(v)>0}\n if len(all_match_pairs_local)==1:\n match_pair.update( all_match_pairs_local[list(all_match_pairs_local.keys())[0]])\n logger.debug(f\"found inline pair: {pprint.pformat(match_pair, indent=4)}\")\n else:\n for nbr1 in new_sp:\n if (nbr1+'_'+nbr1 not in all_match_pairs.keys()):\n logger.debug(f\"recursive single branch call from single branch {nbr1} {nbr1}\")\n new_pair={}\n compare_nodes(G,all_match_pairs,new_pair,traversed.copy(),nbr1,nbr1,ports_weight)\n #filtering multiple axis of symmetries with same block, ideally they should be handled by array generation\n if new_pair:\n all_match_pairs[nbr1+'_'+nbr1] = new_pair\n logger.debug(f\"updating match pairs: {pprint.pformat(all_match_pairs, indent=4)}\")\n\n\n elif nbrs1 == nbrs2:\n logger.debug(f\"traversing converging branch\")\n match_pair[node1]=node2\n traversed+=[node1,node2]\n nbrs1=sorted(set(nbrs1)-set([node1,node2]))\n logger.debug(f\"all non traversed neighbours: {nbrs1}\")\n if len(nbrs1)==1:\n nbr1=nbr2=nbrs1[0]\n logger.debug(f\"keeping single converged branch inline {nbr1} {nbr2}\")\n compare_nodes(G,all_match_pairs,match_pair,traversed.copy(),nbr1,nbr2,ports_weight)\n else:\n for nbr1,nbr2 in combinations_with_replacement(nbrs1,2):\n logger.debug(f\"recursive call from converged branch {nbr1} {nbr2}\")\n if nbr1+'_'+nbr2 not in all_match_pairs.keys():\n new_pair={}\n compare_nodes(G,all_match_pairs,new_pair,traversed.copy(),nbr1,nbr2,ports_weight)\n #filtering multiple axis of symmetries with same block, ideally they should be handled by array generation\n if new_pair:\n all_match_pairs[nbr1+'_'+nbr2] = new_pair\n logger.debug(f\"updating match pairs: {pprint.pformat(all_match_pairs, indent=4)}\")\n\n\n elif compare_two_nodes(G,node1,node2,ports_weight):\n nbrs1 = sorted(set([nbr for nbr in nbrs1 if G.get_edge_data(node1, nbr)['weight'] !=2]))\n nbrs2 = sorted(set([nbr for nbr in nbrs2 if G.get_edge_data(node2, nbr)['weight'] !=2]))\n match_pair[node1]=node2\n traversed+=[node1,node2]\n logger.debug(f\"Traversing parallel branches from {node1},{node2} {nbrs1}, {nbrs2}\")\n nbrs1_wt = [G.get_edge_data(node1, nbr)['weight'] for nbr in nbrs1]\n nbrs2_wt = [G.get_edge_data(node2, nbr)['weight'] for nbr in nbrs2]\n unique_match=find_unique_matching_branches(G,nbrs1,nbrs2,ports_weight)\n if len(nbrs1)==0 or len(nbrs2)==0:\n logger.debug(f\"no new SD neihbours, returning recursion {match_pair}\")\n elif len(nbrs1) ==1 and len(nbrs2)==1:\n logger.debug(f\"traversing binary branch\")\n compare_nodes(G,all_match_pairs,match_pair,traversed,nbrs1.pop(),nbrs2.pop(),ports_weight)\n elif unique_match:\n logger.debug(f'traversing unique matches {unique_match}')\n match_pair[node1]=node2\n traversed+=[node1,node2]\n for nbr1,nbr2 in unique_match.items():\n logger.debug(f\"recursive call from binary {node1}:{node2} to {nbr1}:{nbr2}\")\n compare_nodes(G,all_match_pairs,match_pair,traversed.copy(),nbr1,nbr2,ports_weight)\n elif len(nbrs1_wt)>len(set(nbrs1_wt))>1 and len(nbrs2_wt)>len(set(nbrs2_wt))>1:\n logger.debug(f\"setting new start points {node1} {node2}\")\n match_pair[node1]=node2\n if \"start_point\" in match_pair.keys():\n match_pair[\"start_point\"]+=[node1,node2]\n else:\n match_pair[\"start_point\"]=[node1,node2]\n else:\n match_pair = {}\n logger.debug(f\"end all traversal from binary branch {node1} {node2}\")\n\n else:\n match_pair = {}\n logger.debug(f\"end of recursion branch, matches {match_pair}\")","def distance_mentions(m_i, m_j):\n return abs(m_i.id - m_j.id)","def nn_set2set_match(descs1, descs2):\n idxs = nn_set2set_match_cuda(descs1.unsqueeze(0).cuda(), descs2.unsqueeze(0).cuda()).detach().cpu().long()\n return idxs[0]","def find_extra_surface_nodeids(orderids, sorted_large_nodes):\n extra_nodeids = []\n first_overlap_orderid = orderids[0]\n min_cfrom = sorted_nodes[first_overlap_orderid].cfrom\n\n # Check if any earlier nodes also in the region.\n while True:\n prev_cfrom = sorted_nodes[first_overlap_orderid-1].cfrom\n if prev_cfrom == min_cfrom:\n first_overlap_orderid -= 1\n extra_nodeids.append(sorted_nodes[first_overlap_orderid].nodeid)\n else:\n break\n\n # Find the last node in the region.\n last_overlap_orderid = matched_orderids[-1]\n max_cto = sorted_nodes[last_overlap_orderid].cto\n for i in range(first_overlap_orderid, len(sorted_nodes)):\n if sorted_nodes[i].cfrom > max_cto:\n break\n else:\n if i not in orderids:\n extra_nodeids.append(sorted_nodes[i].nodeid)\n cto = sorted_nodes[i].cto\n if cto >= max_cto:\n max_cto = cto\n if i > last_overlap_orderid:\n last_overlap_orderid = i\n\n return extra_nodeids","def solve_part1(start):\n inputs = load_inputs(False)\n two_matches = []\n tiles = inputs.keys()\n for elem in tiles:\n matches = defaultdict(list)\n for elem2 in tiles:\n if elem != elem2 and compare_tile(inputs[elem], inputs[elem2]):\n l = matches[elem]\n l.append(elem2)\n\n if len(matches[elem]) == 2:\n print matches\n two_matches.append(elem)\n\n return reduce((lambda x, y: int(x) * int(y)), two_matches)","def __find_similar_pairs(self):\n size = len(self.__indexclusters)\n candidates = []\n for i in range(size):\n for j in range(i+1, size):\n simi = self.__cluster_simi(i, j)\n #print simi, self.__indexclusters[i],self.__indexclusters[j]\n if simi >= self.__threshold:\n candidates.append((simi, i, j))\n candidates.sort(reverse = True, key = lambda x: x[0])\n\n\n # filter overlapped pairs\n to_remove = set()\n appeared = set()\n for index, cand in enumerate(candidates):\n if cand[1] not in appeared and cand[2] not in appeared:\n appeared.add(cand[1])\n appeared.add(cand[2])\n else:\n to_remove.add(index)\n\n #print 'ahha'\n #print [(cand[1], cand[2]) for index, cand in enumerate(candidates) if index not in to_remove]\n\n return [(cand[1], cand[2]) for index, cand in enumerate(candidates)\n if index not in to_remove]","def needleMatching(self):\r\n # productive\r\n profprint()\r\n modelNodes = slicer.mrmlScene.GetNodesByClass('vtkMRMLModelNode')\r\n nbNode = modelNodes.GetNumberOfItems()\r\n result = []\r\n found = []\r\n # print nbNode\r\n for nthNode in range(nbNode):\r\n node = slicer.mrmlScene.GetNthNodeByClass(nthNode, 'vtkMRMLModelNode')\r\n if node.GetID() not in found and node.GetAttribute('type') != 'Validation':\r\n dist = []\r\n polydata = node.GetPolyData()\r\n if polydata != None:\r\n bounds = polydata.GetBounds()\r\n for nthNode2 in range(nbNode):\r\n node2 = slicer.mrmlScene.GetNthNodeByClass(nthNode2, 'vtkMRMLModelNode')\r\n if node2.GetID() not in found and node2.GetAttribute('type') == 'Validation':\r\n polydata2 = node2.GetPolyData()\r\n if polydata2 != None and polydata2.GetNumberOfPoints() > 100 and polydata.GetNumberOfPoints() > 100:\r\n tipDistance = self.distTip(int(node.GetID().strip('vtkMRMLModelNode')) , int(node2.GetID().strip('vtkMRMLModelNode')))\r\n baseDistance = self.distBase(int(node.GetID().strip('vtkMRMLModelNode')) , int(node2.GetID().strip('vtkMRMLModelNode')))\r\n name = node.GetName()\r\n manualName = name.lstrip('auto-seg_').lstrip('manual-seg_').lstrip('obturator-seg_').lstrip('0123456789').lstrip('-ID-vtkMRMLModelNode').lstrip('0123456789-')\r\n if manualName==node2.GetName(): dist.append([tipDistance, node2.GetID(), node2.GetName()])\r\n # print tipDistance\r\n if dist != []:\r\n match = [min(dist)[0], min(dist)[1], node.GetID(), min(dist)[2]]\r\n result.append(match)\r\n found.append(min(dist)[1])\r\n found.append(node.GetID())\r\n node.GetDisplayNode().SetSliceIntersectionVisibility(1)\r\n # print result\r\n return result","def nearby():\n for i in ids:\n for j in ids:\n if i != j:\n if sum([1 for x,y in zip(i,j) if x!=y]) == 1:\n print(\"\".join([x for x,y in zip(i,j) if x==y]))\n return","def selectCompatibleIndices(bigTimes, smallTimes):\r\n indices = []\r\n for idx, _ in enumerate(smallTimes):\r\n distances = (bigTimes - smallTimes[idx])**2\r\n def getValue(k):\r\n return distances[k]\r\n thisIndices = sorted(range(len(distances)), key=getValue)\r\n indices.append(thisIndices[0])\r\n return np.array(indices)","def make_compatible_distance_matrices(dm1, dm2, lookup=None):\r\n dm1_ids = dm1[0]\r\n dm1_data = dm1[1]\r\n dm2_ids = dm2[0]\r\n dm2_data = dm2[1]\r\n\r\n if lookup:\r\n try:\r\n dm1_ids = [lookup[e] for e in dm1_ids]\r\n dm2_ids = [lookup[e] for e in dm2_ids]\r\n except KeyError as e:\r\n raise KeyError(\"All entries in both DMs must be in lookup if a \"\r\n \"lookup is provided. Missing: %s\" % str(e))\r\n order = [e for e in dm1_ids if e in dm2_ids]\r\n\r\n if len(order) == 0:\r\n return ([], []), ([], [])\r\n\r\n # store the intersected distance matrices here\r\n matrices = []\r\n\r\n # iterate over the distance matrices and identifiers to match the data\r\n # note that the order must be the same between the two matrices\r\n for ids, distance_matrix in [(dm1_ids, dm1_data), (dm2_ids, dm2_data)]:\r\n\r\n # the order is kept by getting the indices from this list\r\n indices = [ids.index(element) for element in order]\r\n\r\n # this matrix contains the matched up data\r\n out = distance_matrix[indices][:, indices]\r\n matrices.append(out)\r\n\r\n return (order, matrices[0]), (order, matrices[1])","def find_mutual_nn(self):\n best_match_src = self.scores.argmax(1) # Best match for each source word\n best_match_trg = self.scores.argmax(0) # Best match for each source word\n\n # ONELIENER\n # paired_idx = [(i,best_match_src[i]) for i in range(self.ns) if best_match_trg[best_match_src[i]] == i]\n # paired_words = [(self.src_words[i],self.trg_words[j]) for (i,j) in paired_idx]\n paired = []\n for i in range(self.ns):\n m = best_match_src[i]\n if best_match_trg[m] == i:\n paired.append((i,m))\n\n paired_toks = []\n if self.src_words and self.trg_words:\n paired_toks = [(self.src_words[i],self.trg_words[j]) for (i,j) in paired]\n else:\n paired_toks = paired\n return paired_toks","def compare_search(sizes=[1e1, 1e2, 1e3, 1e4, 1e5, 1e6, 1e7]):\n\tprint(sizes)\n\treturn [(size,\n\t\t\t time_search(linear_search, list(range(int(size))), -1),\n\t\t\t time_search(binary_search, list(range(int(size))), -1)) for size in sizes]","def match(desc1, desc2):\n desc1 = array([d/linalg.norm(d) for d in desc1])\n desc2 = array([d/linalg.norm(d) for d in desc2])\n\n dist_ratio = 0.6\n disc1_size = desc1.shape\n\n matchscores = zeros((desc1_size[0]), \"int\")\n desc2t = desc2.T\n for i in range(desc1_size[0]):\n dotprods = dot(desc1[i, :], desc2t)\n dotprods = 0.9999 * dotprods\n\n indx = argsort(arccos(dotprods))\n\n if arccos(dotprods)[indx[0]] < dist_ratio * arccos(dotprods)[indx[1]]:\n matchscores[i] = int(indx[0])\n\n return matchscores","def remove_xmatch_multiples(index_primary, index_secondary, d2d, d3d, retain_best_match=True,\n verbose=False):\n n_entries = len(index_primary)\n n_unique_entries = len(np.unique(index_primary))\n if verbose:\n print('xmatch: cleanMultipleCrossMatches: there are {0:d} unique entries in the primary '\n 'catalog'.format(n_unique_entries))\n\n if n_entries != n_unique_entries:\n # get array of unique indices (here like identifier) and the corresponding occurrence count\n unique_array, return_counts = np.unique(index_primary, return_counts=True)\n\n # indices in unique array of stars with multiple crossmatches\n index_in_unique_array = np.where(return_counts > 1)[0]\n number_of_stars_with_multiplematches = len(index_in_unique_array)\n if verbose:\n if retain_best_match:\n print('xmatch: result contains {} multiple matches affecting {} entries, '\n 'keeping closest match'.format(number_of_stars_with_multiplematches,\n n_entries - n_unique_entries))\n else:\n print('xmatch: result contains {} multiple matches affecting {} entries, removing '\n 'them all'.format(number_of_stars_with_multiplematches,\n n_entries - n_unique_entries))\n\n # identifiers (i.e. numbers in index_primary) of stars with multiple crossmatches\n multi_matches = unique_array[index_in_unique_array]\n\n # index in index_primary where multiple matches occur\n index_multiple_match = np.where(np.in1d(index_primary, multi_matches))[0]\n if verbose:\n print(d2d[index_multiple_match], index_primary[index_multiple_match], index_secondary[index_multiple_match])\n\n good_index_in_index_primary = np.zeros(number_of_stars_with_multiplematches)\n for ii, jj in enumerate(multi_matches):\n tmp_idx0 = np.where(index_primary[index_multiple_match] == jj)[0]\n tmp_idx1 = np.argmin(d2d[index_multiple_match][tmp_idx0])\n good_index_in_index_primary[ii] = index_primary[index_multiple_match][tmp_idx0[tmp_idx1]]\n\n if retain_best_match:\n index_to_remove = np.setdiff1d(index_multiple_match, good_index_in_index_primary)\n else:\n index_to_remove = index_multiple_match\n\n mask = np.ones(len(index_primary), dtype=bool)\n mask[index_to_remove] = False\n index_primary = index_primary[mask]\n index_secondary = index_secondary[mask]\n d2d = d2d[mask]\n d3d = d3d[mask]\n if len(index_primary) != len(np.unique(index_primary)):\n print('xmatch: Multiple match cleanup procedure failed')\n # get array of unique indices (here like identifier) and the corresponding occurrence count\n unique_array, return_counts = np.unique(index_primary, return_counts=True)\n\n # indices in unique array of stars with multiple crossmatches\n index_in_unique_array = np.where(return_counts > 1)[0]\n number_of_stars_with_multiplematches = len(index_in_unique_array)\n print('xmatch: result still contains {} multiple matches'.format(\n number_of_stars_with_multiplematches))\n\n return index_primary, index_secondary, d2d, d3d","def cal_similarity(query_feat, gallery_feat, q_pids, g_pids, q_camids, g_camids):\n # The larger the cosine distance, the more similar it is\n distmat = -np.matmul(query_feat, np.transpose(gallery_feat))\n num_q = query_feat.shape[0]\n num_g = gallery_feat.shape[0]\n max_rank = 10\n if num_g < max_rank:\n max_rank = num_g\n print(\"Note: number of gallery samples is quite small, got {}\".format(num_g))\n indices = np.argsort(distmat, axis=1)\n pred_label = g_pids[indices]\n matches = (pred_label == q_pids[:, np.newaxis]).astype(np.int32)\n\n return_matchs = []\n return_index = []\n\n for q_idx in range(num_q):\n q_pid = q_pids[q_idx]\n q_camid = q_camids[q_idx]\n\n # remove gallery samples that have the same pid and camid with query\n order = indices[q_idx]\n remove = (q_camid == 3) & (g_camids[order] == 2)\n keep = np.invert(remove)\n\n new_matchs = matches[q_idx][keep]\n new_index = indices[q_idx][keep]\n\n return_matchs.append(new_matchs[:10])\n return_index.append(new_index[:10])\n\n return np.asarray(return_index).astype(np.int32), np.asarray(return_matchs).astype(np.int32)","def find_matches_for_start_pairs(pairs, adj_list_ids, adj_list_words):\n all_valid = []\n for p in tqdm(pairs):\n valid = find_matches(p[0], p[1], adj_list_ids, adj_list_words)\n if valid:\n all_valid.append((p, valid))\n return all_valid","def _partition_nearest(self, medoids, dists, only_these=set()):\n if len(only_these) == 0:\n allowed_inds = self._not_ignored_inds\n else:\n allowed_inds = self._not_ignored_inds & only_these\n closest_medoid_ind = np.argmin(dists[:,medoids], 1) # If len(medoids)==3, would look like [2,1,1,0,1,2,...].\n clusts = [[] for i in medoids]\n for node_ind, med_ind in enumerate(closest_medoid_ind):\n if node_ind in allowed_inds:\n clusts[med_ind].append(node_ind)\n return clusts","def _gen_matches(target_units, source_units, stoplist_set, features_size):\n for hits2positions in gen_hits2positions(\n target_units, source_units, stoplist_set, features_size):\n overhits2positions = {\n k: np.array(v) for k, v in hits2positions.items()\n if len(v) >= 2}\n for (t_ind, s_ind), positions in overhits2positions.items():\n yield (t_ind, s_ind, positions)","def needleMatching(self):\n #productive\n profprint()\n modelNodes=slicer.mrmlScene.GetNodesByClass('vtkMRMLModelNode')\n nbNode=modelNodes.GetNumberOfItems()\n result=[]\n found=[]\n #print nbNode\n for nthNode in range(nbNode):\n node=slicer.mrmlScene.GetNthNodeByClass(nthNode,'vtkMRMLModelNode')\n if node.GetID() not in found and node.GetAttribute('type')!='Validation':\n dist=[]\n polydata = node.GetPolyData()\n if polydata!=None:\n bounds = polydata.GetBounds()\n for nthNode2 in range(nbNode):\n node2=slicer.mrmlScene.GetNthNodeByClass(nthNode2,'vtkMRMLModelNode')\n if node2.GetID() not in found and node2.GetAttribute('type')=='Validation':\n polydata2 = node2.GetPolyData()\n if polydata2!=None and polydata2.GetNumberOfPoints()>100 and polydata.GetNumberOfPoints()>100:\n\n axialDistance=self.distTip( int(node.GetID().strip('vtkMRMLModelNode')) , int(node2.GetID().strip('vtkMRMLModelNode')))\n \n dist.append([axialDistance,node2.GetID()])\n # print axialDistance\n \n if dist!=[]:\n match=[min(dist)[0],min(dist)[1],node.GetID()]\n result.append(match)\n found.append(min(dist)[1])\n found.append(node.GetID()) \n node.GetDisplayNode().SetSliceIntersectionVisibility(1)\n # print result\n return result","def match3(img1, img2, coordinates1, coordinates2, PATCH_SIZE, threshold=0.7):\n\n\t#creating patches for all points from img1 and img2\n\tcoord1_patches = [make_patch(coordinate, PATCH_SIZE, img1) for coordinate in coordinates1]\n\tcoord2_patches = [make_patch(coordinate, PATCH_SIZE, img2) for coordinate in coordinates2]\n\n\t# creating a matrix with dissimilarity measures for all pairs\n\tall_matches = np.zeros((len(coordinates1), len(coordinates2)))\n\n\tfor (x, y), _ in np.ndenumerate(all_matches):\n\t\tall_matches[x,y] = count_difference(coord1_patches[x], coord2_patches[y])\n\n\t#looking for best left-to-right and right-to-left matches\n\tmatches = []\n\t#left-to-right\n\tfor i, coord1 in enumerate(coordinates1):\n\t\tbest_ltr_match = np.argmin(all_matches[i, :]) #best left-to-right match for coord1\n\t\tbest_rtl_match = np.argmin(all_matches[:, best_ltr_match]) #best match for a best match\n\t\tif (i == best_rtl_match): #hurray, there is a super match\n\n\t\t\tmatches.append([coord1, coordinates2[best_ltr_match], all_matches[i, best_ltr_match]])\n\t\n\treturn matches","def findMatches(personDict,personDict2):\n matches = {}\n skepticalMatches = {}\n for i in range(1,19):\n if tags[i] not in ['SSN','PHONE']:\n continue\n\n dictConsidered = personDict[tags[i]]\n done = False\n\n for duplicatedEntry in dictConsidered:\n if duplicatedEntry==\"\":\n #skip the empty entries\n continue\n pairs = itertools.combinations(dictConsidered[duplicatedEntry],2)\n if done:\n break\n for p in pairs:\n if done:\n break\n\n info1 = personDict['EnterpriseID'][p[0]]\n info2 = personDict['EnterpriseID'][p[1]]\n info1b = personDict2['EnterpriseID'][p[0]]\n info2b = personDict2['EnterpriseID'][p[1]]\n k = tuple(sorted(p))\n \n if k not in matches and k not in skepticalMatches:\n if (((info1[1]==info2[1])and info1[1]!='') or((info1[2]==info2[2])and info1[2]!='') or ((info1[5]==info2[5])and info1[5]!='') ):\n score = getScorePair(info1b,info2b)\n \n \n if (abs(int(k[0])-int(k[1]))<10) and score<7:\n #This is likely not a real match\n skepticalMatches[k] = score\n else:\n #This is a real match\n matches[k] = score\n \n return matches,skepticalMatches","def find_similarity(long, short):\n similarity1 = 0\n similarity2 = 0\n for i in range(len(long)-len(short)+1):\n a = 0\n part = long[i:i+len(short)]\n for j in range(len(part)):\n if part[j] == short[j]:\n a += 1\n if a == len(short):\n similarity1 = part\n return similarity1\n elif a > similarity2:\n similarity2 = a\n similarity1 = part\n return similarity1","def find_longest_matches(sorted_nodes1, sorted_nodes2):\n root = TreeNode(-1,-1)\n fill_tree(root, sorted_nodes1, sorted_nodes2)\n match = find_treepaths(root, [])\n\n # Remove (-1, -1) superroot.\n if isinstance(match[0], list): # More than one match of the same length.\n res = []\n for m in match:\n res.append([node.to_tuple() for node in m[1:]])\n return res\n else:\n return [[node.to_tuple() for node in match[1:]]]","def common_ids(descendent_ids, ancestor_ids, threshold=0.5):\n\n common = np.intersect1d(descendent_ids, ancestor_ids)\n return common.size > threshold * ancestor_ids.size","def compare_two_grids( treecode1, treecode2 ):\n import numpy as np\n\n common_blocks = 0\n\n for i in range(treecode1.shape[0]):\n # we look for this tree code in the second array\n code1 = treecode1[i,:]\n\n for j in range(treecode2.shape[0]):\n code2 = treecode2[j,:]\n if np.linalg.norm( code2-code1 ) < 1.0e-13:\n # found code1 in the second array\n common_blocks += 1\n break\n\n print( \"Nblocks1=%i NBlocks2=%i common blocks=%i\" % (treecode1.shape[0], treecode2.shape[0], common_blocks) )\n\n return common_blocks / treecode1.shape[0]","def get_min_distances_per_query(dst, n_matches_per_query):\n print(time.asctime(), ' Sorting distances')\n start = time.time()\n query_matches = []\n for i in range(dst.shape[0]):\n midx = util.mindist(dst[i,:], n=n_matches_per_query)\n query_matches.append(midx)\n end = time.time()\n print(time.asctime(), ' Done Sorting distances in ', end-start, ' seconds', flush=True)\n return query_matches","def rh_get_match(x, y, k, d=7, hash_size=\"automatic\"):\n n = len(x)\n m = len(y)\n\n if hash_size == \"automatic\":\n q = n * m\n else:\n q = hash_size\n\n output = list()\n\n for i in range(n - k + 1):\n matches = rabin_karp_matcher(\n target=y,\n potential=x[i:i + k],\n d=d,\n q=q\n )\n\n for match in matches:\n output.append((i, match))\n\n return output","def paired_distance(self, left_ids, right_ids = None, adjusted = False, format = 'pandas'):\n if right_ids is None:\n # Default to self-distance\n right_ids = left_ids\n\n # Accept htids as well as mtids by checking the first element.\n def expand_htids(iset):\n if not '-' in list(iset)[0]:\n output = []\n for id in iset:\n output.extend(self.htid_lookup[id])\n output.sort()\n return output\n return iset\n\n left_ids, right_ids = map(expand_htids, [left_ids, right_ids])\n \n left = self.mtid_matrix(left_ids)\n right = self.mtid_matrix(right_ids)\n if adjusted:\n joint = np.concatenate((left, right))\n mediod = np.median(joint, 0)\n left = left - mediod\n right = right - mediod\n ds = (np.dot(left, right.T))\n labs = [(ida, idb) for ida in left_ids for idb in right_ids]\n if format == 'matrix':\n return (ds, (left_ids, right_ids))\n return pd.DataFrame([(a, b, c) for ((a, b), c) in (zip(labs, ds.flatten()))], columns = ['left', 'right', 'sim'])","def mass_based_dissimilarity(self, x1, x2):\n # In each i-tree, find lowest nodes containing both x and y\n # TODO: parallelize\n sum_masses = 0\n for itree in self.random_itrees:\n # Divide each sum by size of subset used to construct the trees.\n sum_masses += self.get_lowest_common_node_mass(itree, x1, x2)/self.subs_size\n return (1/len(self.random_itrees)) * sum_masses # Divide by number of space partitioning models.","def get_intersecting_dissemination_ids(cross_section, dissemination_areas):\n assert 'DAUID' in cross_section.columns \n dissem_arr = dissemination_areas.loc[dissemination_areas['DAUID'].isin(np.unique(cross_section['DAUID'].values))].DAUID.unique()\n reg_arr = dissemination_areas.loc[dissemination_areas['DAUID'].isin(np.unique(cross_section['DAUID'].values))].CSDUID.unique()\n# code_arr = dissemination_areas.loc[dissemination_areas['DAUID'].isin(np.unique(cross_section['DAUID'].values))].CODEID.unique()\n\n\n return list(dissem_arr), list(reg_arr)","def match_min(coords1,coords2,tail1=(),tail2=()):\n nc=len(coords1)\n np1=len(coords1[0])\n np2=len(coords2[0])\n a1=array(coords1)\n a2=array(coords2)\n nt1=len(tail1)\n for i in range(nt1): \n if len(tail1[i])!= np1: raise 'Not the same lenght as coordinates 1'\n nt2=len(tail2)\n for i in range(nt2): \n if len(tail2[i])!= np2: raise 'Not the same lenght as coordinates 2'\n match=zeros(np1, int)-1\n\n dist_min=zeros(np1)*1.\n\n for j in range(np1):\n #dist=sqrt(add.reduce((a1[:,j,NewAxis]-a2[:,:])**2))\n a1j = a1[:,j]\n dist=add.reduce((reshape(a1j, (len(a1j), 1)) - a2)**2)\n i_min=argmin(dist)\n dist_min[j]=dist[i_min]\n match[j]=i_min\n\n salida=list(a1)\n for i in range(nt1):salida.append(tail1[i])\n \n for i in range(nt2):\n if type(tail2[i][0])==type('si'):\n t=[]\n for j in match: t.append(tail2[i][j])\n else:\n t=take(tail2[i],match)\n salida.append(t)\n\n salida.append(dist_min)\n return tuple(salida)","def nn_match(descs1, descs2):\n # diff = descs1[:, None, :] - descs2[None, :, :]\n # diff = np.linalg.norm(diff, ord=2, axis=2)\n # indices = np.argmin(diff, axis=1)\n\n flann = cv2.FlannBasedMatcher_create()\n matches = flann.match(descs1.astype(np.float32), descs2.astype(np.float32))\n indices = [x.trainIdx for x in matches]\n\n return indices","def find_num_matches(p1, p2, t1, t2, m1, m2, x, k, len_p, i):\n start = 0\n for mismatch in range(k):\n # print(f'start: {start}, id: {id}')\n id = start\n end = len_p-1\n while start <= end:\n mid = start + (end-start)//2\n p_h1, p_h2 = get_hash_value(\n p1, m1, x, id, mid-start), get_hash_value(p2, m2, x, id, mid-start)\n s_h1, s_h2 = get_hash_value(\n t1, m1, x, i+id, mid-start), get_hash_value(t2, m2, x, i+id, mid-start)\n if p_h1 == s_h1 and p_h2 == s_h2: # move to the right half, no mismatch yet\n start = mid + 1\n else:\n end = mid - 1\n # when loop exits, start - 1 is the index of the mismatch.\n if start == len_p: # found the last mismatch\n return True\n return False","def match_objects(coords1,coords2,tail1=(),tail2=(),accuracy=1.):\n acc2=accuracy**2\n nc=len(coords1)\n np1=len(coords1[0])\n np2=len(coords2[0])\n a1=array(coords1)\n a2=array(coords2)\n nt1=len(tail1)\n for i in range(nt1): \n if len(tail1[i])!= np1: raise 'Not the same lenght as coordinates 1'\n nt2=len(tail2)\n for i in range(nt2): \n if len(tail2[i])!= np2: raise 'Not the same lenght as coordinates 2'\n match=zeros(np1, int)-1\n for j in range(np1):\n #dist=add.reduce((a1[:,j,NewAxis]-a2[:,:])**2)\n a1j = a1[:,j]\n dist=add.reduce((reshape(a1j, (len(a1j), 1)) - a2)**2)\n i_min=argmin(dist)\n if dist[i_min]<acc2:match[j]=i_min\n good=greater_equal(match,0)\n n1=compress(good,list(range(np1))) \n match=compress(good,match)\n a1=compress(good,a1)\n salida=list(a1)\n for i in range(nt1):\n if type(tail1[i][0])==type('si'):\n t=[]\n for j in n1: t.append(tail1[i][j])\n else:\n t=take(tail1[i],n1)\n salida.append(t)\n for i in range(nt2):\n if type(tail2[i][0])==type('si'):\n t=[]\n for j in match: t.append(tail2[i][j])\n else:\n t=take(tail2[i],match)\n salida.append(t)\n return salida","def find_mutual_ids(tree_1, tree_2):\r\n # Getting lists of all the users:\r\n all_users_1 = tree_1.all_users() + [tree_1]\r\n all_users_2 = tree_2.all_users() + [tree_2]\r\n\r\n result_list = []\r\n\r\n # Changing types of values in lists:\r\n all_users_1 = [user.get_id_num() for user in all_users_1]\r\n all_users_2 = [user.get_id_num() for user in all_users_2]\r\n\r\n # Checking:\r\n for user in all_users_1:\r\n if user in all_users_2:\r\n result_list.append(user)\r\n\r\n return result_list","def get_matches(src,dst,src_list, dst_list):\n matches=[]\n for src_conn in src_list:\n print src_conn\n if (src_conn in dst_list) & (src_conn<>dst):\n matches.append(src_conn)\n return matches","def match(desc1,desc2):\n desc1 = array([d/linalg.norm(d) for d in desc1])\n desc2 = array([d/linalg.norm(d) for d in desc2])\n dist_ratio = 0.6\n desc1_size = desc1.shape\n matchscores = zeros((desc1_size[0],1),'int')\n desc2t = desc2.T # precompute matrix transpose\n for i in range(desc1_size[0]):\n dotprods = dot(desc1[i, :], desc2t) # vector of dot products\n dotprods *= 0.9999\n # inverse cosine and sort, return index for features in second image\n indx = argsort(arccos(dotprods))\n # check if nearest neighbor has angle less than dist_ratio times 2nd\n if arccos(dotprods)[indx[0]] < dist_ratio * arccos(dotprods)[indx[1]]:\n matchscores[i] = int(indx[0])\n return matchscores","def findSubsetIndices(min_lat,max_lat,min_lon,max_lon,lats,lons):\n res=np.zeros((4),dtype=np.float64)\n minLon=min_lon; maxLon=max_lon\n\n distances1 = []; distances2 = []\n indices=[]; index=1\n\n for point in lats:\n s1 = max_lat-point # (vector subtract)\n s2 = min_lat-point # (vector subtract)\n distances1.append((np.dot(s1, s1), point, index))\n distances2.append((np.dot(s2, s2), point, index-1))\n index=index+1\n\n distances1.sort()\n distances2.sort()\n indices.append(distances1[0])\n indices.append(distances2[0])\n\n distances1 = []; distances2 = []; index=1\n\n for point in lons:\n s1 = maxLon-point # (vector subtract)\n s2 = minLon-point # (vector subtract)\n distances1.append((np.dot(s1, s1), point, index))\n distances2.append((np.dot(s2, s2), point, index-1))\n index=index+1\n\n distances1.sort()\n distances2.sort()\n indices.append(distances1[0])\n indices.append(distances2[0])\n\n # Save final product: max_lat_indices,min_lat_indices,max_lon_indices,min_lon_indices\n minJ=indices[1][2]\n maxJ=indices[0][2]\n minI=indices[3][2]\n maxI=indices[2][2]\n\n res[0]=minI; res[1]=maxI; res[2]=minJ; res[3]=maxJ\n return res","def match(cat1, cat2, xs, ys, mmax):\n\n nmatch = 0\n x1s, y1s = cat1[:,0], cat1[:,1]\n ind1 = np.arange(len(cat1))\n ind2 = np.empty(len(cat2),dtype=int)\n ind2.fill(-1)\n for i2, p2 in enumerate(cat2):\n x2, y2 = p2\n ok = (x1s > x2-xs-mmax) & (x1s < x2-xs+mmax) & \\\n (y1s > y2-ys-mmax) & (y1s < y2-ys+mmax)\n if len(x1s[ok]) == 1:\n nmatch += 1\n ind2[i2] = ind1[ok][0]\n\n return (nmatch, ind2)","def create_match_instance_pairs(plant_match_in):\r\n\t## collect all plant name match instances indices\r\n\tjust_indices = [int(indices) for plant_match_in_set in plant_match_in for indices in plant_match_in_set[1]]\r\n\t\r\n\tassert len(just_indices) == len(set(just_indices)) # check there are no exact duplicates in indices\r\n\r\n\tsorted_index = list(sorted(just_indices)) # sort indices small-large\r\n\tprint(f'Length of corpus bigrams BEFORE ambiguous matches removed: {len(sorted_index)}')\r\n\t#print(sorted_index)\r\n\r\n\t# remove all ambiguous matches that are within 1 word of each other\r\n\tprint('Ambiguous plant name matches: ')\r\n\tfor i, index in enumerate(sorted_index): # iterate over all indices in sorted list\r\n\t\t\r\n\t\tif index == sorted_index[i-1]+1: # indices is within 1 of previous indices in list\r\n\t\t\tprint(index, sorted_index[i-1])\r\n\t\t\tsorted_index.remove(index) # remove indices from list\r\n\t\t\tsorted_index.remove(sorted_index[i-1]) # AND remove previous indices from list\r\n\tprint(f'Length of corpus bigrams AFTER ambiguous matches removed: {len(sorted_index)}')\r\n\r\n\t# create indices dict with 'B', 'I' values\r\n\tpaired_finds = {}\r\n\tfor match_index in sorted_index: # iterate over unambiguous match indices list\r\n\t\t\t\t\t\r\n\t\t\tpaired_finds[match_index] = ('B') # WITH value of 'B'\r\n\t\t\t\r\n\t\t\tpaired_finds[match_index+1] = ('I') # WITH value of 'I'\r\n\r\n\treturn paired_finds","def match_min2(coords1,coords2,tail1=(),tail2=()):\n nc=len(coords1)\n np1=len(coords1[0])\n np2=len(coords2[0])\n a1=array(coords1)\n a2=array(coords2)\n nt1=len(tail1)\n for i in range(nt1): \n if len(tail1[i])!= np1: raise 'Not the same lenght as coordinates 1'\n nt2=len(tail2)\n for i in range(nt2): \n if len(tail2[i])!= np2: raise 'Not the same lenght as coordinates 2'\n match=zeros(np1, int)-1\n dist_min=zeros(np1)*1.\n x2=zeros(np1)*1.\n y2=zeros(np1)*1.\n for j in range(np1):\n #dist=add.reduce((a1[:,j,NewAxis]-a2[:,:])**2)\n a1j = a1[:,j]\n dist=add.reduce((reshape(a1j, (len(a1j), 1)) - a2)**2)\n i_min=argmin(dist)\n dist_min[j]=dist[i_min]\n x2[j],y2[j]=a2[0,i_min],a2[1,i_min]\n match[j]=i_min\n \n salida=list(a1)\n salida.append(x2)\n salida.append(y2)\n\n for i in range(nt1):salida.append(tail1[i])\n \n for i in range(nt2):\n if type(tail2[i][0])==type('si'):\n t=[]\n for j in match: t.append(tail2[i][j])\n else:\n t=take(tail2[i],match)\n salida.append(t)\n\n salida.append(dist_min)\n return tuple(salida)","def test_if_nodes_are_in_same_chunk(self, node_ids: Sequence[np.uint64]\n ) -> bool:\n assert len(node_ids) == 2\n return self.get_chunk_id(node_id=node_ids[0]) == \\\n self.get_chunk_id(node_id=node_ids[1])","def find_nearby_membranes(all_membranes, all_membrane_map, vert_normals):\r\n membrane_tree = scipy.spatial.cKDTree(all_membranes)\r\n nearby_membranes = np.array(list(membrane_tree.query_pairs(adhesion_max_dist, p=2)))\r\n nearby_membrane_map = defaultdict(list)\r\n if nearby_membranes.shape[0] > 0:\r\n # Exclude same-cell membrane interactions and same-direction-facing segments\r\n all_vert_normals = np.concatenate(vert_normals, axis=0)\r\n subset = np.where(\r\n (all_membrane_map[nearby_membranes[:, 0], 0] !=\r\n all_membrane_map[nearby_membranes[:, 1], 0])\r\n & (np.einsum('ij,ik->i', all_vert_normals[nearby_membranes[:, 0]], all_vert_normals[nearby_membranes[:, 1]]) < 0.0)\r\n )\r\n nearby_membranes = nearby_membranes[subset]\r\n # {cell idx: (vert idx, other cell idx, other vert idx, 'all_membranes' vert idx)}\r\n for nm in nearby_membranes:\r\n m0 = all_membrane_map[nm[0]]\r\n m1 = all_membrane_map[nm[1]]\r\n nearby_membrane_map[m0[0]].append((m0[1], m1[0], m1[1], nm[1]))\r\n nearby_membrane_map[m1[0]].append((m1[1], m0[0], m0[1], nm[0]))\r\n nearby_membrane_map = {k: np.array(v)\r\n for k, v in nearby_membrane_map.items()}\r\n# print(nearby_membrane_map)\r\n return nearby_membranes, nearby_membrane_map","def test_several_paths(id1, id2, expected_path_ids):\n syn1 = germanet_data.get_synset_by_id(id1)\n syn2 = germanet_data.get_synset_by_id(id2)\n paths = syn1.shortest_path(syn2)\n assert len(paths) == len(expected_path_ids), \"the number of found paths doesn't macht the true number of paths\"\n for path in paths:\n path = [synset.id for synset in path]\n np.testing.assert_equal(path in expected_path_ids, True)","def find_mate_pairs(strandseq_files, unique_id_length):\n pairs = []\n run_ids = set()\n for pos in range(0, len(strandseq_files), 2):\n first_mate = strandseq_files[pos]\n second_mate = strandseq_files[pos+1]\n sm = difflib.SequenceMatcher(a=first_mate, b=second_mate)\n mobj = sm.find_longest_match(0, len(first_mate), 0, len(second_mate))\n match_size = mobj.size\n common_substring = first_mate[mobj.a : mobj.a+mobj.size]\n try:\n next_mate = strandseq_files[pos+2]\n sm.set_seq1(next_mate)\n mobj = sm.find_longest_match(0, len(next_mate), 0, len(second_mate))\n if match_size <= mobj.size:\n raise ValueError('Cannot pair mates based on lexicographical order: '\n '{} / {} vs {}'.format(first_mate, second_mate, next_mate))\n except IndexError:\n pass\n uniq_runid = hashlib.md5(common_substring.encode('utf-8')).hexdigest()[:unique_id_length]\n if uniq_runid in run_ids:\n raise ValueError('Created run ID is not unique: {} / {}'.format(uniq_runid, common_substring))\n run_ids.add(uniq_runid)\n pairs.append((first_mate, second_mate, common_substring, uniq_runid))\n return sorted(pairs, key=lambda x: x[2])","def _find_common(self, lineset1, lineset2):\n lines1 = lineset1.enumerate_stripped\n lines2 = lineset2.enumerate_stripped\n find = lineset2.find\n index1 = 0\n min_lines = self.min_lines\n while index1 < len(lineset1):\n skip = 1\n num = 0\n for index2 in find(lineset1[index1]):\n non_blank = 0\n for num, ((_, line1), (_, line2)) in enumerate(\n zip(lines1(index1), lines2(index2))\n ):\n if line1 != line2:\n if non_blank > min_lines:\n yield num, lineset1, index1, lineset2, index2\n skip = max(skip, num)\n break\n if line1:\n non_blank += 1\n else:\n # we may have reach the end\n num += 1\n if non_blank > min_lines:\n yield num, lineset1, index1, lineset2, index2\n skip = max(skip, num)\n index1 += skip","def return_matches(hashes):\n # Create a dictionary of hash => offset pairs for later lookups\n mapper = {}\n for hash, offset in hashes:\n mapper[hash.upper()] = offset\n\n # Get an iteratable of all the hashes we need\n values = mapper.keys()\n\n conn = MySQLdb.connect(**connection_string[\"Common\"])\n cur = conn.cursor()\n\n for split_values in grouper(values, 1000):\n # Create our IN part of the query\n query = SELECT_MULTIPLE\n query %= ', '.join(['UNHEX(%s)'] * len(split_values))\n\n cur.execute(query, split_values)\n\n for hash, sid, offset in cur:\n # (sid, db_offset - song_sampled_offset)\n yield (sid, offset - mapper[hash])","def match(desc1,desc2):\n\t\n\tdesc1 = array([d/linalg.norm(d) for d in desc1])\n\tdesc2 = array([d/linalg.norm(d) for d in desc2])\n\t\n\tdist_ratio = 0.6\n\tdesc1_size = desc1.shape\n\t\n\tmatchscores = zeros((desc1_size[0],1))\n\tdesc2t = desc2.T #precompute matrix transpose\n\tfor i in range(desc1_size[0]):\n\t\tdotprods = dot(desc1[i,:],desc2t) #vector of dot products\n\t\tdotprods = 0.9999*dotprods\n\t\t#inverse cosine and sort, return index for features in second image\n\t\tindx = argsort(arccos(dotprods))\n\t\t\n\t\t#check if nearest neighbor has angle less than dist_ratio times 2nd\n#\t\tif arccos(dotprods)[indx[0]] < dist_ratio * arccos(dotprods)[indx[1]]:\n\t\tmatchscores[i] = int(indx[0])\n\t\n\treturn matchscores","def match_twosided(desc1, desc2):\n\n matches_12 = match(desc1, desc2)\n matches_21 = match(desc2, desc1)\n\n ndx_12 = matches_12.non_zeros()[0]\n\n for n in ndx_12:\n if matches_21[int(matches_12[n])] != n:\n matches_12[n] = 0\n\n return matches_12","def paired_dists(self, other, match_com=True):\n assert self.ndim == other.ndim\n if match_com:\n dists1 = (self.rs[..., np.newaxis] - self.rs.T[np.newaxis, ...])\n dists2 = (other.rs[..., np.newaxis] - other.rs.T[np.newaxis, ...])\n rij_minus_sij = np.rollaxis(dists1 - dists2, -1, -2)\n rij_minus_sij = ((rij_minus_sij + 1/2.) % 1) - 1/2.\n dist_sqs = np.triu(np.sum(rij_minus_sij**2, axis=-1))\n return np.sqrt(np.sum(dist_sqs) * self.L * other.L / len(self.rs))\n else:\n diffs = self.rs - other.rs\n diffs = ((diffs + 1/2.) % 1) - 1/2.\n return np.sqrt(np.sum(diffs**2) * self.L * other.L)","def findsegments(id1, seq1, id2, seq2, minlen):\n\n segments = \"\"\n\n # Initialize list of corresponding residues.\n correspondances = []\n for res in seq1:\n correspondances.append([])\n \n # Main loop.\n for i in range(len(seq1)-minlen):\n seg1 = seq1[i:i+minlen]\n for j in range(len(seq2)-minlen):\n if j not in correspondances[i]:\n seg2 = seq2[j:j+minlen]\n if seg1 == seg2:\n # Look if the segment is longer than minlen.\n segments_equal = True\n prev1 = seg1\n prev2 = seg2\n extend = 1\n while segments_equal == True:\n i_end = i+minlen+extend\n j_end = j+minlen+extend\n ext1 = seq1[i:i_end]\n ext2 = seq2[j:j_end]\n if i_end > len(seq1) or j_end > len(seq2):\n seqend = True\n else:\n seqend = False\n if ext1 != ext2 or seqend == True:\n segments_equal = False\n segments += \"{} \".format(prev1)\n segments += \"{} [{}, {}] \".format(id1, i, i_end-2)\n segments += \" \"\n segments += \"{} [{}, {}] \".format(id2, j, j_end-2)\n segments += \"\\n\"\n # Add residues to correspondance list.\n for k in range(minlen+extend-1):\n l = i+k\n m = j+k\n correspondances[l].append(m)\n prev1 = ext1\n prev2 = ext2\n extend += 1\n\n return segments","def mapsMatch(m1,m2):\n same = True\n f1 = file(m1,'r').readlines()\n f2 = file(m2,'r').readlines()\n for i, row in enumerate(f1):\n row = row.strip().split()\n row2 = f2[i].strip().split()\n if row[0] <> row2[0]:\n\t same = False\n break\n return same","def test_return_series_matching_idlist_mols(cls):\n\n cls.test_mmp_series_object.setup_mmp_data_for_mms(cls.temp_file_input_csv_confusion.name,\n 'SMILES', 'ID', 'PIC50',\n 3, 0.50001)\n\n cls.test_mmp_series_object.generate_store_mmp_series()\n\n result_ = cls.test_mmp_series_object.return_series_matching_idlist([2, 3, 4], 'MOL_ID')\n\n #print(result_.to_dict())\n cls.assertDictEqual({'SERIES_ID': {0: 1, 1: 1, 2: 1, 3: 1, 4: 1, 5: 2, 6: 2, 7: 2, 8: 2, 9: 2},\n 'SERIES_SEQ_ID': {0: 1, 1: 2, 2: 3, 3: 4, 4: 5, 5: 1, 6: 2, 7: 3, 8: 4, 9: 5},\n 'CONTEXT_ID': {0: 8, 1: 8, 2: 8, 3: 8, 4: 8, 5: 29, 6: 29, 7: 29, 8: 29, 9: 29},\n 'FRAG_ID': {0: 7, 1: 44, 2: 69, 3: 91, 4: 285, 5: 24, 6: 34, 7: 60, 8: 82, 9: 286},\n 'MOL_ID': {0: 1, 1: 2, 2: 3, 3: 4, 4: 5, 5: 1, 6: 2, 7: 3, 8: 4, 9: 5},\n 'ACTIVITY': {0: 7.0, 1: 7.68, 2: 8.51, 3: 8.77, 4: 8.99, 5: 7.0, 6: 7.68, 7: 8.51, 8: 8.77,\n 9: 8.99}},\n result_.to_dict())","def spherematch(ra1, dec1, ra2, dec2, tol=None, nnearest=1, threads=1):\n \n #convert arguments into arrays for ease of use\n ra1 = np.array(ra1, copy=False)\n dec1 = np.array(dec1, copy=False)\n ra2 = np.array(ra2, copy=False)\n dec2 = np.array(dec2, copy=False)\n\n #check to see if arguments are consistent\n if ra1.shape != dec1.shape:\n raise ValueError('ra1 and dec1 do not match!')\n if ra2.shape != dec2.shape:\n raise ValueError('ra2 and dec2 do not match!') \n\n #convert spherical coordinates into cartesian coordinates\n x1, y1, z1 = _spherical_to_cartesian_fast(ra1.ravel(), dec1.ravel(), threads) \n\n # this is equivalent to, but faster than just doing np.array([x1, y1, z1])\n coords1 = np.empty((x1.size, 3))\n coords1[:, 0] = x1\n coords1[:, 1] = y1\n coords1[:, 2] = z1 \n\n #convert spherical coordinates into cartesian coordinates\n x2, y2, z2 = _spherical_to_cartesian_fast(ra2.ravel(), dec2.ravel(), threads)\n\n # this is equivalent to, but faster than just doing np.array([x1, y1, z1])\n coords2 = np.empty((x2.size, 3))\n coords2[:, 0] = x2\n coords2[:, 1] = y2\n coords2[:, 2] = z2\n \n #create tree structure\n kdt = KDT(coords2)\n #find neighbors\n if nnearest == 1:\n idxs2 = kdt.query(coords1)[1]\n elif nnearest == 0 and (tol is not None): #if you want all matches\n p1x, p1y, p1z = _spherical_to_cartesian_fast(90, 0, threads)\n p2x, p2y, p2z = _spherical_to_cartesian_fast(90, tol, threads)\n p1x = float(p1x)\n p2x = float(p2x)\n p1y = float(p1y)\n p2y = float(p2y)\n p1z = float(p1z)\n p2z = float(p2z)\n r = np.sqrt((p2x-p1x)**2+(p2y-p1y)**2+(p2z-p1z)**2) #cartesian tol\n idxs2 = kdt.query_ball_point(coords1, r)[0]\n elif nnearest > 1:\n idxs2 = kdt.query(coords1, nnearest)[1][:, -1]\n else:\n raise ValueError('invalid nnearest ' + str(nnearest))\n \n #calculate distances between matches\n ds = _great_circle_distance_fast(ra1, dec1, ra2[idxs2], dec2[idxs2], threads) \n\n #if tolerance is None, then all objects will have a match\n idxs1 = np.arange(ra1.size)\n \n #remove matches that are beyond the tolerance seperation\n if (tol is not None) and nnearest != 0:\n msk = ds < tol\n idxs1 = idxs1[msk]\n idxs2 = idxs2[msk]\n ds = ds[msk]\n\n \n return idxs1, idxs2, ds","def get_pairs_to_compare(id_token_pairs):\n token_sku_id_pairs = dict()\n for sku_id, tokens in id_token_pairs.items():\n for token in tokens:\n token_sku_id_pairs[token] = token_sku_id_pairs.get(token, []) + [sku_id]\n\n pairs_to_compare = set()\n for token, sku_ids in token_sku_id_pairs.items():\n id_combinations = combinations(sku_ids, 2)\n for (id1, id2) in id_combinations:\n if (id2, id1) not in pairs_to_compare:\n pairs_to_compare.add((id1, id2))\n\n return pairs_to_compare","def _calculate_leading_dim_map():\n small_matrixes = [(value, value+64) for value in range(256, 40192+512, 512)]\n large_matrixes = [(value, value+1088) for value in range(1024, 39936+1024, 1024)]\n return dict(small_matrixes + large_matrixes)","def match_features(desc1, desc2, min_score):\n\n ## Reshape D1,2 to (N1, k^2), (k^2, N2)\n\n D1 = desc1.reshape((desc1.shape[0], -1))\n D2 = desc2.reshape((desc2.shape[0], -1)).T\n\n ## Calc M = D1 * D2, shape (N1, N2)\n ## Mi,j = match score of pt i from I1 and pt 2 from I2.\n\n M = D1.dot(D2)\n\n ## Get candidates list I1 and I2, shape (2, N2), (\n ## total_cand = 4-j cands of the 2-i cands in index i\n\n cols_cand = np.argpartition(M, -2, axis=0)[-2:]\n rows_cand = np.argpartition(M.T, -2, axis=0)[-2:]\n total_cand = rows_cand[:, cols_cand]\n\n ## Mark matches where i appear in the ith col\n ## concat matches.\n\n index_map = np.ones(cols_cand.shape, dtype=np.int) * np.arange(cols_cand.shape[-1])\n match = (total_cand == index_map)\n\n desc1_match = np.concatenate((cols_cand[match[0]],\n cols_cand[match[1]]))\n desc2_match = np.concatenate((index_map[match[0]],\n index_map[match[1]]))\n\n ## Discard matches below min_score\n\n satisfty_min = np.where(M[desc1_match, desc2_match] >= min_score)\n desc1_match = desc1_match[satisfty_min]\n desc2_match = desc2_match[satisfty_min]\n\n ## Remove duplicate matches, keep max score pair.\n\n order = np.argsort(M[desc1_match, desc2_match])[::-1]\n desc1_match = desc1_match[order]\n desc2_match = desc2_match[order]\n\n unqe = np.unique(desc1_match, return_index=True)[1]\n desc1_match = desc1_match[unqe]\n desc2_match = desc2_match[unqe]\n\n return [desc1_match, desc2_match]","def associate(first_list, second_list, offset, max_difference):\n ## obatin all keys\n first_keys = list(first_list)\n second_keys = list(second_list)\n potential_matches = [(abs(a - (b + offset)), a, b)\n for a in first_keys\n for b in second_keys\n if abs(a - (b + offset)) < max_difference]\n potential_matches.sort()\n matches = []\n for diff, a, b in potential_matches:\n if a in first_keys and b in second_keys:\n first_keys.remove(a)\n second_keys.remove(b)\n matches.append((a, b))\n \n matches.sort()\n return matches","def indmatch(ra1, dec1, ra2, dec2, tol):\n m = match(ra1, dec1, ra2, dec2, tol)\n c = m.ind > -1\n i1 = c.nonzero()[0]\n i2 = m.ind[c]\n return i1, i2","def test_connected_ids_remote_minions():\n opts = {\n \"publish_port\": 4505,\n \"detect_remote_minions\": True,\n \"remote_minions_port\": 22,\n \"minion_data_cache\": True,\n }\n minion = \"minion\"\n minion2 = \"minion2\"\n minion2_ip = \"192.168.2.10\"\n minion_ips = {\"203.0.113.1\", \"203.0.113.2\", \"127.0.0.1\"}\n mdata = {\"grains\": {\"ipv4\": minion_ips, \"ipv6\": []}}\n mdata2 = {\"grains\": {\"ipv4\": [minion2_ip], \"ipv6\": []}}\n patch_net = patch(\"salt.utils.network.local_port_tcp\", return_value=minion_ips)\n patch_remote_net = patch(\n \"salt.utils.network.remote_port_tcp\", return_value={minion2_ip}\n )\n patch_list = patch(\"salt.cache.Cache.list\", return_value=[minion, minion2])\n patch_fetch = patch(\"salt.cache.Cache.fetch\", side_effect=[mdata, mdata2])\n ckminions = salt.utils.minions.CkMinions(opts)\n with patch_net, patch_list, patch_fetch, patch_remote_net:\n ret = ckminions.connected_ids()\n assert ret == {minion2, minion}","def greedy_match(cost_matrix):\n num_detections, num_tracks = cost_matrix.shape\n distance_1d = cost_matrix.reshape(-1)\n index_1d = np.argsort(distance_1d)\n index_2d = np.stack([index_1d // num_tracks, index_1d % num_tracks], axis=1).astype(int, copy=False)\n\n matched_indices = []\n matched_firsts = set()\n matched_seconds = set()\n\n for (first_id, second_id) in index_2d:\n if first_id not in matched_firsts and second_id not in matched_seconds:\n matched_seconds.add(second_id)\n matched_firsts.add(first_id)\n matched_indices.append([first_id, second_id])\n return np.array(matched_indices)","def correspondences(labels1,labels2,return_counts=True):\n q = 100000\n assert amin(labels1)>=0 and amin(labels2)>=0\n assert amax(labels2)<q\n combo = labels1*q+labels2\n result = unique(combo, return_counts=return_counts)\n if return_counts:\n result, counts = result\n result = array([result//q,result%q,counts])\n else:\n result = array([result//q,result%q])\n return result","def min_cost_matching(\n distance_metric, max_distance, tracks, detections, track_indices=None,\n detection_indices=None):\n if track_indices is None:\n track_indices = np.arange(len(tracks))\n if detection_indices is None:\n detection_indices = np.arange(len(detections))\n\n if len(detection_indices) == 0 or len(track_indices) == 0:\n return [], track_indices, detection_indices # Nothing to match.\n\n cost_matrix = distance_metric(\n tracks, detections, track_indices, detection_indices)\n cost_matrix[cost_matrix > max_distance] = max_distance + 1e-5\n indices = linear_sum_assignment(cost_matrix)\n indices = np.asarray(indices)\n indices = np.transpose(indices)\n\n matches, unmatched_tracks, unmatched_detections = [], [], []\n for col, detection_idx in enumerate(detection_indices):\n if col not in indices[:, 1]:\n unmatched_detections.append(detection_idx)\n for row, track_idx in enumerate(track_indices):\n if row not in indices[:, 0]:\n unmatched_tracks.append(track_idx)\n for row, col in indices:\n track_idx = track_indices[row]\n detection_idx = detection_indices[col]\n if cost_matrix[row, col] > max_distance:\n unmatched_tracks.append(track_idx)\n unmatched_detections.append(detection_idx)\n else:\n matches.append((track_idx, detection_idx))\n return matches, unmatched_tracks, unmatched_detections","def match_coords(list1, list2, tol = 1.5):\n tol1, tol2 = tol/3600.0, (tol/3600.0)**2\n jmin, match_idx, best_dr2 = 0, [None]*len(list1), [tol2]*len(list1)\n # This next bit is rather tricky because we have to sort the lists,\n # but also remember where we put each item. Here i, j = sorted indices,\n # while ci[i], ci[j] = corresponding actual indices in original lists.\n ci = np.array([c.ra for c in list1]).argsort()\n cj = np.array([c.ra for c in list2]).argsort()\n for i in range(len(list1)):\n CD = np.cos(list1[ci[i]].dec*np.pi/180.0)\n ramin, ramax = list1[ci[i]].ra - tol1/CD, list1[ci[i]].ra + tol1/CD\n decmin, decmax = list1[ci[i]].dec - tol1, list1[ci[i]].dec + tol1\n # Inch along in list2 until we find the part that matches list1 in RA\n while jmin < len(list2) and list2[cj[jmin]].ra < ramin: jmin += 1\n if jmin == len(list2): break\n # Now go through all the RA matches and check the RA+DEC distance.\n j = jmin\n while j < len(list2) and list2[cj[j]].ra < ramax:\n dr2 = ((CD*(list1[ci[i]].ra-list2[cj[j]].ra))**2 +\n (list1[ci[i]].dec-list2[cj[j]].dec)**2)\n if dr2 < best_dr2[ci[i]]:\n match_idx[ci[i]], best_dr2[ci[i]] = cj[j], dr2\n j += 1\n # Save and return the index in list2 of the best-matched object to each\n # item in list1, and the distances between corresponding best matches.\n best_dr = [np.sqrt(dr2)*3600 for dr2 in best_dr2]\n return match_idx, best_dr","def _match_identical_nodes(self):\n\n for job_name_b in self._topo_b_nodes:\n for job_name_a in self._unresolved_a_nodes:\n if self._is_node_identical(job_name_a, job_name_b):\n self._identical_nodes[job_name_b] = job_name_a\n self._unresolved_a_nodes.remove(job_name_a)\n self._unresolved_b_nodes.remove(job_name_b)\n break","def pair_address(streetsweeping, streetvolume):\r\n addresses = pd.read_sql_query('Select * from address_data', conn)\r\n streetsweeping['corridor'] = streetsweeping['corridor'].apply(lambda x: x.upper())\r\n addresses['blocknum'] = addresses['number'].apply(lambda x: math.floor(int(x) / 100))\r\n streetsweeping['blocknum'] = streetsweeping['lf_fadd'].apply(lambda x: math.floor(int(x) / 100))\r\n streetsweeping = streetsweeping[['corridor', 'blocknum', 'lineid']]\r\n addresses = addresses.merge(streetsweeping, how = 'left', left_on = ['street', 'blocknum'], right_on = ['corridor', 'blocknum'])\r\n addresses.drop_duplicates(subset = ['address'], inplace = True)\r\n\r\n\r\n unfound = addresses[pd.isnull(addresses.lineid)]\r\n unfound.dropna(subset = ['lat', 'lon' ], inplace = True)\r\n addresses.dropna(subset = ['lineid'], inplace = True)\r\n addresses.drop(columns = ['blocknum', 'index', 'corridor'], inplace = True)\r\n\r\n geometry = [Point(xy) for xy in zip(unfound.lon, unfound.lat)]\r\n crs = {'init': 'epsg:4326'}\r\n gdf = gpd.GeoDataFrame(unfound, crs=crs, geometry=geometry)\r\n addresses = addresses[['lon', 'lat', 'number', 'street', 'address', 'streetname', 'nhood', 'lineid']]\r\n tqdm.pandas()\r\n dfstreets = streetvolume.copy()\r\n print(\"searching for unmatched addresses\")\r\n gdf['lineid'] = gdf.progress_apply(lambda x: find_closest_point(x['geometry'], x['street'], dfstreets), axis = 1)\r\n addresses = addresses.append(gdf)\r\n addresses = addresses[['address', 'lat', 'lon', 'lineid', 'nhood', 'number', 'street', 'streetname']]\r\n addresses.to_sql('address_data', conn, if_exists = 'replace')\r\n return","def match2Lists(list1,list2):\r\n TopMatch = []\r\n TopScore = []\r\n TopRowIdx = []\r\n for member in list1:\r\n x=process.extractOne(member, list2)\r\n TopMatch.append(x[0])\r\n TopScore.append(x[1])\r\n TopRowIdx.append(x[2])\r\n return TopMatch, TopScore, TopRowIdx","def get_pairwise_matches(pos1, descs1, pos2, descs2, up_to=30):\n assert pos1.shape[0] * pos2.shape[0] < 1e8, \\\n \"Too many points: increase cornerness threshold\"\n assert pos1.shape[0] > 10 and pos1.shape[0] > 10, \\\n \"Not enough points: lower cornerness threshold\"\n # get the similarities between all descriptors\n sims = np.dot(descs1, descs2.T)\n # get the best matches\n mi2 = sims.argmax(axis=1).squeeze()\n ms = sims.max(axis=1).squeeze()\n bmi1 = ms.argsort()[::-1][:up_to]\n bmi2 = mi2[bmi1]\n # return their positions\n bp1 = pos1[bmi1]\n bp2 = pos2[bmi2]\n return bp1, bp2","def test_return_series_matching_idlist_frags(cls):\n\n cls.test_mmp_series_object.setup_mmp_data_for_mms(cls.temp_file_input_csv_confusion.name,\n 'SMILES', 'ID', 'PIC50',\n 3, 0.50001)\n\n cls.test_mmp_series_object.generate_store_mmp_series()\n\n result_ = cls.test_mmp_series_object.return_series_matching_idlist([24, 34, 60],\n 'FRAG_ID')\n #print(result_.to_dict())\n cls.assertDictEqual(\n {'SERIES_ID': {5: 2, 6: 2, 7: 2, 8: 2, 9: 2, 14: 4, 15: 4, 16: 4, 17: 4, 23: 6, 24: 6, 25: 6, 26: 6, 27: 6},\n 'SERIES_SEQ_ID': {5: 1, 6: 2, 7: 3, 8: 4, 9: 5, 14: 1, 15: 2, 16: 3, 17: 4, 23: 1, 24: 1, 25: 2, 26: 3,\n 27: 4},\n 'CONTEXT_ID': {5: 29, 6: 29, 7: 29, 8: 29, 9: 29, 14: 122, 15: 122, 16: 122, 17: 122, 23: 208, 24: 208,\n 25: 208, 26: 208, 27: 208},\n 'FRAG_ID': {5: 24, 6: 34, 7: 60, 8: 82, 9: 286, 14: 60, 15: 34, 16: 24, 17: 82, 23: 24, 24: 9, 25: 34,\n 26: 60, 27: 82},\n 'MOL_ID': {5: 1, 6: 2, 7: 3, 8: 4, 9: 5, 14: 12, 15: 11, 16: 10, 17: 13, 23: 30002100, 24: 300021,\n 25: 298356, 26: 29835601, 27: 29835602},\n 'ACTIVITY': {5: 7.0, 6: 7.68, 7: 8.51, 8: 8.77, 9: 8.99, 14: 7.77, 15: 8.0, 16: 8.3, 17: 8.89, 23: 6.5,\n 24: 6.5, 25: 6.9, 26: 7.3, 27: 7.91}},\n result_.to_dict())","def generate_mobility_queries_pair(similar=False):\n q1 = generate_random_mobility_query()\n if similar:\n q2 = generate_similar_mobility_query(q1)\n else:\n q2 = generate_not_similar_mobility_query(q1)\n\n return q1, q2","def match_cluster_sets(cs1, cs2):\n\n matr = [[len(cl1.bibs & cl2.bibs) for cl2 in cs2.clusters] for cl1 in cs1.clusters]\n mapping = maximized_mapping(matr)\n return dict((cs1.clusters[mappy[0]], cs2.clusters[mappy[1]]) for mappy in mapping)","def _compute_set_distances(nonzeros_1, nonzeros_2):\n distances = np.zeros(len(nonzeros_1))\n for i, _ in enumerate(distances):\n distances[i] = np.min(\n _norm_along_last_axis(nonzeros_1[i].reshape(1, -1) - nonzeros_2)\n )\n return distances","def mwpm_ids(edges):\n # extract and sort node ids\n node_ids = sorted(set(id for (id_a, id_b, _) in edges for id in (id_a, id_b)))\n # count n_nodes\n n_nodes = len(node_ids)\n # check node ids form contiguous set of non-negative integers starting at zero\n assert n_nodes == 0 or (node_ids[0] == 0 and node_ids[-1] == n_nodes - 1), (\n 'Node ids are not a contiguous set of non-negative integers starting at zero.')\n # count n_edges\n n_edges = len(edges)\n # unzip edges\n nodes_a, nodes_b, weights = zip(*edges) if n_edges else ([], [], [])\n # prepare array types\n mates_array_type = ctypes.c_int * n_nodes\n edges_array_type = ctypes.c_int * n_edges\n # prepare empty mates\n mates_array = mates_array_type()\n # call C interface\n _libpypm().mwpm(ctypes.c_int(n_nodes), mates_array, ctypes.c_int(n_edges),\n edges_array_type(*nodes_a), edges_array_type(*nodes_b), edges_array_type(*weights))\n # structure of mates: mates_array[i] = j means ith node matches jth node\n # convert to more useful format: e.g. convert [1, 0, 3, 2] to {(0, 1), (2, 3)}\n mates = {tuple(sorted((a, b))) for a, b in enumerate(mates_array)}\n return mates","def all_match():\n S1=Spectrum.Spectrum()\n S1.add_peak(50.7,234)\n S1.add_peak(54.6,585)\n S1.add_peak(60.7,773)\n S1.add_peak(65.6,387)\n S1.add_peak(87.7,546)\n S1.add_peak(104.6,598)\n S1.pep_mass=100\n S1.euclidean_scale()\n\n S2=Spectrum.Spectrum()\n S2.add_peak(50.5,234/2)\n S2.add_peak(54.8,585/2)\n S2.add_peak(61.0,773/2)\n S2.add_peak(65.4,387/2)\n S2.add_peak(88.0,546/2)\n S2.add_peak(104.3,598/2)\n S2.pep_mass=100\n S2.euclidean_scale()\n\n score,peaks=similarity.cosine_score_max(S1,S2)\n assert peaks==6, \"Incorrect number of peaks matched with greedy method\"\n assert math.isclose(score,1.0), \"Incorrect score with greedy method\"\n\n score,peaks=similarity.cosine_score_greedy(S1,S2)\n assert peaks==6, \"Incorrect number of peaks matched with maximum weighted method\"\n assert math.isclose(score,1.0), \"Incorrect score with maximum weighted method\"","def match_twosided(desc1,desc2):\n matches_12 = match(desc1, desc2)\n matches_21 = match(desc2, desc1)\n ndx_12 = matches_12.nonzero()[0]\n # remove matches that are not symmetric\n for n in ndx_12:\n if matches_21[int(matches_12[n])] != n:\n matches_12[n] = 0\n return matches_12","def match_data(embeddings, z_scores):\r\n print(\"Matching protein IDs...\", end=\"\")\r\n\r\n x, y = [], []\r\n # this could just as well be the keys from the z-scores, since the two of them are identical\r\n protein_ids = embeddings.keys()\r\n for protein_id in protein_ids:\r\n x.append(embeddings[protein_id])\r\n y.append(z_scores[protein_id])\r\n\r\n print(f\"done!\")\r\n return x, y","def match_dimensions(A, B, dims):\n dsa = A.datashape.copy()\n dsb = B.datashape.copy()\n dsa.dim_low = list(dsa.dim_low)\n dsb.dim_low = list(dsb.dim_low)\n dsa.dim_high = list(dsa.dim_high)\n dsb.dim_high = list(dsb.dim_high)\n\n for i, j in dims:\n low = min(dsa.dim_low[i], dsb.dim_low[j])\n high = max(dsa.dim_high[i], dsb.dim_high[j])\n\n dsa.dim_low[i] = low\n dsa.dim_high[i] = high\n dsb.dim_low[j] = low\n dsb.dim_high[j] = high\n\n if dsa != A.datashape:\n A = A.redimension(dsa.schema)\n if dsb != B.datashape:\n B = B.redimension(dsb.schema)\n\n return A, B","def match_features(desc1, desc2, min_score):\n\n match = []\n flat_des1 = desc1.reshape(desc1.shape[0],desc1.shape[1] * desc1.shape[2])\n flat_des2 = desc2.reshape(desc2.shape[0], desc2.shape[1] * desc2.shape[2])\n combine = np.dot(flat_des1,flat_des2.transpose())\n\n for i in range (combine.shape[0]):\n max_index_row = combine[i].argsort()[-2:]\n for j in max_index_row:\n max_index_col = combine[:,j].argsort()[-2:]\n if i in max_index_col and combine[i][j] >= min_score:\n match.append([i,j])\n\n match = np.array(match)\n return [match.transpose()[0],match.transpose()[1]] #todo should be list?","def match_twosided(desc1,desc2):\n\t\n\tmatches_12 = match(desc1,desc2)\n\tmatches_21 = match(desc2,desc1)\n\t\n\tndx_12 = matches_12.nonzero()[0]\n\t\n\t#remove matches that are not symmetric\n\tfor n in ndx_12:\n\t\tif matches_21[int(matches_12[n])] != n:\n\t\t\tmatches_12[n] = 0\n\t\n\treturn matches_12","def map_nodes(dist1, dist2, lcnt, op, mode=None):\n # TODO: Modify the functions citing this function, so that we can avoid use \"mode\" in this function.\n # The only difference is the format of dist2\n \n tmp = 0\n map_dict = []\n for i in range(0, lcnt):\n map_dict.append(i)\n \n if mode == None:\n if len(dist1)==len(dist2):\n dist_M = np.zeros((len(dist1), len(dist2)))\n for i in range(0, len(dist1)):\n for j in range(0, len(dist2)):\n dist_M[i,j] = np.linalg.norm(dist1[i]-dist2[j])\n row_ind, col_ind = linear_sum_assignment(dist_M)\n for i in range(0, len(col_ind)):\n map_dict.append(col_ind[i]+lcnt)\n else:\n for i in range(0, len(dist1)):\n idx = find_min_square_dist(dist1[i], dist2, op, map_dict, lcnt)\n map_dict.append(idx+lcnt)\n else:\n if len(dist1)==len(dist2)-lcnt:\n dist1 = dist1[lcnt:len(dist1),:]\n dist_M = np.zeros((len(dist1), len(dist2)))\n for i in range(0, len(dist1)):\n for j in range(0, len(dist2)):\n dist_M[i,j] = np.linalg.norm(dist1[i]-dist2[j])\n row_ind, col_ind = linear_sum_assignment(dist_M)\n for i in range(0, len(col_ind)):\n map_dict.append(col_ind[i]+lcnt)\n else:\n for i in range(0, len(dist1)):\n idx = find_min_square_dist(dist1[i], dist2, op, map_dict, lcnt)\n map_dict.append(idx)\n\n return map_dict","def findSubsetIndices(grdMODEL, min_lat, max_lat, min_lon, max_lon):\n\n\n if min_lon<0 and max_lon>0:\n splitExtract = True; Turns=2\n grdMODEL.splitExtract=splitExtract\n else:\n splitExtract = False; Turns=1\n grdMODEL.splitExtract=splitExtract\n grdMODEL.lon = np.where(grdMODEL.lon>180,grdMODEL.lon-360,grdMODEL.lon)\n \n # Array to store the results returned from the function\n res=np.zeros((Turns,4),dtype=np.float64)\n \n lats=grdMODEL.lat[:,0]\n lons=grdMODEL.lon[0,:]\n\n \n for k in range(Turns):\n\n if k==0 and splitExtract == True:\n minLon=min_lon; maxLon=0\n minLon=minLon+360\n maxLon=maxLon+360\n elif k==1 and splitExtract == True:\n minLon=0; maxLon=max_lon\n else:\n minLon=min_lon; maxLon=max_lon\n \n distances1 = []\n distances2 = []\n indices=[]\n index=1\n for point in lats:\n s1 = max_lat-point # (vector subtract)\n s2 = min_lat-point # (vector subtract)\n distances1.append((np.dot(s1, s1), point, index))\n distances2.append((np.dot(s2, s2), point, index-1))\n index=index+1\n\n distances1.sort()\n distances2.sort()\n indices.append(distances1[0])\n indices.append(distances2[0])\n \n distances1 = []\n distances2 = []\n index=1\n \n for point in lons:\n s1 = maxLon-point # (vector subtract)\n s2 = minLon-point # (vector subtract)\n distances1.append((np.dot(s1, s1), point, index))\n distances2.append((np.dot(s2, s2), point, index-1))\n index=index+1\n \n distances1.sort()\n distances2.sort()\n indices.append(distances1[0])\n indices.append(distances2[0])\n\n # Save final product: max_lat_indices,min_lat_indices,max_lon_indices,min_lon_indices\n minJ=indices[1][2]\n maxJ=indices[0][2]\n minI=indices[3][2]\n maxI=indices[2][2]\n \n res[k,0]=minI; res[k,1]=maxI; res[k,2]=minJ; res[k,3]=maxJ;\n\n # Save final product: max_lat_indices,min_lat_indices,max_lon_indices,min_lon_indices\n grdMODEL.indices=res","def read_pairwise_ld(snp1, snp2):\n\tif snp1.rsID == snp2.rsID:\n\t\treturn 1\n\tif snp1.rsID in r2_cache and snp2.rsID in r2_cache:\n\t\treturn r2_cache[snp1.rsID][snp2.rsID]\n\telse:\n\t\treturn 0","def get_closest_match(indices1, indices2):\n \n if len(indices1) == 1 and len(indices2) == 1:\n return indices1[0], indices2[0]\n \n closest_match = (indices1[0], indices2[0])\n min_dist = np.abs(closest_match[0][0] - closest_match[1][0])\n for pair in itertools.product(indices1, indices2):\n dist = np.abs(pair[0][0] - pair[1][0])\n if dist < min_dist:\n closest_match = pair\n min_dist = dist\n \n return closest_match","def findMatches2(personDict,matches,skepticalMatches,personDict2,s2=0):\n try:\n additionalMatches = {}\n skipCount = 0\n L1 = list(personDict['LAST'])\n L2 = list(personDict['FIRST'])\n L3 = list(personDict['DOB'])\n count = 0\n for ln in L1[:]:\n count += 1\n if count%600==0:\n print (round(100*count/len(L1),3),\"% complete [\"+str(count)+\"/\"+str(len(L1))+\"] after\",round(time.time()-s2,2),\"seconds\")\n print (len(additionalMatches),\"additional matches found so far...\",flush=True)\n if ln=='':\n continue\n LNIDs = personDict['LAST'][ln]\n for fn in L2:\n if fn=='':\n continue\n \n FNIDs = personDict['FIRST'][fn]\n toPassOn = LNIDs.intersection(FNIDs)\n if len(toPassOn)==0:\n skipCount += 1\n continue\n \n for dob in L3:\n if dob=='':\n continue\n DOBIDs = personDict['DOB'][dob]\n finalSet = toPassOn.intersection(DOBIDs)\n if len(finalSet)==0:\n skipCount += 1\n continue\n pairs = itertools.combinations(finalSet,2)\n for p in pairs:\n k = tuple(sorted(p))\n \n info1b = personDict2['EnterpriseID'][p[0]]\n info2b = personDict2['EnterpriseID'][p[1]]\n \n if (k not in matches) and (k not in skepticalMatches) and (k not in additionalMatches):\n badness = (L.distance(info1b[1],info2b[1])+L.distance(info1b[2],info2b[2])+2*L.distance(info1b[5],info2b[5]))\n score = getScorePair(info1b,info2b)\n if info1b[7]!=\"\" and info2b[7]!=\"\":\n badness+=L.distance(info1b[7],info2b[7])\n if len(info1b[12])>4 and len(info2b[12])>4:\n if info1b[12][0:4]==info2b[12][0:4]:\n badness-=2\n if badness>2 and score<5:\n continue\n \n additionalMatches[k] = score\n except KeyboardInterrupt:\n return additionalMatches\n return additionalMatches","def match2(img1, img2, coordinates1, coordinates2, PATCH_SIZE):\n\n\tpossible_matches = pd.DataFrame(columns=['feature1', 'feature2', 'diff'])\n\n\t# iteration through all the possible pairs of features from img1 and img2\n\tfor (feature1, feature2) in product(coordinates1, coordinates2):\n\t\tpatch1 = make_patch(feature1, PATCH_SIZE, img1)\n\t\tpatch2 = make_patch(feature2, PATCH_SIZE, img2)\n\t\tdiff = count_difference(patch1, patch2)\n\t\t# print(feature1, feature2, diff)\n\t\t# next line is weird, don't ask\n\t\tpossible_matches = possible_matches.append({'feature1': feature1, 'feature2': feature2, 'diff': diff}, ignore_index=True)\n\n\n\t# sorting the possible_matches according to their difference and resetin the index\n\t# inplace=True means that changes will be performed in-place, so they will change the variable and there is no need to reassign\n\tpossible_matches.sort_values(['diff'], inplace=True)\n\tpossible_matches.reset_index(inplace=True, drop=True)\n\t# print(\"SORTED\")\n\t# print(possible_matches)\n\n\t# adding only the best matches\n\tmatches = []\n\twhile not possible_matches.empty:\n\t\tbest_match = possible_matches.loc[0]\n\t\tmatches.append(list(best_match))\n\t\t# creating a list of indicies to be dropped\n\t\ttrash = []\n\n\t\t#finding and deleting rows with features that are already used and reseting the index\n\t\tfor i, (f1, f2, d) in enumerate(possible_matches.values):\n\t\t \n\t\t\tif np.all(f1 == best_match[0]) or np.all(f2 == best_match[1]):\n\t\t\t\ttrash.append(i)\n\t\n\t\tfor i in trash:\n\t\t\tpossible_matches.drop(i, inplace=True)\n\t\tpossible_matches.reset_index(inplace=True, drop=True)\n\t\t# print(possible_matches)\n\n\treturn matches","def one_to_one_compare(comparison_1, comparison_2):\r\n total = comparison_1.shape[0]\r\n interm = 0\r\n one2one = 0\r\n for row in comparison_1.itertuples():\r\n if row.gene_type == \"one_to_one_mapping\":\r\n interm += 1\r\n Q_gene = row.Query_gene\r\n S_gene = row.Sytentic_genes.split(\",\")[0]\r\n # get the index of the query gene in second file using subject gene var\r\n idx = comparison_2[comparison_2.Query_gene.isin([S_gene])].index.tolist()\r\n # check to see if the index is empty\r\n if idx:\r\n if comparison_2.at[idx[0], \"gene_type\"] == \"one_to_one_mapping\":\r\n comp_2_S_gene = comparison_2.at[idx[0], \"Sytentic_genes\"].split(\",\")[0]\r\n if comp_2_S_gene == Q_gene:\r\n one2one += 1\r\n return(total, interm, one2one)","def find_dimm_ids(**kwargs):\n member = kwargs.get(\"data\", {})\n memory_members = kwargs.get(\"resources\").get(\"memory\", [])\n interleave_sets = member.get(\"InterleaveSets\", [])\n locations = []\n for interleave_set in interleave_sets:\n for pmem in memory_members:\n if PmemHelpers.compare_id(\n interleave_set.get(\"Memory\").get(\"@odata.id\"), pmem.get(\"@odata.id\")\n ):\n location = Mapper.get_single_attribute(\n pmem, \"Location\", MappingTable.device.value, output_as_json=True\n )\n locations.append(location.get(\"Location\", \"\"))\n return PmemHelpers.location_format_converter(locations)[0]","def get_similarities(tags):\n return [(a, b)\n for (a, b) in itertools.permutations(tags, 2)\n if difflib.SequenceMatcher(a=a.lower(), b=b.lower()).ratio() > SIMILAR\n and a != b\n and b.endswith('s')]","def seq_dist(i1: int, s1: t.Collection[SeqGene],\n i2: int, s2: t.Collection[SeqGene]) -> t.Tuple[int, int, float]:\n m1, m2 = map(\n lambda s: dict(chain.from_iterable(\n ((pos, aa) for pos, aa in zip(g.Pos, g.Seq)) for g in s)),\n [s1, s2])\n d = 0.\n for p in set(m1) | set(m2):\n if p in m1 and p in m2 and m1[p] == m2[p]:\n continue\n d += 1\n return i1, i2, d","def pointfind2(plat, plon, lat, lon, pdif=1):\n\n\tdist_min = 1000000.\n\t\n\t\n\tfor i in range(lon.shape[0]):\n\t\tfor j in range(lon.shape[1]):\n\t\t\tdist = Ngl.gc_dist(plat,plon,lat[i,j],lon[i,j])\n\t\t\tif dist_min > dist:\n\t\t\t\tdist_min = dist\n\t\t\t\ti_min = i\n\t\t\t\tj_min = j\n\t\t\t\tlat_min = lat[i,j]\n\t\t\t\tlon_min = lon[i,j]\n\t\n\tprint(i_min,j_min,lat_min,lon_min)\n\tgg1 = i_min, j_min\n\t\n\treturn(gg1, lat_min, lon_min)","def splitNodes(matching):\n outer = set(range(self.n))\n inner = set([])\n for (u, v) in matching:\n if u in outer:\n outer.remove(u)\n if v in outer:\n outer.remove(v)\n inner.add(u)\n inner.add(v)\n return list(inner), list(outer)","def diff_index_calc(oct_abund_list1, oct_abund_list2):\n rel_index_list = []\n abs_index_list = []\n smty_index_list = []\n for i in range(10):\n abund_data_array = sc.asarray(oct_abund_list1[i], dtype='double')\n abund_sim_array = sc.asarray(oct_abund_list2[i], dtype = 'double')\n \n # make the length of the arrays similar to each other\n if len(abund_data_array) < len(abund_sim_array):\n small_len = abund_data_array\n long_len = abund_sim_array\n else:\n small_len = abund_sim_array\n long_len = abund_data_array\n diff = len(long_len) - len(small_len) \n small_len = sc.append(small_len, [0]*diff)\n \n relative_index_vect = abs(long_len - small_len)/long_len \n rel_index_list.append(sum(relative_index_vect)/len(relative_index_vect))\n \n absolute_index_vect = abs(long_len - small_len)\n abs_index_list.append(sum(absolute_index_vect)/len(absolute_index_vect))\n \n similarity_index_vect = []\n for i in range(len(long_len)):\n similarity_index_vect.append(sc.minimum(long_len[i], small_len[i])/sc.amax([long_len[i], small_len[i]]))\n \n smty_index_list.append(sum(similarity_index_vect)/len(similarity_index_vect)) \n \n rel_index_final = sum(rel_index_list)/10\n abs_index_final = sum(abs_index_list)/10\n smty_index_final = sum(smty_index_list)/10\n \n return (rel_index_final, abs_index_final, smty_index_final)","def compare_trees(tree1, tree2):\n \tresponse = {}\n \tstart_time = time.time()\n \ttry:\t\n \t\ttns = dendropy.TaxonNamespace() \t\n \t\n \t\ttree_obj1 = dendropy.Tree.get(data=tree1, schema=\"newick\",taxon_namespace=tns)\n \t\ttree_obj2 = dendropy.Tree.get(data=tree2, schema=\"newick\",taxon_namespace=tns)\n\n \t\ttree_obj1.encode_bipartitions()\n \t\ttree_obj2.encode_bipartitions()\n\n \t\t#-----------------------------------------------------------\n \t\t#This method returns the symmetric distance between two trees. \n \t\t#The symmetric distance between two trees is the sum of the number of splits found in one of the trees but not the other. \n \t\t#It is common to see this statistic called the Robinson-Foulds distance\n\n \t\tareSame = True if treecompare.symmetric_difference(tree_obj1, tree_obj2) == 0 else False\n \t\tstatus = 200\n \t\tmessage = \"Success\"\n \t\tresponse['are_same_tree'] = areSame\n \n \texcept Exception, e:\n \t\tif \"Incomplete or improperly-terminated tree statement\" in str(e): #invalid: \"((A,B),C,D));\" valid: ((A,B),(C,D)); \n \t\t\tmessage = \"NewickReaderIncompleteTreeStatementError: \" + str(e)\n \t \t\tstatus = 400\n \t\telif \"Unbalanced parentheses at tree statement\" in str(e): #invalid: \"((A,B),(C,D);\" valid: ((A,B),(C,D)); \n \t\t\tmessage = \"NewickReaderMalformedStatementError: \"+str(e) \n \t \t\tstatus = 400\n \t\telif \"Multiple occurrences of the same taxa\" in str(e): #invalid: \"((A,B),(C,C));\" valid: ((A,B),(C,D));\n \t\t\tmessage = \"NewickReaderDuplicateTaxonError: \"+str(e)\n \t \t\tstatus = 400\n \t\telif \"Unexpected end of stream\" in str(e): # invalid: \"((A,B),(C,D))\" valid: ((A,B),(C,D));\n \t\t\tmessage = \"UnexpectedEndOfStreamError: \"+str(e)\n \t \t\tstatus = 400\n \t\telse:\n \t\t\tmessage = \"Error: Failed to compare trees. \"+str(e)\n \t \t\tstatus = 500\n \t \t\n \tresponse['status_code'] = status\n \tresponse['message'] = message\n\n \tend_time = time.time()\n \texecution_time = end_time-start_time\n #service result creation time\n \tcreation_time = datetime.datetime.now().isoformat()\n \tmeta_data = {'creation_time': creation_time, 'execution_time': float('{:4.2f}'.format(execution_time)), 'source_urls':[\"http://dendropy.org/library/treecompare.html#module-dendropy.calculate.treecompare\"] }\n\n \tresponse['meta_data'] = meta_data\n \tprint response\n \treturn response","def find_matches(id1, id2, adj_list_ids, adj_list_words):\n\n # combine words from tweets\n stanza_words = adj_list_ids[id1] + adj_list_ids[id2]\n\n # look for other tweets with those words\n pot_ids = set().union(*[adj_list_words[w] for w in stanza_words])\n\n # --- filter down ---\n # remove start tweets\n # ensure tweets contain subset of master_word_set\n pot_ids = pot_ids - {id1, id2}\n pot_ids = [x for x in pot_ids if set(adj_list_ids[x]) <= set(stanza_words)]\n\n # look for valid pairs of potential tweets\n if len(pot_ids) > 1:\n return find_valid_matches(pot_ids, adj_list_ids, stanza_words)\n return []","def match_all(data_dir):\n print('Loading GT')\n gt_cells = load(os.path.join(data_dir, 'cell_obj', 'cells_final_selected.hdf5'))\n storm_i = np.load(os.path.join(data_dir, 'images', 'storm_inner.npy'))\n\n for ph in [10000, 1000, 500]:\n print('Photons {}'.format(ph))\n\n m_cells = load(os.path.join(data_dir, 'cell_obj', 'cell_ph_{}_raw.hdf5'.format(ph)))\n print('Measured cells loaded')\n\n bin_predicted = tifffile.imread(os.path.join(data_dir, 'images', 'binary_{}photons_predicted.tif'.format(ph)))\n print('Filtering')\n filtered_pred = filter_binaries(bin_predicted, min_size=495, max_size=2006.4, min_minor=7.57, max_minor=17.3,\n min_major=15.41, max_major=54.97)\n\n gt_match, m_match, = match_cells(gt_cells, m_cells, storm_i, filtered_pred, max_d=5)\n\n print('Matched {} cells out of max {}'.format(len(m_match), len(m_cells)))\n\n for i, (m_, gt_) in tqdm(enumerate(zip(m_match, gt_match))):\n m_i = m_cells.name.tolist().index(m_.rstrip())\n g_i = gt_cells.name.tolist().index(gt_.rstrip())\n\n try:\n assert len(m_cells[m_i].data.data_dict['storm_inner']) == len(gt_cells[g_i].data.data_dict['storm_inner'])\n except AssertionError:\n print('Assertion error:', i)\n\n with open(os.path.join(data_dir, 'matched_names', 'gt_cells_ph_{}_match.txt'.format(ph)), 'w') as f:\n f.writelines(gt_match)\n\n with open(os.path.join(data_dir, 'matched_names', 'm_cells_ph_{}_match.txt'.format(ph)), 'w') as f:\n f.writelines(m_match)","def pairs(data1, r, data2=None, period=None):\n \n #work with arrays!\n data1 = np.asarray(data1)\n if data2==None:\n data2 = np.asarray(data1)\n self_match=False\n else:\n data2 = np.asarray(data2)\n self_match=True\n \n #Check to make sure both data sets have the same dimension. Otherwise, throw an error!\n if np.shape(data1)[-1]!=np.shape(data2)[-1]:\n raise ValueError(\"data1 and data2 inputs do not have the same dimension.\")\n return None\n \n #Process period entry and check for consistency.\n if period is None:\n period = np.array([np.inf]*np.shape(data1)[-1])\n else:\n period = np.asarray(period).astype(\"float64\")\n if np.shape(period) == ():\n period = np.array([period]*np.shape(data1)[-1])\n if np.shape(period)[0] != np.shape(data1)[-1]:\n raise ValueError(\"period should have len == dimension of points\")\n return None\n \n tree_1 = cKDTree(data1)\n \n pairs = tree_1.query_ball_tree(tree_2, r, period=period)\n \n spairs = set()\n for i in range(len(pairs)):\n if self_match==False:\n if pairs[i,0] != pairs[i,1]:\n spairs.add((min(pairs[i]),max(pairs[i])))\n if self_match==True:\n spairs.add((min(pairs[i]),max(pairs[i])))\n \n return spairs","def _node_distance(self, first, second):\r\n\r\n name_1 = first.name.split(' ')[0]\r\n name_2 = second.name.split(' ')[0]\r\n\r\n seq1 = self.msa_by_name[name_1]\r\n seq2 = self.msa_by_name[name_2]\r\n\r\n distance = self._seq_distance(seq1, seq2)\r\n\r\n return distance"],"string":"[\n \"def get_matched_nodeids_from_orderids(sorted_small_nodes, sorted_large_nodes, matched_orderids):\\n orderid2nodeid_func = lambda order_pair: (sorted_small_nodes[order_pair[0]].nodeid, sorted_large_nodes[order_pair[1]].nodeid)\\n return list(map(orderid2nodeid_func, matched_orderids))\",\n \"def get_matches(self, first, second):\\n matches = self._match_table.dropna(0)[\\n [first.position.id, second.position.id]].astype(int).values\\n return matches\",\n \"def sm_get_matching_blocks(s1,s2,min_length=1):\\n anslist= list(SM(None, s1, s2).get_matching_blocks())\\n\\n\\n anslist = [ l for l in anslist if l.size>=min_length]\\n\\n anslist=[ (s1[l.a:l.a+l.size], l.a, l.b, l.size) for l in anslist]\\n return anslist\",\n \"def compare_nodes(G,all_match_pairs,match_pair,traversed,node1,node2, ports_weight):\\n logger.debug(f\\\"comparing {node1},{node2}, traversed {traversed}\\\")\\n nbrs1 = sorted(set(G.neighbors(node1)) - set(traversed))\\n #remove dummies\\n nbrs1 = sorted(set([nbr for nbr in nbrs1 if G.get_edge_data(node1, nbr)['weight'] !=7]))\\n nbrs2 = sorted(set(G.neighbors(node2)) - set(traversed))\\n #remove dummies\\n nbrs2 = sorted(set([nbr for nbr in nbrs2 if G.get_edge_data(node2, nbr)['weight'] !=7]))\\n logger.debug(f\\\"node1:{node1},property: {G.nodes[node1]},neigbors1: {nbrs1}\\\")\\n logger.debug(f\\\"node2:{node2},property: {G.nodes[node2]},neigbors2: {nbrs2}\\\")\\n if not nbrs1 or not nbrs2:\\n if compare_two_nodes(G, node1, node2, ports_weight):\\n match_pair[node1] = node2\\n logger.debug(f\\\"no new neihbours, returning recursion {match_pair}\\\")\\n return\\n elif len(nbrs1)> 10:\\n if \\\"start_point\\\" in match_pair.keys():\\n match_pair[\\\"start_point\\\"]+=[node1,node2]\\n else:\\n match_pair[\\\"start_point\\\"]=[node1,node2]\\n logger.debug(f\\\"skipping high fanout nets due to large computation, {node1} {nbrs1}\\\")\\n traversed.append(node1)\\n return\\n elif len(nbrs2)> 10:\\n if \\\"start_point\\\" in match_pair.keys():\\n match_pair[\\\"start_point\\\"]+=[node1,node2]\\n else:\\n match_pair[\\\"start_point\\\"]=[node1,node2]\\n traversed.append(node2)\\n logger.debug(f\\\"skipping high fanout nets due to large computation, {node2} {nbrs2}\\\")\\n return\\n\\n if node1 == node2:\\n if node1 in match_pair.keys() or node1 in match_pair.values():\\n logger.debug(\\\"avoid existing pair wise symmetry\\\")\\n return\\n logger.debug(f\\\"single node {node1}, nbrs {nbrs1}, nbr_weight {[G.get_edge_data(node1,nbr) for nbr in nbrs1]}\\\")\\n SD_nbrs= [nbr for nbr in nbrs1 if G.get_edge_data(node1, nbr)['weight'] !=2]\\n ## TBD: filter based on primitive constraints\\n ## Right now will try to figure out S/D paths\\n if len(SD_nbrs) ==0:\\n logger.debug(f\\\"No SD paths found to traverse\\\")\\n match_pair[node1]=node1\\n elif len(SD_nbrs) ==1:\\n logger.debug(f\\\"traversing single S/D path {SD_nbrs}\\\")\\n match_pair[node1]=node1\\n traversed.append(node1)\\n compare_nodes(G,all_match_pairs,match_pair,traversed,SD_nbrs[0],SD_nbrs[0],ports_weight)\\n else:\\n logger.debug(f\\\" multiple nodes diverging {SD_nbrs}\\\")\\n logger.debug(f\\\"nbr weights: {SD_nbrs} {[G.get_edge_data(node1, nbr)['weight'] for nbr in SD_nbrs ]}\\\")\\n match_pair[node1]=node1\\n traversed.append(node1)\\n new_sp=sorted(set(SD_nbrs)-set(traversed))\\n all_match_pairs_local={}\\n for nbr1,nbr2 in combinations(new_sp, 2):\\n logger.debug(f\\\"recursive pair call from single branch {nbr1} {nbr2}\\\")\\n new_pair={}\\n compare_nodes(G,all_match_pairs,new_pair,traversed.copy(),nbr1,nbr2,ports_weight)\\n if new_pair:\\n #new_pair[nbr1]=nbr2\\n all_match_pairs_local[nbr1+'_'+nbr2] = new_pair\\n all_match_pairs_local={k: v for k, v in all_match_pairs_local.items() if len(v)>0}\\n if len(all_match_pairs_local)==1:\\n match_pair.update( all_match_pairs_local[list(all_match_pairs_local.keys())[0]])\\n logger.debug(f\\\"found inline pair: {pprint.pformat(match_pair, indent=4)}\\\")\\n else:\\n for nbr1 in new_sp:\\n if (nbr1+'_'+nbr1 not in all_match_pairs.keys()):\\n logger.debug(f\\\"recursive single branch call from single branch {nbr1} {nbr1}\\\")\\n new_pair={}\\n compare_nodes(G,all_match_pairs,new_pair,traversed.copy(),nbr1,nbr1,ports_weight)\\n #filtering multiple axis of symmetries with same block, ideally they should be handled by array generation\\n if new_pair:\\n all_match_pairs[nbr1+'_'+nbr1] = new_pair\\n logger.debug(f\\\"updating match pairs: {pprint.pformat(all_match_pairs, indent=4)}\\\")\\n\\n\\n elif nbrs1 == nbrs2:\\n logger.debug(f\\\"traversing converging branch\\\")\\n match_pair[node1]=node2\\n traversed+=[node1,node2]\\n nbrs1=sorted(set(nbrs1)-set([node1,node2]))\\n logger.debug(f\\\"all non traversed neighbours: {nbrs1}\\\")\\n if len(nbrs1)==1:\\n nbr1=nbr2=nbrs1[0]\\n logger.debug(f\\\"keeping single converged branch inline {nbr1} {nbr2}\\\")\\n compare_nodes(G,all_match_pairs,match_pair,traversed.copy(),nbr1,nbr2,ports_weight)\\n else:\\n for nbr1,nbr2 in combinations_with_replacement(nbrs1,2):\\n logger.debug(f\\\"recursive call from converged branch {nbr1} {nbr2}\\\")\\n if nbr1+'_'+nbr2 not in all_match_pairs.keys():\\n new_pair={}\\n compare_nodes(G,all_match_pairs,new_pair,traversed.copy(),nbr1,nbr2,ports_weight)\\n #filtering multiple axis of symmetries with same block, ideally they should be handled by array generation\\n if new_pair:\\n all_match_pairs[nbr1+'_'+nbr2] = new_pair\\n logger.debug(f\\\"updating match pairs: {pprint.pformat(all_match_pairs, indent=4)}\\\")\\n\\n\\n elif compare_two_nodes(G,node1,node2,ports_weight):\\n nbrs1 = sorted(set([nbr for nbr in nbrs1 if G.get_edge_data(node1, nbr)['weight'] !=2]))\\n nbrs2 = sorted(set([nbr for nbr in nbrs2 if G.get_edge_data(node2, nbr)['weight'] !=2]))\\n match_pair[node1]=node2\\n traversed+=[node1,node2]\\n logger.debug(f\\\"Traversing parallel branches from {node1},{node2} {nbrs1}, {nbrs2}\\\")\\n nbrs1_wt = [G.get_edge_data(node1, nbr)['weight'] for nbr in nbrs1]\\n nbrs2_wt = [G.get_edge_data(node2, nbr)['weight'] for nbr in nbrs2]\\n unique_match=find_unique_matching_branches(G,nbrs1,nbrs2,ports_weight)\\n if len(nbrs1)==0 or len(nbrs2)==0:\\n logger.debug(f\\\"no new SD neihbours, returning recursion {match_pair}\\\")\\n elif len(nbrs1) ==1 and len(nbrs2)==1:\\n logger.debug(f\\\"traversing binary branch\\\")\\n compare_nodes(G,all_match_pairs,match_pair,traversed,nbrs1.pop(),nbrs2.pop(),ports_weight)\\n elif unique_match:\\n logger.debug(f'traversing unique matches {unique_match}')\\n match_pair[node1]=node2\\n traversed+=[node1,node2]\\n for nbr1,nbr2 in unique_match.items():\\n logger.debug(f\\\"recursive call from binary {node1}:{node2} to {nbr1}:{nbr2}\\\")\\n compare_nodes(G,all_match_pairs,match_pair,traversed.copy(),nbr1,nbr2,ports_weight)\\n elif len(nbrs1_wt)>len(set(nbrs1_wt))>1 and len(nbrs2_wt)>len(set(nbrs2_wt))>1:\\n logger.debug(f\\\"setting new start points {node1} {node2}\\\")\\n match_pair[node1]=node2\\n if \\\"start_point\\\" in match_pair.keys():\\n match_pair[\\\"start_point\\\"]+=[node1,node2]\\n else:\\n match_pair[\\\"start_point\\\"]=[node1,node2]\\n else:\\n match_pair = {}\\n logger.debug(f\\\"end all traversal from binary branch {node1} {node2}\\\")\\n\\n else:\\n match_pair = {}\\n logger.debug(f\\\"end of recursion branch, matches {match_pair}\\\")\",\n \"def distance_mentions(m_i, m_j):\\n return abs(m_i.id - m_j.id)\",\n \"def nn_set2set_match(descs1, descs2):\\n idxs = nn_set2set_match_cuda(descs1.unsqueeze(0).cuda(), descs2.unsqueeze(0).cuda()).detach().cpu().long()\\n return idxs[0]\",\n \"def find_extra_surface_nodeids(orderids, sorted_large_nodes):\\n extra_nodeids = []\\n first_overlap_orderid = orderids[0]\\n min_cfrom = sorted_nodes[first_overlap_orderid].cfrom\\n\\n # Check if any earlier nodes also in the region.\\n while True:\\n prev_cfrom = sorted_nodes[first_overlap_orderid-1].cfrom\\n if prev_cfrom == min_cfrom:\\n first_overlap_orderid -= 1\\n extra_nodeids.append(sorted_nodes[first_overlap_orderid].nodeid)\\n else:\\n break\\n\\n # Find the last node in the region.\\n last_overlap_orderid = matched_orderids[-1]\\n max_cto = sorted_nodes[last_overlap_orderid].cto\\n for i in range(first_overlap_orderid, len(sorted_nodes)):\\n if sorted_nodes[i].cfrom > max_cto:\\n break\\n else:\\n if i not in orderids:\\n extra_nodeids.append(sorted_nodes[i].nodeid)\\n cto = sorted_nodes[i].cto\\n if cto >= max_cto:\\n max_cto = cto\\n if i > last_overlap_orderid:\\n last_overlap_orderid = i\\n\\n return extra_nodeids\",\n \"def solve_part1(start):\\n inputs = load_inputs(False)\\n two_matches = []\\n tiles = inputs.keys()\\n for elem in tiles:\\n matches = defaultdict(list)\\n for elem2 in tiles:\\n if elem != elem2 and compare_tile(inputs[elem], inputs[elem2]):\\n l = matches[elem]\\n l.append(elem2)\\n\\n if len(matches[elem]) == 2:\\n print matches\\n two_matches.append(elem)\\n\\n return reduce((lambda x, y: int(x) * int(y)), two_matches)\",\n \"def __find_similar_pairs(self):\\n size = len(self.__indexclusters)\\n candidates = []\\n for i in range(size):\\n for j in range(i+1, size):\\n simi = self.__cluster_simi(i, j)\\n #print simi, self.__indexclusters[i],self.__indexclusters[j]\\n if simi >= self.__threshold:\\n candidates.append((simi, i, j))\\n candidates.sort(reverse = True, key = lambda x: x[0])\\n\\n\\n # filter overlapped pairs\\n to_remove = set()\\n appeared = set()\\n for index, cand in enumerate(candidates):\\n if cand[1] not in appeared and cand[2] not in appeared:\\n appeared.add(cand[1])\\n appeared.add(cand[2])\\n else:\\n to_remove.add(index)\\n\\n #print 'ahha'\\n #print [(cand[1], cand[2]) for index, cand in enumerate(candidates) if index not in to_remove]\\n\\n return [(cand[1], cand[2]) for index, cand in enumerate(candidates)\\n if index not in to_remove]\",\n \"def needleMatching(self):\\r\\n # productive\\r\\n profprint()\\r\\n modelNodes = slicer.mrmlScene.GetNodesByClass('vtkMRMLModelNode')\\r\\n nbNode = modelNodes.GetNumberOfItems()\\r\\n result = []\\r\\n found = []\\r\\n # print nbNode\\r\\n for nthNode in range(nbNode):\\r\\n node = slicer.mrmlScene.GetNthNodeByClass(nthNode, 'vtkMRMLModelNode')\\r\\n if node.GetID() not in found and node.GetAttribute('type') != 'Validation':\\r\\n dist = []\\r\\n polydata = node.GetPolyData()\\r\\n if polydata != None:\\r\\n bounds = polydata.GetBounds()\\r\\n for nthNode2 in range(nbNode):\\r\\n node2 = slicer.mrmlScene.GetNthNodeByClass(nthNode2, 'vtkMRMLModelNode')\\r\\n if node2.GetID() not in found and node2.GetAttribute('type') == 'Validation':\\r\\n polydata2 = node2.GetPolyData()\\r\\n if polydata2 != None and polydata2.GetNumberOfPoints() > 100 and polydata.GetNumberOfPoints() > 100:\\r\\n tipDistance = self.distTip(int(node.GetID().strip('vtkMRMLModelNode')) , int(node2.GetID().strip('vtkMRMLModelNode')))\\r\\n baseDistance = self.distBase(int(node.GetID().strip('vtkMRMLModelNode')) , int(node2.GetID().strip('vtkMRMLModelNode')))\\r\\n name = node.GetName()\\r\\n manualName = name.lstrip('auto-seg_').lstrip('manual-seg_').lstrip('obturator-seg_').lstrip('0123456789').lstrip('-ID-vtkMRMLModelNode').lstrip('0123456789-')\\r\\n if manualName==node2.GetName(): dist.append([tipDistance, node2.GetID(), node2.GetName()])\\r\\n # print tipDistance\\r\\n if dist != []:\\r\\n match = [min(dist)[0], min(dist)[1], node.GetID(), min(dist)[2]]\\r\\n result.append(match)\\r\\n found.append(min(dist)[1])\\r\\n found.append(node.GetID())\\r\\n node.GetDisplayNode().SetSliceIntersectionVisibility(1)\\r\\n # print result\\r\\n return result\",\n \"def nearby():\\n for i in ids:\\n for j in ids:\\n if i != j:\\n if sum([1 for x,y in zip(i,j) if x!=y]) == 1:\\n print(\\\"\\\".join([x for x,y in zip(i,j) if x==y]))\\n return\",\n \"def selectCompatibleIndices(bigTimes, smallTimes):\\r\\n indices = []\\r\\n for idx, _ in enumerate(smallTimes):\\r\\n distances = (bigTimes - smallTimes[idx])**2\\r\\n def getValue(k):\\r\\n return distances[k]\\r\\n thisIndices = sorted(range(len(distances)), key=getValue)\\r\\n indices.append(thisIndices[0])\\r\\n return np.array(indices)\",\n \"def make_compatible_distance_matrices(dm1, dm2, lookup=None):\\r\\n dm1_ids = dm1[0]\\r\\n dm1_data = dm1[1]\\r\\n dm2_ids = dm2[0]\\r\\n dm2_data = dm2[1]\\r\\n\\r\\n if lookup:\\r\\n try:\\r\\n dm1_ids = [lookup[e] for e in dm1_ids]\\r\\n dm2_ids = [lookup[e] for e in dm2_ids]\\r\\n except KeyError as e:\\r\\n raise KeyError(\\\"All entries in both DMs must be in lookup if a \\\"\\r\\n \\\"lookup is provided. Missing: %s\\\" % str(e))\\r\\n order = [e for e in dm1_ids if e in dm2_ids]\\r\\n\\r\\n if len(order) == 0:\\r\\n return ([], []), ([], [])\\r\\n\\r\\n # store the intersected distance matrices here\\r\\n matrices = []\\r\\n\\r\\n # iterate over the distance matrices and identifiers to match the data\\r\\n # note that the order must be the same between the two matrices\\r\\n for ids, distance_matrix in [(dm1_ids, dm1_data), (dm2_ids, dm2_data)]:\\r\\n\\r\\n # the order is kept by getting the indices from this list\\r\\n indices = [ids.index(element) for element in order]\\r\\n\\r\\n # this matrix contains the matched up data\\r\\n out = distance_matrix[indices][:, indices]\\r\\n matrices.append(out)\\r\\n\\r\\n return (order, matrices[0]), (order, matrices[1])\",\n \"def find_mutual_nn(self):\\n best_match_src = self.scores.argmax(1) # Best match for each source word\\n best_match_trg = self.scores.argmax(0) # Best match for each source word\\n\\n # ONELIENER\\n # paired_idx = [(i,best_match_src[i]) for i in range(self.ns) if best_match_trg[best_match_src[i]] == i]\\n # paired_words = [(self.src_words[i],self.trg_words[j]) for (i,j) in paired_idx]\\n paired = []\\n for i in range(self.ns):\\n m = best_match_src[i]\\n if best_match_trg[m] == i:\\n paired.append((i,m))\\n\\n paired_toks = []\\n if self.src_words and self.trg_words:\\n paired_toks = [(self.src_words[i],self.trg_words[j]) for (i,j) in paired]\\n else:\\n paired_toks = paired\\n return paired_toks\",\n \"def compare_search(sizes=[1e1, 1e2, 1e3, 1e4, 1e5, 1e6, 1e7]):\\n\\tprint(sizes)\\n\\treturn [(size,\\n\\t\\t\\t time_search(linear_search, list(range(int(size))), -1),\\n\\t\\t\\t time_search(binary_search, list(range(int(size))), -1)) for size in sizes]\",\n \"def match(desc1, desc2):\\n desc1 = array([d/linalg.norm(d) for d in desc1])\\n desc2 = array([d/linalg.norm(d) for d in desc2])\\n\\n dist_ratio = 0.6\\n disc1_size = desc1.shape\\n\\n matchscores = zeros((desc1_size[0]), \\\"int\\\")\\n desc2t = desc2.T\\n for i in range(desc1_size[0]):\\n dotprods = dot(desc1[i, :], desc2t)\\n dotprods = 0.9999 * dotprods\\n\\n indx = argsort(arccos(dotprods))\\n\\n if arccos(dotprods)[indx[0]] < dist_ratio * arccos(dotprods)[indx[1]]:\\n matchscores[i] = int(indx[0])\\n\\n return matchscores\",\n \"def remove_xmatch_multiples(index_primary, index_secondary, d2d, d3d, retain_best_match=True,\\n verbose=False):\\n n_entries = len(index_primary)\\n n_unique_entries = len(np.unique(index_primary))\\n if verbose:\\n print('xmatch: cleanMultipleCrossMatches: there are {0:d} unique entries in the primary '\\n 'catalog'.format(n_unique_entries))\\n\\n if n_entries != n_unique_entries:\\n # get array of unique indices (here like identifier) and the corresponding occurrence count\\n unique_array, return_counts = np.unique(index_primary, return_counts=True)\\n\\n # indices in unique array of stars with multiple crossmatches\\n index_in_unique_array = np.where(return_counts > 1)[0]\\n number_of_stars_with_multiplematches = len(index_in_unique_array)\\n if verbose:\\n if retain_best_match:\\n print('xmatch: result contains {} multiple matches affecting {} entries, '\\n 'keeping closest match'.format(number_of_stars_with_multiplematches,\\n n_entries - n_unique_entries))\\n else:\\n print('xmatch: result contains {} multiple matches affecting {} entries, removing '\\n 'them all'.format(number_of_stars_with_multiplematches,\\n n_entries - n_unique_entries))\\n\\n # identifiers (i.e. numbers in index_primary) of stars with multiple crossmatches\\n multi_matches = unique_array[index_in_unique_array]\\n\\n # index in index_primary where multiple matches occur\\n index_multiple_match = np.where(np.in1d(index_primary, multi_matches))[0]\\n if verbose:\\n print(d2d[index_multiple_match], index_primary[index_multiple_match], index_secondary[index_multiple_match])\\n\\n good_index_in_index_primary = np.zeros(number_of_stars_with_multiplematches)\\n for ii, jj in enumerate(multi_matches):\\n tmp_idx0 = np.where(index_primary[index_multiple_match] == jj)[0]\\n tmp_idx1 = np.argmin(d2d[index_multiple_match][tmp_idx0])\\n good_index_in_index_primary[ii] = index_primary[index_multiple_match][tmp_idx0[tmp_idx1]]\\n\\n if retain_best_match:\\n index_to_remove = np.setdiff1d(index_multiple_match, good_index_in_index_primary)\\n else:\\n index_to_remove = index_multiple_match\\n\\n mask = np.ones(len(index_primary), dtype=bool)\\n mask[index_to_remove] = False\\n index_primary = index_primary[mask]\\n index_secondary = index_secondary[mask]\\n d2d = d2d[mask]\\n d3d = d3d[mask]\\n if len(index_primary) != len(np.unique(index_primary)):\\n print('xmatch: Multiple match cleanup procedure failed')\\n # get array of unique indices (here like identifier) and the corresponding occurrence count\\n unique_array, return_counts = np.unique(index_primary, return_counts=True)\\n\\n # indices in unique array of stars with multiple crossmatches\\n index_in_unique_array = np.where(return_counts > 1)[0]\\n number_of_stars_with_multiplematches = len(index_in_unique_array)\\n print('xmatch: result still contains {} multiple matches'.format(\\n number_of_stars_with_multiplematches))\\n\\n return index_primary, index_secondary, d2d, d3d\",\n \"def cal_similarity(query_feat, gallery_feat, q_pids, g_pids, q_camids, g_camids):\\n # The larger the cosine distance, the more similar it is\\n distmat = -np.matmul(query_feat, np.transpose(gallery_feat))\\n num_q = query_feat.shape[0]\\n num_g = gallery_feat.shape[0]\\n max_rank = 10\\n if num_g < max_rank:\\n max_rank = num_g\\n print(\\\"Note: number of gallery samples is quite small, got {}\\\".format(num_g))\\n indices = np.argsort(distmat, axis=1)\\n pred_label = g_pids[indices]\\n matches = (pred_label == q_pids[:, np.newaxis]).astype(np.int32)\\n\\n return_matchs = []\\n return_index = []\\n\\n for q_idx in range(num_q):\\n q_pid = q_pids[q_idx]\\n q_camid = q_camids[q_idx]\\n\\n # remove gallery samples that have the same pid and camid with query\\n order = indices[q_idx]\\n remove = (q_camid == 3) & (g_camids[order] == 2)\\n keep = np.invert(remove)\\n\\n new_matchs = matches[q_idx][keep]\\n new_index = indices[q_idx][keep]\\n\\n return_matchs.append(new_matchs[:10])\\n return_index.append(new_index[:10])\\n\\n return np.asarray(return_index).astype(np.int32), np.asarray(return_matchs).astype(np.int32)\",\n \"def find_matches_for_start_pairs(pairs, adj_list_ids, adj_list_words):\\n all_valid = []\\n for p in tqdm(pairs):\\n valid = find_matches(p[0], p[1], adj_list_ids, adj_list_words)\\n if valid:\\n all_valid.append((p, valid))\\n return all_valid\",\n \"def _partition_nearest(self, medoids, dists, only_these=set()):\\n if len(only_these) == 0:\\n allowed_inds = self._not_ignored_inds\\n else:\\n allowed_inds = self._not_ignored_inds & only_these\\n closest_medoid_ind = np.argmin(dists[:,medoids], 1) # If len(medoids)==3, would look like [2,1,1,0,1,2,...].\\n clusts = [[] for i in medoids]\\n for node_ind, med_ind in enumerate(closest_medoid_ind):\\n if node_ind in allowed_inds:\\n clusts[med_ind].append(node_ind)\\n return clusts\",\n \"def _gen_matches(target_units, source_units, stoplist_set, features_size):\\n for hits2positions in gen_hits2positions(\\n target_units, source_units, stoplist_set, features_size):\\n overhits2positions = {\\n k: np.array(v) for k, v in hits2positions.items()\\n if len(v) >= 2}\\n for (t_ind, s_ind), positions in overhits2positions.items():\\n yield (t_ind, s_ind, positions)\",\n \"def needleMatching(self):\\n #productive\\n profprint()\\n modelNodes=slicer.mrmlScene.GetNodesByClass('vtkMRMLModelNode')\\n nbNode=modelNodes.GetNumberOfItems()\\n result=[]\\n found=[]\\n #print nbNode\\n for nthNode in range(nbNode):\\n node=slicer.mrmlScene.GetNthNodeByClass(nthNode,'vtkMRMLModelNode')\\n if node.GetID() not in found and node.GetAttribute('type')!='Validation':\\n dist=[]\\n polydata = node.GetPolyData()\\n if polydata!=None:\\n bounds = polydata.GetBounds()\\n for nthNode2 in range(nbNode):\\n node2=slicer.mrmlScene.GetNthNodeByClass(nthNode2,'vtkMRMLModelNode')\\n if node2.GetID() not in found and node2.GetAttribute('type')=='Validation':\\n polydata2 = node2.GetPolyData()\\n if polydata2!=None and polydata2.GetNumberOfPoints()>100 and polydata.GetNumberOfPoints()>100:\\n\\n axialDistance=self.distTip( int(node.GetID().strip('vtkMRMLModelNode')) , int(node2.GetID().strip('vtkMRMLModelNode')))\\n \\n dist.append([axialDistance,node2.GetID()])\\n # print axialDistance\\n \\n if dist!=[]:\\n match=[min(dist)[0],min(dist)[1],node.GetID()]\\n result.append(match)\\n found.append(min(dist)[1])\\n found.append(node.GetID()) \\n node.GetDisplayNode().SetSliceIntersectionVisibility(1)\\n # print result\\n return result\",\n \"def match3(img1, img2, coordinates1, coordinates2, PATCH_SIZE, threshold=0.7):\\n\\n\\t#creating patches for all points from img1 and img2\\n\\tcoord1_patches = [make_patch(coordinate, PATCH_SIZE, img1) for coordinate in coordinates1]\\n\\tcoord2_patches = [make_patch(coordinate, PATCH_SIZE, img2) for coordinate in coordinates2]\\n\\n\\t# creating a matrix with dissimilarity measures for all pairs\\n\\tall_matches = np.zeros((len(coordinates1), len(coordinates2)))\\n\\n\\tfor (x, y), _ in np.ndenumerate(all_matches):\\n\\t\\tall_matches[x,y] = count_difference(coord1_patches[x], coord2_patches[y])\\n\\n\\t#looking for best left-to-right and right-to-left matches\\n\\tmatches = []\\n\\t#left-to-right\\n\\tfor i, coord1 in enumerate(coordinates1):\\n\\t\\tbest_ltr_match = np.argmin(all_matches[i, :]) #best left-to-right match for coord1\\n\\t\\tbest_rtl_match = np.argmin(all_matches[:, best_ltr_match]) #best match for a best match\\n\\t\\tif (i == best_rtl_match): #hurray, there is a super match\\n\\n\\t\\t\\tmatches.append([coord1, coordinates2[best_ltr_match], all_matches[i, best_ltr_match]])\\n\\t\\n\\treturn matches\",\n \"def findMatches(personDict,personDict2):\\n matches = {}\\n skepticalMatches = {}\\n for i in range(1,19):\\n if tags[i] not in ['SSN','PHONE']:\\n continue\\n\\n dictConsidered = personDict[tags[i]]\\n done = False\\n\\n for duplicatedEntry in dictConsidered:\\n if duplicatedEntry==\\\"\\\":\\n #skip the empty entries\\n continue\\n pairs = itertools.combinations(dictConsidered[duplicatedEntry],2)\\n if done:\\n break\\n for p in pairs:\\n if done:\\n break\\n\\n info1 = personDict['EnterpriseID'][p[0]]\\n info2 = personDict['EnterpriseID'][p[1]]\\n info1b = personDict2['EnterpriseID'][p[0]]\\n info2b = personDict2['EnterpriseID'][p[1]]\\n k = tuple(sorted(p))\\n \\n if k not in matches and k not in skepticalMatches:\\n if (((info1[1]==info2[1])and info1[1]!='') or((info1[2]==info2[2])and info1[2]!='') or ((info1[5]==info2[5])and info1[5]!='') ):\\n score = getScorePair(info1b,info2b)\\n \\n \\n if (abs(int(k[0])-int(k[1]))<10) and score<7:\\n #This is likely not a real match\\n skepticalMatches[k] = score\\n else:\\n #This is a real match\\n matches[k] = score\\n \\n return matches,skepticalMatches\",\n \"def find_similarity(long, short):\\n similarity1 = 0\\n similarity2 = 0\\n for i in range(len(long)-len(short)+1):\\n a = 0\\n part = long[i:i+len(short)]\\n for j in range(len(part)):\\n if part[j] == short[j]:\\n a += 1\\n if a == len(short):\\n similarity1 = part\\n return similarity1\\n elif a > similarity2:\\n similarity2 = a\\n similarity1 = part\\n return similarity1\",\n \"def find_longest_matches(sorted_nodes1, sorted_nodes2):\\n root = TreeNode(-1,-1)\\n fill_tree(root, sorted_nodes1, sorted_nodes2)\\n match = find_treepaths(root, [])\\n\\n # Remove (-1, -1) superroot.\\n if isinstance(match[0], list): # More than one match of the same length.\\n res = []\\n for m in match:\\n res.append([node.to_tuple() for node in m[1:]])\\n return res\\n else:\\n return [[node.to_tuple() for node in match[1:]]]\",\n \"def common_ids(descendent_ids, ancestor_ids, threshold=0.5):\\n\\n common = np.intersect1d(descendent_ids, ancestor_ids)\\n return common.size > threshold * ancestor_ids.size\",\n \"def compare_two_grids( treecode1, treecode2 ):\\n import numpy as np\\n\\n common_blocks = 0\\n\\n for i in range(treecode1.shape[0]):\\n # we look for this tree code in the second array\\n code1 = treecode1[i,:]\\n\\n for j in range(treecode2.shape[0]):\\n code2 = treecode2[j,:]\\n if np.linalg.norm( code2-code1 ) < 1.0e-13:\\n # found code1 in the second array\\n common_blocks += 1\\n break\\n\\n print( \\\"Nblocks1=%i NBlocks2=%i common blocks=%i\\\" % (treecode1.shape[0], treecode2.shape[0], common_blocks) )\\n\\n return common_blocks / treecode1.shape[0]\",\n \"def get_min_distances_per_query(dst, n_matches_per_query):\\n print(time.asctime(), ' Sorting distances')\\n start = time.time()\\n query_matches = []\\n for i in range(dst.shape[0]):\\n midx = util.mindist(dst[i,:], n=n_matches_per_query)\\n query_matches.append(midx)\\n end = time.time()\\n print(time.asctime(), ' Done Sorting distances in ', end-start, ' seconds', flush=True)\\n return query_matches\",\n \"def rh_get_match(x, y, k, d=7, hash_size=\\\"automatic\\\"):\\n n = len(x)\\n m = len(y)\\n\\n if hash_size == \\\"automatic\\\":\\n q = n * m\\n else:\\n q = hash_size\\n\\n output = list()\\n\\n for i in range(n - k + 1):\\n matches = rabin_karp_matcher(\\n target=y,\\n potential=x[i:i + k],\\n d=d,\\n q=q\\n )\\n\\n for match in matches:\\n output.append((i, match))\\n\\n return output\",\n \"def paired_distance(self, left_ids, right_ids = None, adjusted = False, format = 'pandas'):\\n if right_ids is None:\\n # Default to self-distance\\n right_ids = left_ids\\n\\n # Accept htids as well as mtids by checking the first element.\\n def expand_htids(iset):\\n if not '-' in list(iset)[0]:\\n output = []\\n for id in iset:\\n output.extend(self.htid_lookup[id])\\n output.sort()\\n return output\\n return iset\\n\\n left_ids, right_ids = map(expand_htids, [left_ids, right_ids])\\n \\n left = self.mtid_matrix(left_ids)\\n right = self.mtid_matrix(right_ids)\\n if adjusted:\\n joint = np.concatenate((left, right))\\n mediod = np.median(joint, 0)\\n left = left - mediod\\n right = right - mediod\\n ds = (np.dot(left, right.T))\\n labs = [(ida, idb) for ida in left_ids for idb in right_ids]\\n if format == 'matrix':\\n return (ds, (left_ids, right_ids))\\n return pd.DataFrame([(a, b, c) for ((a, b), c) in (zip(labs, ds.flatten()))], columns = ['left', 'right', 'sim'])\",\n \"def mass_based_dissimilarity(self, x1, x2):\\n # In each i-tree, find lowest nodes containing both x and y\\n # TODO: parallelize\\n sum_masses = 0\\n for itree in self.random_itrees:\\n # Divide each sum by size of subset used to construct the trees.\\n sum_masses += self.get_lowest_common_node_mass(itree, x1, x2)/self.subs_size\\n return (1/len(self.random_itrees)) * sum_masses # Divide by number of space partitioning models.\",\n \"def get_intersecting_dissemination_ids(cross_section, dissemination_areas):\\n assert 'DAUID' in cross_section.columns \\n dissem_arr = dissemination_areas.loc[dissemination_areas['DAUID'].isin(np.unique(cross_section['DAUID'].values))].DAUID.unique()\\n reg_arr = dissemination_areas.loc[dissemination_areas['DAUID'].isin(np.unique(cross_section['DAUID'].values))].CSDUID.unique()\\n# code_arr = dissemination_areas.loc[dissemination_areas['DAUID'].isin(np.unique(cross_section['DAUID'].values))].CODEID.unique()\\n\\n\\n return list(dissem_arr), list(reg_arr)\",\n \"def match_min(coords1,coords2,tail1=(),tail2=()):\\n nc=len(coords1)\\n np1=len(coords1[0])\\n np2=len(coords2[0])\\n a1=array(coords1)\\n a2=array(coords2)\\n nt1=len(tail1)\\n for i in range(nt1): \\n if len(tail1[i])!= np1: raise 'Not the same lenght as coordinates 1'\\n nt2=len(tail2)\\n for i in range(nt2): \\n if len(tail2[i])!= np2: raise 'Not the same lenght as coordinates 2'\\n match=zeros(np1, int)-1\\n\\n dist_min=zeros(np1)*1.\\n\\n for j in range(np1):\\n #dist=sqrt(add.reduce((a1[:,j,NewAxis]-a2[:,:])**2))\\n a1j = a1[:,j]\\n dist=add.reduce((reshape(a1j, (len(a1j), 1)) - a2)**2)\\n i_min=argmin(dist)\\n dist_min[j]=dist[i_min]\\n match[j]=i_min\\n\\n salida=list(a1)\\n for i in range(nt1):salida.append(tail1[i])\\n \\n for i in range(nt2):\\n if type(tail2[i][0])==type('si'):\\n t=[]\\n for j in match: t.append(tail2[i][j])\\n else:\\n t=take(tail2[i],match)\\n salida.append(t)\\n\\n salida.append(dist_min)\\n return tuple(salida)\",\n \"def nn_match(descs1, descs2):\\n # diff = descs1[:, None, :] - descs2[None, :, :]\\n # diff = np.linalg.norm(diff, ord=2, axis=2)\\n # indices = np.argmin(diff, axis=1)\\n\\n flann = cv2.FlannBasedMatcher_create()\\n matches = flann.match(descs1.astype(np.float32), descs2.astype(np.float32))\\n indices = [x.trainIdx for x in matches]\\n\\n return indices\",\n \"def find_num_matches(p1, p2, t1, t2, m1, m2, x, k, len_p, i):\\n start = 0\\n for mismatch in range(k):\\n # print(f'start: {start}, id: {id}')\\n id = start\\n end = len_p-1\\n while start <= end:\\n mid = start + (end-start)//2\\n p_h1, p_h2 = get_hash_value(\\n p1, m1, x, id, mid-start), get_hash_value(p2, m2, x, id, mid-start)\\n s_h1, s_h2 = get_hash_value(\\n t1, m1, x, i+id, mid-start), get_hash_value(t2, m2, x, i+id, mid-start)\\n if p_h1 == s_h1 and p_h2 == s_h2: # move to the right half, no mismatch yet\\n start = mid + 1\\n else:\\n end = mid - 1\\n # when loop exits, start - 1 is the index of the mismatch.\\n if start == len_p: # found the last mismatch\\n return True\\n return False\",\n \"def match_objects(coords1,coords2,tail1=(),tail2=(),accuracy=1.):\\n acc2=accuracy**2\\n nc=len(coords1)\\n np1=len(coords1[0])\\n np2=len(coords2[0])\\n a1=array(coords1)\\n a2=array(coords2)\\n nt1=len(tail1)\\n for i in range(nt1): \\n if len(tail1[i])!= np1: raise 'Not the same lenght as coordinates 1'\\n nt2=len(tail2)\\n for i in range(nt2): \\n if len(tail2[i])!= np2: raise 'Not the same lenght as coordinates 2'\\n match=zeros(np1, int)-1\\n for j in range(np1):\\n #dist=add.reduce((a1[:,j,NewAxis]-a2[:,:])**2)\\n a1j = a1[:,j]\\n dist=add.reduce((reshape(a1j, (len(a1j), 1)) - a2)**2)\\n i_min=argmin(dist)\\n if dist[i_min]<acc2:match[j]=i_min\\n good=greater_equal(match,0)\\n n1=compress(good,list(range(np1))) \\n match=compress(good,match)\\n a1=compress(good,a1)\\n salida=list(a1)\\n for i in range(nt1):\\n if type(tail1[i][0])==type('si'):\\n t=[]\\n for j in n1: t.append(tail1[i][j])\\n else:\\n t=take(tail1[i],n1)\\n salida.append(t)\\n for i in range(nt2):\\n if type(tail2[i][0])==type('si'):\\n t=[]\\n for j in match: t.append(tail2[i][j])\\n else:\\n t=take(tail2[i],match)\\n salida.append(t)\\n return salida\",\n \"def find_mutual_ids(tree_1, tree_2):\\r\\n # Getting lists of all the users:\\r\\n all_users_1 = tree_1.all_users() + [tree_1]\\r\\n all_users_2 = tree_2.all_users() + [tree_2]\\r\\n\\r\\n result_list = []\\r\\n\\r\\n # Changing types of values in lists:\\r\\n all_users_1 = [user.get_id_num() for user in all_users_1]\\r\\n all_users_2 = [user.get_id_num() for user in all_users_2]\\r\\n\\r\\n # Checking:\\r\\n for user in all_users_1:\\r\\n if user in all_users_2:\\r\\n result_list.append(user)\\r\\n\\r\\n return result_list\",\n \"def get_matches(src,dst,src_list, dst_list):\\n matches=[]\\n for src_conn in src_list:\\n print src_conn\\n if (src_conn in dst_list) & (src_conn<>dst):\\n matches.append(src_conn)\\n return matches\",\n \"def match(desc1,desc2):\\n desc1 = array([d/linalg.norm(d) for d in desc1])\\n desc2 = array([d/linalg.norm(d) for d in desc2])\\n dist_ratio = 0.6\\n desc1_size = desc1.shape\\n matchscores = zeros((desc1_size[0],1),'int')\\n desc2t = desc2.T # precompute matrix transpose\\n for i in range(desc1_size[0]):\\n dotprods = dot(desc1[i, :], desc2t) # vector of dot products\\n dotprods *= 0.9999\\n # inverse cosine and sort, return index for features in second image\\n indx = argsort(arccos(dotprods))\\n # check if nearest neighbor has angle less than dist_ratio times 2nd\\n if arccos(dotprods)[indx[0]] < dist_ratio * arccos(dotprods)[indx[1]]:\\n matchscores[i] = int(indx[0])\\n return matchscores\",\n \"def findSubsetIndices(min_lat,max_lat,min_lon,max_lon,lats,lons):\\n res=np.zeros((4),dtype=np.float64)\\n minLon=min_lon; maxLon=max_lon\\n\\n distances1 = []; distances2 = []\\n indices=[]; index=1\\n\\n for point in lats:\\n s1 = max_lat-point # (vector subtract)\\n s2 = min_lat-point # (vector subtract)\\n distances1.append((np.dot(s1, s1), point, index))\\n distances2.append((np.dot(s2, s2), point, index-1))\\n index=index+1\\n\\n distances1.sort()\\n distances2.sort()\\n indices.append(distances1[0])\\n indices.append(distances2[0])\\n\\n distances1 = []; distances2 = []; index=1\\n\\n for point in lons:\\n s1 = maxLon-point # (vector subtract)\\n s2 = minLon-point # (vector subtract)\\n distances1.append((np.dot(s1, s1), point, index))\\n distances2.append((np.dot(s2, s2), point, index-1))\\n index=index+1\\n\\n distances1.sort()\\n distances2.sort()\\n indices.append(distances1[0])\\n indices.append(distances2[0])\\n\\n # Save final product: max_lat_indices,min_lat_indices,max_lon_indices,min_lon_indices\\n minJ=indices[1][2]\\n maxJ=indices[0][2]\\n minI=indices[3][2]\\n maxI=indices[2][2]\\n\\n res[0]=minI; res[1]=maxI; res[2]=minJ; res[3]=maxJ\\n return res\",\n \"def match(cat1, cat2, xs, ys, mmax):\\n\\n nmatch = 0\\n x1s, y1s = cat1[:,0], cat1[:,1]\\n ind1 = np.arange(len(cat1))\\n ind2 = np.empty(len(cat2),dtype=int)\\n ind2.fill(-1)\\n for i2, p2 in enumerate(cat2):\\n x2, y2 = p2\\n ok = (x1s > x2-xs-mmax) & (x1s < x2-xs+mmax) & \\\\\\n (y1s > y2-ys-mmax) & (y1s < y2-ys+mmax)\\n if len(x1s[ok]) == 1:\\n nmatch += 1\\n ind2[i2] = ind1[ok][0]\\n\\n return (nmatch, ind2)\",\n \"def create_match_instance_pairs(plant_match_in):\\r\\n\\t## collect all plant name match instances indices\\r\\n\\tjust_indices = [int(indices) for plant_match_in_set in plant_match_in for indices in plant_match_in_set[1]]\\r\\n\\t\\r\\n\\tassert len(just_indices) == len(set(just_indices)) # check there are no exact duplicates in indices\\r\\n\\r\\n\\tsorted_index = list(sorted(just_indices)) # sort indices small-large\\r\\n\\tprint(f'Length of corpus bigrams BEFORE ambiguous matches removed: {len(sorted_index)}')\\r\\n\\t#print(sorted_index)\\r\\n\\r\\n\\t# remove all ambiguous matches that are within 1 word of each other\\r\\n\\tprint('Ambiguous plant name matches: ')\\r\\n\\tfor i, index in enumerate(sorted_index): # iterate over all indices in sorted list\\r\\n\\t\\t\\r\\n\\t\\tif index == sorted_index[i-1]+1: # indices is within 1 of previous indices in list\\r\\n\\t\\t\\tprint(index, sorted_index[i-1])\\r\\n\\t\\t\\tsorted_index.remove(index) # remove indices from list\\r\\n\\t\\t\\tsorted_index.remove(sorted_index[i-1]) # AND remove previous indices from list\\r\\n\\tprint(f'Length of corpus bigrams AFTER ambiguous matches removed: {len(sorted_index)}')\\r\\n\\r\\n\\t# create indices dict with 'B', 'I' values\\r\\n\\tpaired_finds = {}\\r\\n\\tfor match_index in sorted_index: # iterate over unambiguous match indices list\\r\\n\\t\\t\\t\\t\\t\\r\\n\\t\\t\\tpaired_finds[match_index] = ('B') # WITH value of 'B'\\r\\n\\t\\t\\t\\r\\n\\t\\t\\tpaired_finds[match_index+1] = ('I') # WITH value of 'I'\\r\\n\\r\\n\\treturn paired_finds\",\n \"def match_min2(coords1,coords2,tail1=(),tail2=()):\\n nc=len(coords1)\\n np1=len(coords1[0])\\n np2=len(coords2[0])\\n a1=array(coords1)\\n a2=array(coords2)\\n nt1=len(tail1)\\n for i in range(nt1): \\n if len(tail1[i])!= np1: raise 'Not the same lenght as coordinates 1'\\n nt2=len(tail2)\\n for i in range(nt2): \\n if len(tail2[i])!= np2: raise 'Not the same lenght as coordinates 2'\\n match=zeros(np1, int)-1\\n dist_min=zeros(np1)*1.\\n x2=zeros(np1)*1.\\n y2=zeros(np1)*1.\\n for j in range(np1):\\n #dist=add.reduce((a1[:,j,NewAxis]-a2[:,:])**2)\\n a1j = a1[:,j]\\n dist=add.reduce((reshape(a1j, (len(a1j), 1)) - a2)**2)\\n i_min=argmin(dist)\\n dist_min[j]=dist[i_min]\\n x2[j],y2[j]=a2[0,i_min],a2[1,i_min]\\n match[j]=i_min\\n \\n salida=list(a1)\\n salida.append(x2)\\n salida.append(y2)\\n\\n for i in range(nt1):salida.append(tail1[i])\\n \\n for i in range(nt2):\\n if type(tail2[i][0])==type('si'):\\n t=[]\\n for j in match: t.append(tail2[i][j])\\n else:\\n t=take(tail2[i],match)\\n salida.append(t)\\n\\n salida.append(dist_min)\\n return tuple(salida)\",\n \"def test_if_nodes_are_in_same_chunk(self, node_ids: Sequence[np.uint64]\\n ) -> bool:\\n assert len(node_ids) == 2\\n return self.get_chunk_id(node_id=node_ids[0]) == \\\\\\n self.get_chunk_id(node_id=node_ids[1])\",\n \"def find_nearby_membranes(all_membranes, all_membrane_map, vert_normals):\\r\\n membrane_tree = scipy.spatial.cKDTree(all_membranes)\\r\\n nearby_membranes = np.array(list(membrane_tree.query_pairs(adhesion_max_dist, p=2)))\\r\\n nearby_membrane_map = defaultdict(list)\\r\\n if nearby_membranes.shape[0] > 0:\\r\\n # Exclude same-cell membrane interactions and same-direction-facing segments\\r\\n all_vert_normals = np.concatenate(vert_normals, axis=0)\\r\\n subset = np.where(\\r\\n (all_membrane_map[nearby_membranes[:, 0], 0] !=\\r\\n all_membrane_map[nearby_membranes[:, 1], 0])\\r\\n & (np.einsum('ij,ik->i', all_vert_normals[nearby_membranes[:, 0]], all_vert_normals[nearby_membranes[:, 1]]) < 0.0)\\r\\n )\\r\\n nearby_membranes = nearby_membranes[subset]\\r\\n # {cell idx: (vert idx, other cell idx, other vert idx, 'all_membranes' vert idx)}\\r\\n for nm in nearby_membranes:\\r\\n m0 = all_membrane_map[nm[0]]\\r\\n m1 = all_membrane_map[nm[1]]\\r\\n nearby_membrane_map[m0[0]].append((m0[1], m1[0], m1[1], nm[1]))\\r\\n nearby_membrane_map[m1[0]].append((m1[1], m0[0], m0[1], nm[0]))\\r\\n nearby_membrane_map = {k: np.array(v)\\r\\n for k, v in nearby_membrane_map.items()}\\r\\n# print(nearby_membrane_map)\\r\\n return nearby_membranes, nearby_membrane_map\",\n \"def test_several_paths(id1, id2, expected_path_ids):\\n syn1 = germanet_data.get_synset_by_id(id1)\\n syn2 = germanet_data.get_synset_by_id(id2)\\n paths = syn1.shortest_path(syn2)\\n assert len(paths) == len(expected_path_ids), \\\"the number of found paths doesn't macht the true number of paths\\\"\\n for path in paths:\\n path = [synset.id for synset in path]\\n np.testing.assert_equal(path in expected_path_ids, True)\",\n \"def find_mate_pairs(strandseq_files, unique_id_length):\\n pairs = []\\n run_ids = set()\\n for pos in range(0, len(strandseq_files), 2):\\n first_mate = strandseq_files[pos]\\n second_mate = strandseq_files[pos+1]\\n sm = difflib.SequenceMatcher(a=first_mate, b=second_mate)\\n mobj = sm.find_longest_match(0, len(first_mate), 0, len(second_mate))\\n match_size = mobj.size\\n common_substring = first_mate[mobj.a : mobj.a+mobj.size]\\n try:\\n next_mate = strandseq_files[pos+2]\\n sm.set_seq1(next_mate)\\n mobj = sm.find_longest_match(0, len(next_mate), 0, len(second_mate))\\n if match_size <= mobj.size:\\n raise ValueError('Cannot pair mates based on lexicographical order: '\\n '{} / {} vs {}'.format(first_mate, second_mate, next_mate))\\n except IndexError:\\n pass\\n uniq_runid = hashlib.md5(common_substring.encode('utf-8')).hexdigest()[:unique_id_length]\\n if uniq_runid in run_ids:\\n raise ValueError('Created run ID is not unique: {} / {}'.format(uniq_runid, common_substring))\\n run_ids.add(uniq_runid)\\n pairs.append((first_mate, second_mate, common_substring, uniq_runid))\\n return sorted(pairs, key=lambda x: x[2])\",\n \"def _find_common(self, lineset1, lineset2):\\n lines1 = lineset1.enumerate_stripped\\n lines2 = lineset2.enumerate_stripped\\n find = lineset2.find\\n index1 = 0\\n min_lines = self.min_lines\\n while index1 < len(lineset1):\\n skip = 1\\n num = 0\\n for index2 in find(lineset1[index1]):\\n non_blank = 0\\n for num, ((_, line1), (_, line2)) in enumerate(\\n zip(lines1(index1), lines2(index2))\\n ):\\n if line1 != line2:\\n if non_blank > min_lines:\\n yield num, lineset1, index1, lineset2, index2\\n skip = max(skip, num)\\n break\\n if line1:\\n non_blank += 1\\n else:\\n # we may have reach the end\\n num += 1\\n if non_blank > min_lines:\\n yield num, lineset1, index1, lineset2, index2\\n skip = max(skip, num)\\n index1 += skip\",\n \"def return_matches(hashes):\\n # Create a dictionary of hash => offset pairs for later lookups\\n mapper = {}\\n for hash, offset in hashes:\\n mapper[hash.upper()] = offset\\n\\n # Get an iteratable of all the hashes we need\\n values = mapper.keys()\\n\\n conn = MySQLdb.connect(**connection_string[\\\"Common\\\"])\\n cur = conn.cursor()\\n\\n for split_values in grouper(values, 1000):\\n # Create our IN part of the query\\n query = SELECT_MULTIPLE\\n query %= ', '.join(['UNHEX(%s)'] * len(split_values))\\n\\n cur.execute(query, split_values)\\n\\n for hash, sid, offset in cur:\\n # (sid, db_offset - song_sampled_offset)\\n yield (sid, offset - mapper[hash])\",\n \"def match(desc1,desc2):\\n\\t\\n\\tdesc1 = array([d/linalg.norm(d) for d in desc1])\\n\\tdesc2 = array([d/linalg.norm(d) for d in desc2])\\n\\t\\n\\tdist_ratio = 0.6\\n\\tdesc1_size = desc1.shape\\n\\t\\n\\tmatchscores = zeros((desc1_size[0],1))\\n\\tdesc2t = desc2.T #precompute matrix transpose\\n\\tfor i in range(desc1_size[0]):\\n\\t\\tdotprods = dot(desc1[i,:],desc2t) #vector of dot products\\n\\t\\tdotprods = 0.9999*dotprods\\n\\t\\t#inverse cosine and sort, return index for features in second image\\n\\t\\tindx = argsort(arccos(dotprods))\\n\\t\\t\\n\\t\\t#check if nearest neighbor has angle less than dist_ratio times 2nd\\n#\\t\\tif arccos(dotprods)[indx[0]] < dist_ratio * arccos(dotprods)[indx[1]]:\\n\\t\\tmatchscores[i] = int(indx[0])\\n\\t\\n\\treturn matchscores\",\n \"def match_twosided(desc1, desc2):\\n\\n matches_12 = match(desc1, desc2)\\n matches_21 = match(desc2, desc1)\\n\\n ndx_12 = matches_12.non_zeros()[0]\\n\\n for n in ndx_12:\\n if matches_21[int(matches_12[n])] != n:\\n matches_12[n] = 0\\n\\n return matches_12\",\n \"def paired_dists(self, other, match_com=True):\\n assert self.ndim == other.ndim\\n if match_com:\\n dists1 = (self.rs[..., np.newaxis] - self.rs.T[np.newaxis, ...])\\n dists2 = (other.rs[..., np.newaxis] - other.rs.T[np.newaxis, ...])\\n rij_minus_sij = np.rollaxis(dists1 - dists2, -1, -2)\\n rij_minus_sij = ((rij_minus_sij + 1/2.) % 1) - 1/2.\\n dist_sqs = np.triu(np.sum(rij_minus_sij**2, axis=-1))\\n return np.sqrt(np.sum(dist_sqs) * self.L * other.L / len(self.rs))\\n else:\\n diffs = self.rs - other.rs\\n diffs = ((diffs + 1/2.) % 1) - 1/2.\\n return np.sqrt(np.sum(diffs**2) * self.L * other.L)\",\n \"def findsegments(id1, seq1, id2, seq2, minlen):\\n\\n segments = \\\"\\\"\\n\\n # Initialize list of corresponding residues.\\n correspondances = []\\n for res in seq1:\\n correspondances.append([])\\n \\n # Main loop.\\n for i in range(len(seq1)-minlen):\\n seg1 = seq1[i:i+minlen]\\n for j in range(len(seq2)-minlen):\\n if j not in correspondances[i]:\\n seg2 = seq2[j:j+minlen]\\n if seg1 == seg2:\\n # Look if the segment is longer than minlen.\\n segments_equal = True\\n prev1 = seg1\\n prev2 = seg2\\n extend = 1\\n while segments_equal == True:\\n i_end = i+minlen+extend\\n j_end = j+minlen+extend\\n ext1 = seq1[i:i_end]\\n ext2 = seq2[j:j_end]\\n if i_end > len(seq1) or j_end > len(seq2):\\n seqend = True\\n else:\\n seqend = False\\n if ext1 != ext2 or seqend == True:\\n segments_equal = False\\n segments += \\\"{} \\\".format(prev1)\\n segments += \\\"{} [{}, {}] \\\".format(id1, i, i_end-2)\\n segments += \\\" \\\"\\n segments += \\\"{} [{}, {}] \\\".format(id2, j, j_end-2)\\n segments += \\\"\\\\n\\\"\\n # Add residues to correspondance list.\\n for k in range(minlen+extend-1):\\n l = i+k\\n m = j+k\\n correspondances[l].append(m)\\n prev1 = ext1\\n prev2 = ext2\\n extend += 1\\n\\n return segments\",\n \"def mapsMatch(m1,m2):\\n same = True\\n f1 = file(m1,'r').readlines()\\n f2 = file(m2,'r').readlines()\\n for i, row in enumerate(f1):\\n row = row.strip().split()\\n row2 = f2[i].strip().split()\\n if row[0] <> row2[0]:\\n\\t same = False\\n break\\n return same\",\n \"def test_return_series_matching_idlist_mols(cls):\\n\\n cls.test_mmp_series_object.setup_mmp_data_for_mms(cls.temp_file_input_csv_confusion.name,\\n 'SMILES', 'ID', 'PIC50',\\n 3, 0.50001)\\n\\n cls.test_mmp_series_object.generate_store_mmp_series()\\n\\n result_ = cls.test_mmp_series_object.return_series_matching_idlist([2, 3, 4], 'MOL_ID')\\n\\n #print(result_.to_dict())\\n cls.assertDictEqual({'SERIES_ID': {0: 1, 1: 1, 2: 1, 3: 1, 4: 1, 5: 2, 6: 2, 7: 2, 8: 2, 9: 2},\\n 'SERIES_SEQ_ID': {0: 1, 1: 2, 2: 3, 3: 4, 4: 5, 5: 1, 6: 2, 7: 3, 8: 4, 9: 5},\\n 'CONTEXT_ID': {0: 8, 1: 8, 2: 8, 3: 8, 4: 8, 5: 29, 6: 29, 7: 29, 8: 29, 9: 29},\\n 'FRAG_ID': {0: 7, 1: 44, 2: 69, 3: 91, 4: 285, 5: 24, 6: 34, 7: 60, 8: 82, 9: 286},\\n 'MOL_ID': {0: 1, 1: 2, 2: 3, 3: 4, 4: 5, 5: 1, 6: 2, 7: 3, 8: 4, 9: 5},\\n 'ACTIVITY': {0: 7.0, 1: 7.68, 2: 8.51, 3: 8.77, 4: 8.99, 5: 7.0, 6: 7.68, 7: 8.51, 8: 8.77,\\n 9: 8.99}},\\n result_.to_dict())\",\n \"def spherematch(ra1, dec1, ra2, dec2, tol=None, nnearest=1, threads=1):\\n \\n #convert arguments into arrays for ease of use\\n ra1 = np.array(ra1, copy=False)\\n dec1 = np.array(dec1, copy=False)\\n ra2 = np.array(ra2, copy=False)\\n dec2 = np.array(dec2, copy=False)\\n\\n #check to see if arguments are consistent\\n if ra1.shape != dec1.shape:\\n raise ValueError('ra1 and dec1 do not match!')\\n if ra2.shape != dec2.shape:\\n raise ValueError('ra2 and dec2 do not match!') \\n\\n #convert spherical coordinates into cartesian coordinates\\n x1, y1, z1 = _spherical_to_cartesian_fast(ra1.ravel(), dec1.ravel(), threads) \\n\\n # this is equivalent to, but faster than just doing np.array([x1, y1, z1])\\n coords1 = np.empty((x1.size, 3))\\n coords1[:, 0] = x1\\n coords1[:, 1] = y1\\n coords1[:, 2] = z1 \\n\\n #convert spherical coordinates into cartesian coordinates\\n x2, y2, z2 = _spherical_to_cartesian_fast(ra2.ravel(), dec2.ravel(), threads)\\n\\n # this is equivalent to, but faster than just doing np.array([x1, y1, z1])\\n coords2 = np.empty((x2.size, 3))\\n coords2[:, 0] = x2\\n coords2[:, 1] = y2\\n coords2[:, 2] = z2\\n \\n #create tree structure\\n kdt = KDT(coords2)\\n #find neighbors\\n if nnearest == 1:\\n idxs2 = kdt.query(coords1)[1]\\n elif nnearest == 0 and (tol is not None): #if you want all matches\\n p1x, p1y, p1z = _spherical_to_cartesian_fast(90, 0, threads)\\n p2x, p2y, p2z = _spherical_to_cartesian_fast(90, tol, threads)\\n p1x = float(p1x)\\n p2x = float(p2x)\\n p1y = float(p1y)\\n p2y = float(p2y)\\n p1z = float(p1z)\\n p2z = float(p2z)\\n r = np.sqrt((p2x-p1x)**2+(p2y-p1y)**2+(p2z-p1z)**2) #cartesian tol\\n idxs2 = kdt.query_ball_point(coords1, r)[0]\\n elif nnearest > 1:\\n idxs2 = kdt.query(coords1, nnearest)[1][:, -1]\\n else:\\n raise ValueError('invalid nnearest ' + str(nnearest))\\n \\n #calculate distances between matches\\n ds = _great_circle_distance_fast(ra1, dec1, ra2[idxs2], dec2[idxs2], threads) \\n\\n #if tolerance is None, then all objects will have a match\\n idxs1 = np.arange(ra1.size)\\n \\n #remove matches that are beyond the tolerance seperation\\n if (tol is not None) and nnearest != 0:\\n msk = ds < tol\\n idxs1 = idxs1[msk]\\n idxs2 = idxs2[msk]\\n ds = ds[msk]\\n\\n \\n return idxs1, idxs2, ds\",\n \"def get_pairs_to_compare(id_token_pairs):\\n token_sku_id_pairs = dict()\\n for sku_id, tokens in id_token_pairs.items():\\n for token in tokens:\\n token_sku_id_pairs[token] = token_sku_id_pairs.get(token, []) + [sku_id]\\n\\n pairs_to_compare = set()\\n for token, sku_ids in token_sku_id_pairs.items():\\n id_combinations = combinations(sku_ids, 2)\\n for (id1, id2) in id_combinations:\\n if (id2, id1) not in pairs_to_compare:\\n pairs_to_compare.add((id1, id2))\\n\\n return pairs_to_compare\",\n \"def _calculate_leading_dim_map():\\n small_matrixes = [(value, value+64) for value in range(256, 40192+512, 512)]\\n large_matrixes = [(value, value+1088) for value in range(1024, 39936+1024, 1024)]\\n return dict(small_matrixes + large_matrixes)\",\n \"def match_features(desc1, desc2, min_score):\\n\\n ## Reshape D1,2 to (N1, k^2), (k^2, N2)\\n\\n D1 = desc1.reshape((desc1.shape[0], -1))\\n D2 = desc2.reshape((desc2.shape[0], -1)).T\\n\\n ## Calc M = D1 * D2, shape (N1, N2)\\n ## Mi,j = match score of pt i from I1 and pt 2 from I2.\\n\\n M = D1.dot(D2)\\n\\n ## Get candidates list I1 and I2, shape (2, N2), (\\n ## total_cand = 4-j cands of the 2-i cands in index i\\n\\n cols_cand = np.argpartition(M, -2, axis=0)[-2:]\\n rows_cand = np.argpartition(M.T, -2, axis=0)[-2:]\\n total_cand = rows_cand[:, cols_cand]\\n\\n ## Mark matches where i appear in the ith col\\n ## concat matches.\\n\\n index_map = np.ones(cols_cand.shape, dtype=np.int) * np.arange(cols_cand.shape[-1])\\n match = (total_cand == index_map)\\n\\n desc1_match = np.concatenate((cols_cand[match[0]],\\n cols_cand[match[1]]))\\n desc2_match = np.concatenate((index_map[match[0]],\\n index_map[match[1]]))\\n\\n ## Discard matches below min_score\\n\\n satisfty_min = np.where(M[desc1_match, desc2_match] >= min_score)\\n desc1_match = desc1_match[satisfty_min]\\n desc2_match = desc2_match[satisfty_min]\\n\\n ## Remove duplicate matches, keep max score pair.\\n\\n order = np.argsort(M[desc1_match, desc2_match])[::-1]\\n desc1_match = desc1_match[order]\\n desc2_match = desc2_match[order]\\n\\n unqe = np.unique(desc1_match, return_index=True)[1]\\n desc1_match = desc1_match[unqe]\\n desc2_match = desc2_match[unqe]\\n\\n return [desc1_match, desc2_match]\",\n \"def associate(first_list, second_list, offset, max_difference):\\n ## obatin all keys\\n first_keys = list(first_list)\\n second_keys = list(second_list)\\n potential_matches = [(abs(a - (b + offset)), a, b)\\n for a in first_keys\\n for b in second_keys\\n if abs(a - (b + offset)) < max_difference]\\n potential_matches.sort()\\n matches = []\\n for diff, a, b in potential_matches:\\n if a in first_keys and b in second_keys:\\n first_keys.remove(a)\\n second_keys.remove(b)\\n matches.append((a, b))\\n \\n matches.sort()\\n return matches\",\n \"def indmatch(ra1, dec1, ra2, dec2, tol):\\n m = match(ra1, dec1, ra2, dec2, tol)\\n c = m.ind > -1\\n i1 = c.nonzero()[0]\\n i2 = m.ind[c]\\n return i1, i2\",\n \"def test_connected_ids_remote_minions():\\n opts = {\\n \\\"publish_port\\\": 4505,\\n \\\"detect_remote_minions\\\": True,\\n \\\"remote_minions_port\\\": 22,\\n \\\"minion_data_cache\\\": True,\\n }\\n minion = \\\"minion\\\"\\n minion2 = \\\"minion2\\\"\\n minion2_ip = \\\"192.168.2.10\\\"\\n minion_ips = {\\\"203.0.113.1\\\", \\\"203.0.113.2\\\", \\\"127.0.0.1\\\"}\\n mdata = {\\\"grains\\\": {\\\"ipv4\\\": minion_ips, \\\"ipv6\\\": []}}\\n mdata2 = {\\\"grains\\\": {\\\"ipv4\\\": [minion2_ip], \\\"ipv6\\\": []}}\\n patch_net = patch(\\\"salt.utils.network.local_port_tcp\\\", return_value=minion_ips)\\n patch_remote_net = patch(\\n \\\"salt.utils.network.remote_port_tcp\\\", return_value={minion2_ip}\\n )\\n patch_list = patch(\\\"salt.cache.Cache.list\\\", return_value=[minion, minion2])\\n patch_fetch = patch(\\\"salt.cache.Cache.fetch\\\", side_effect=[mdata, mdata2])\\n ckminions = salt.utils.minions.CkMinions(opts)\\n with patch_net, patch_list, patch_fetch, patch_remote_net:\\n ret = ckminions.connected_ids()\\n assert ret == {minion2, minion}\",\n \"def greedy_match(cost_matrix):\\n num_detections, num_tracks = cost_matrix.shape\\n distance_1d = cost_matrix.reshape(-1)\\n index_1d = np.argsort(distance_1d)\\n index_2d = np.stack([index_1d // num_tracks, index_1d % num_tracks], axis=1).astype(int, copy=False)\\n\\n matched_indices = []\\n matched_firsts = set()\\n matched_seconds = set()\\n\\n for (first_id, second_id) in index_2d:\\n if first_id not in matched_firsts and second_id not in matched_seconds:\\n matched_seconds.add(second_id)\\n matched_firsts.add(first_id)\\n matched_indices.append([first_id, second_id])\\n return np.array(matched_indices)\",\n \"def correspondences(labels1,labels2,return_counts=True):\\n q = 100000\\n assert amin(labels1)>=0 and amin(labels2)>=0\\n assert amax(labels2)<q\\n combo = labels1*q+labels2\\n result = unique(combo, return_counts=return_counts)\\n if return_counts:\\n result, counts = result\\n result = array([result//q,result%q,counts])\\n else:\\n result = array([result//q,result%q])\\n return result\",\n \"def min_cost_matching(\\n distance_metric, max_distance, tracks, detections, track_indices=None,\\n detection_indices=None):\\n if track_indices is None:\\n track_indices = np.arange(len(tracks))\\n if detection_indices is None:\\n detection_indices = np.arange(len(detections))\\n\\n if len(detection_indices) == 0 or len(track_indices) == 0:\\n return [], track_indices, detection_indices # Nothing to match.\\n\\n cost_matrix = distance_metric(\\n tracks, detections, track_indices, detection_indices)\\n cost_matrix[cost_matrix > max_distance] = max_distance + 1e-5\\n indices = linear_sum_assignment(cost_matrix)\\n indices = np.asarray(indices)\\n indices = np.transpose(indices)\\n\\n matches, unmatched_tracks, unmatched_detections = [], [], []\\n for col, detection_idx in enumerate(detection_indices):\\n if col not in indices[:, 1]:\\n unmatched_detections.append(detection_idx)\\n for row, track_idx in enumerate(track_indices):\\n if row not in indices[:, 0]:\\n unmatched_tracks.append(track_idx)\\n for row, col in indices:\\n track_idx = track_indices[row]\\n detection_idx = detection_indices[col]\\n if cost_matrix[row, col] > max_distance:\\n unmatched_tracks.append(track_idx)\\n unmatched_detections.append(detection_idx)\\n else:\\n matches.append((track_idx, detection_idx))\\n return matches, unmatched_tracks, unmatched_detections\",\n \"def match_coords(list1, list2, tol = 1.5):\\n tol1, tol2 = tol/3600.0, (tol/3600.0)**2\\n jmin, match_idx, best_dr2 = 0, [None]*len(list1), [tol2]*len(list1)\\n # This next bit is rather tricky because we have to sort the lists,\\n # but also remember where we put each item. Here i, j = sorted indices,\\n # while ci[i], ci[j] = corresponding actual indices in original lists.\\n ci = np.array([c.ra for c in list1]).argsort()\\n cj = np.array([c.ra for c in list2]).argsort()\\n for i in range(len(list1)):\\n CD = np.cos(list1[ci[i]].dec*np.pi/180.0)\\n ramin, ramax = list1[ci[i]].ra - tol1/CD, list1[ci[i]].ra + tol1/CD\\n decmin, decmax = list1[ci[i]].dec - tol1, list1[ci[i]].dec + tol1\\n # Inch along in list2 until we find the part that matches list1 in RA\\n while jmin < len(list2) and list2[cj[jmin]].ra < ramin: jmin += 1\\n if jmin == len(list2): break\\n # Now go through all the RA matches and check the RA+DEC distance.\\n j = jmin\\n while j < len(list2) and list2[cj[j]].ra < ramax:\\n dr2 = ((CD*(list1[ci[i]].ra-list2[cj[j]].ra))**2 +\\n (list1[ci[i]].dec-list2[cj[j]].dec)**2)\\n if dr2 < best_dr2[ci[i]]:\\n match_idx[ci[i]], best_dr2[ci[i]] = cj[j], dr2\\n j += 1\\n # Save and return the index in list2 of the best-matched object to each\\n # item in list1, and the distances between corresponding best matches.\\n best_dr = [np.sqrt(dr2)*3600 for dr2 in best_dr2]\\n return match_idx, best_dr\",\n \"def _match_identical_nodes(self):\\n\\n for job_name_b in self._topo_b_nodes:\\n for job_name_a in self._unresolved_a_nodes:\\n if self._is_node_identical(job_name_a, job_name_b):\\n self._identical_nodes[job_name_b] = job_name_a\\n self._unresolved_a_nodes.remove(job_name_a)\\n self._unresolved_b_nodes.remove(job_name_b)\\n break\",\n \"def pair_address(streetsweeping, streetvolume):\\r\\n addresses = pd.read_sql_query('Select * from address_data', conn)\\r\\n streetsweeping['corridor'] = streetsweeping['corridor'].apply(lambda x: x.upper())\\r\\n addresses['blocknum'] = addresses['number'].apply(lambda x: math.floor(int(x) / 100))\\r\\n streetsweeping['blocknum'] = streetsweeping['lf_fadd'].apply(lambda x: math.floor(int(x) / 100))\\r\\n streetsweeping = streetsweeping[['corridor', 'blocknum', 'lineid']]\\r\\n addresses = addresses.merge(streetsweeping, how = 'left', left_on = ['street', 'blocknum'], right_on = ['corridor', 'blocknum'])\\r\\n addresses.drop_duplicates(subset = ['address'], inplace = True)\\r\\n\\r\\n\\r\\n unfound = addresses[pd.isnull(addresses.lineid)]\\r\\n unfound.dropna(subset = ['lat', 'lon' ], inplace = True)\\r\\n addresses.dropna(subset = ['lineid'], inplace = True)\\r\\n addresses.drop(columns = ['blocknum', 'index', 'corridor'], inplace = True)\\r\\n\\r\\n geometry = [Point(xy) for xy in zip(unfound.lon, unfound.lat)]\\r\\n crs = {'init': 'epsg:4326'}\\r\\n gdf = gpd.GeoDataFrame(unfound, crs=crs, geometry=geometry)\\r\\n addresses = addresses[['lon', 'lat', 'number', 'street', 'address', 'streetname', 'nhood', 'lineid']]\\r\\n tqdm.pandas()\\r\\n dfstreets = streetvolume.copy()\\r\\n print(\\\"searching for unmatched addresses\\\")\\r\\n gdf['lineid'] = gdf.progress_apply(lambda x: find_closest_point(x['geometry'], x['street'], dfstreets), axis = 1)\\r\\n addresses = addresses.append(gdf)\\r\\n addresses = addresses[['address', 'lat', 'lon', 'lineid', 'nhood', 'number', 'street', 'streetname']]\\r\\n addresses.to_sql('address_data', conn, if_exists = 'replace')\\r\\n return\",\n \"def match2Lists(list1,list2):\\r\\n TopMatch = []\\r\\n TopScore = []\\r\\n TopRowIdx = []\\r\\n for member in list1:\\r\\n x=process.extractOne(member, list2)\\r\\n TopMatch.append(x[0])\\r\\n TopScore.append(x[1])\\r\\n TopRowIdx.append(x[2])\\r\\n return TopMatch, TopScore, TopRowIdx\",\n \"def get_pairwise_matches(pos1, descs1, pos2, descs2, up_to=30):\\n assert pos1.shape[0] * pos2.shape[0] < 1e8, \\\\\\n \\\"Too many points: increase cornerness threshold\\\"\\n assert pos1.shape[0] > 10 and pos1.shape[0] > 10, \\\\\\n \\\"Not enough points: lower cornerness threshold\\\"\\n # get the similarities between all descriptors\\n sims = np.dot(descs1, descs2.T)\\n # get the best matches\\n mi2 = sims.argmax(axis=1).squeeze()\\n ms = sims.max(axis=1).squeeze()\\n bmi1 = ms.argsort()[::-1][:up_to]\\n bmi2 = mi2[bmi1]\\n # return their positions\\n bp1 = pos1[bmi1]\\n bp2 = pos2[bmi2]\\n return bp1, bp2\",\n \"def test_return_series_matching_idlist_frags(cls):\\n\\n cls.test_mmp_series_object.setup_mmp_data_for_mms(cls.temp_file_input_csv_confusion.name,\\n 'SMILES', 'ID', 'PIC50',\\n 3, 0.50001)\\n\\n cls.test_mmp_series_object.generate_store_mmp_series()\\n\\n result_ = cls.test_mmp_series_object.return_series_matching_idlist([24, 34, 60],\\n 'FRAG_ID')\\n #print(result_.to_dict())\\n cls.assertDictEqual(\\n {'SERIES_ID': {5: 2, 6: 2, 7: 2, 8: 2, 9: 2, 14: 4, 15: 4, 16: 4, 17: 4, 23: 6, 24: 6, 25: 6, 26: 6, 27: 6},\\n 'SERIES_SEQ_ID': {5: 1, 6: 2, 7: 3, 8: 4, 9: 5, 14: 1, 15: 2, 16: 3, 17: 4, 23: 1, 24: 1, 25: 2, 26: 3,\\n 27: 4},\\n 'CONTEXT_ID': {5: 29, 6: 29, 7: 29, 8: 29, 9: 29, 14: 122, 15: 122, 16: 122, 17: 122, 23: 208, 24: 208,\\n 25: 208, 26: 208, 27: 208},\\n 'FRAG_ID': {5: 24, 6: 34, 7: 60, 8: 82, 9: 286, 14: 60, 15: 34, 16: 24, 17: 82, 23: 24, 24: 9, 25: 34,\\n 26: 60, 27: 82},\\n 'MOL_ID': {5: 1, 6: 2, 7: 3, 8: 4, 9: 5, 14: 12, 15: 11, 16: 10, 17: 13, 23: 30002100, 24: 300021,\\n 25: 298356, 26: 29835601, 27: 29835602},\\n 'ACTIVITY': {5: 7.0, 6: 7.68, 7: 8.51, 8: 8.77, 9: 8.99, 14: 7.77, 15: 8.0, 16: 8.3, 17: 8.89, 23: 6.5,\\n 24: 6.5, 25: 6.9, 26: 7.3, 27: 7.91}},\\n result_.to_dict())\",\n \"def generate_mobility_queries_pair(similar=False):\\n q1 = generate_random_mobility_query()\\n if similar:\\n q2 = generate_similar_mobility_query(q1)\\n else:\\n q2 = generate_not_similar_mobility_query(q1)\\n\\n return q1, q2\",\n \"def match_cluster_sets(cs1, cs2):\\n\\n matr = [[len(cl1.bibs & cl2.bibs) for cl2 in cs2.clusters] for cl1 in cs1.clusters]\\n mapping = maximized_mapping(matr)\\n return dict((cs1.clusters[mappy[0]], cs2.clusters[mappy[1]]) for mappy in mapping)\",\n \"def _compute_set_distances(nonzeros_1, nonzeros_2):\\n distances = np.zeros(len(nonzeros_1))\\n for i, _ in enumerate(distances):\\n distances[i] = np.min(\\n _norm_along_last_axis(nonzeros_1[i].reshape(1, -1) - nonzeros_2)\\n )\\n return distances\",\n \"def mwpm_ids(edges):\\n # extract and sort node ids\\n node_ids = sorted(set(id for (id_a, id_b, _) in edges for id in (id_a, id_b)))\\n # count n_nodes\\n n_nodes = len(node_ids)\\n # check node ids form contiguous set of non-negative integers starting at zero\\n assert n_nodes == 0 or (node_ids[0] == 0 and node_ids[-1] == n_nodes - 1), (\\n 'Node ids are not a contiguous set of non-negative integers starting at zero.')\\n # count n_edges\\n n_edges = len(edges)\\n # unzip edges\\n nodes_a, nodes_b, weights = zip(*edges) if n_edges else ([], [], [])\\n # prepare array types\\n mates_array_type = ctypes.c_int * n_nodes\\n edges_array_type = ctypes.c_int * n_edges\\n # prepare empty mates\\n mates_array = mates_array_type()\\n # call C interface\\n _libpypm().mwpm(ctypes.c_int(n_nodes), mates_array, ctypes.c_int(n_edges),\\n edges_array_type(*nodes_a), edges_array_type(*nodes_b), edges_array_type(*weights))\\n # structure of mates: mates_array[i] = j means ith node matches jth node\\n # convert to more useful format: e.g. convert [1, 0, 3, 2] to {(0, 1), (2, 3)}\\n mates = {tuple(sorted((a, b))) for a, b in enumerate(mates_array)}\\n return mates\",\n \"def all_match():\\n S1=Spectrum.Spectrum()\\n S1.add_peak(50.7,234)\\n S1.add_peak(54.6,585)\\n S1.add_peak(60.7,773)\\n S1.add_peak(65.6,387)\\n S1.add_peak(87.7,546)\\n S1.add_peak(104.6,598)\\n S1.pep_mass=100\\n S1.euclidean_scale()\\n\\n S2=Spectrum.Spectrum()\\n S2.add_peak(50.5,234/2)\\n S2.add_peak(54.8,585/2)\\n S2.add_peak(61.0,773/2)\\n S2.add_peak(65.4,387/2)\\n S2.add_peak(88.0,546/2)\\n S2.add_peak(104.3,598/2)\\n S2.pep_mass=100\\n S2.euclidean_scale()\\n\\n score,peaks=similarity.cosine_score_max(S1,S2)\\n assert peaks==6, \\\"Incorrect number of peaks matched with greedy method\\\"\\n assert math.isclose(score,1.0), \\\"Incorrect score with greedy method\\\"\\n\\n score,peaks=similarity.cosine_score_greedy(S1,S2)\\n assert peaks==6, \\\"Incorrect number of peaks matched with maximum weighted method\\\"\\n assert math.isclose(score,1.0), \\\"Incorrect score with maximum weighted method\\\"\",\n \"def match_twosided(desc1,desc2):\\n matches_12 = match(desc1, desc2)\\n matches_21 = match(desc2, desc1)\\n ndx_12 = matches_12.nonzero()[0]\\n # remove matches that are not symmetric\\n for n in ndx_12:\\n if matches_21[int(matches_12[n])] != n:\\n matches_12[n] = 0\\n return matches_12\",\n \"def match_data(embeddings, z_scores):\\r\\n print(\\\"Matching protein IDs...\\\", end=\\\"\\\")\\r\\n\\r\\n x, y = [], []\\r\\n # this could just as well be the keys from the z-scores, since the two of them are identical\\r\\n protein_ids = embeddings.keys()\\r\\n for protein_id in protein_ids:\\r\\n x.append(embeddings[protein_id])\\r\\n y.append(z_scores[protein_id])\\r\\n\\r\\n print(f\\\"done!\\\")\\r\\n return x, y\",\n \"def match_dimensions(A, B, dims):\\n dsa = A.datashape.copy()\\n dsb = B.datashape.copy()\\n dsa.dim_low = list(dsa.dim_low)\\n dsb.dim_low = list(dsb.dim_low)\\n dsa.dim_high = list(dsa.dim_high)\\n dsb.dim_high = list(dsb.dim_high)\\n\\n for i, j in dims:\\n low = min(dsa.dim_low[i], dsb.dim_low[j])\\n high = max(dsa.dim_high[i], dsb.dim_high[j])\\n\\n dsa.dim_low[i] = low\\n dsa.dim_high[i] = high\\n dsb.dim_low[j] = low\\n dsb.dim_high[j] = high\\n\\n if dsa != A.datashape:\\n A = A.redimension(dsa.schema)\\n if dsb != B.datashape:\\n B = B.redimension(dsb.schema)\\n\\n return A, B\",\n \"def match_features(desc1, desc2, min_score):\\n\\n match = []\\n flat_des1 = desc1.reshape(desc1.shape[0],desc1.shape[1] * desc1.shape[2])\\n flat_des2 = desc2.reshape(desc2.shape[0], desc2.shape[1] * desc2.shape[2])\\n combine = np.dot(flat_des1,flat_des2.transpose())\\n\\n for i in range (combine.shape[0]):\\n max_index_row = combine[i].argsort()[-2:]\\n for j in max_index_row:\\n max_index_col = combine[:,j].argsort()[-2:]\\n if i in max_index_col and combine[i][j] >= min_score:\\n match.append([i,j])\\n\\n match = np.array(match)\\n return [match.transpose()[0],match.transpose()[1]] #todo should be list?\",\n \"def match_twosided(desc1,desc2):\\n\\t\\n\\tmatches_12 = match(desc1,desc2)\\n\\tmatches_21 = match(desc2,desc1)\\n\\t\\n\\tndx_12 = matches_12.nonzero()[0]\\n\\t\\n\\t#remove matches that are not symmetric\\n\\tfor n in ndx_12:\\n\\t\\tif matches_21[int(matches_12[n])] != n:\\n\\t\\t\\tmatches_12[n] = 0\\n\\t\\n\\treturn matches_12\",\n \"def map_nodes(dist1, dist2, lcnt, op, mode=None):\\n # TODO: Modify the functions citing this function, so that we can avoid use \\\"mode\\\" in this function.\\n # The only difference is the format of dist2\\n \\n tmp = 0\\n map_dict = []\\n for i in range(0, lcnt):\\n map_dict.append(i)\\n \\n if mode == None:\\n if len(dist1)==len(dist2):\\n dist_M = np.zeros((len(dist1), len(dist2)))\\n for i in range(0, len(dist1)):\\n for j in range(0, len(dist2)):\\n dist_M[i,j] = np.linalg.norm(dist1[i]-dist2[j])\\n row_ind, col_ind = linear_sum_assignment(dist_M)\\n for i in range(0, len(col_ind)):\\n map_dict.append(col_ind[i]+lcnt)\\n else:\\n for i in range(0, len(dist1)):\\n idx = find_min_square_dist(dist1[i], dist2, op, map_dict, lcnt)\\n map_dict.append(idx+lcnt)\\n else:\\n if len(dist1)==len(dist2)-lcnt:\\n dist1 = dist1[lcnt:len(dist1),:]\\n dist_M = np.zeros((len(dist1), len(dist2)))\\n for i in range(0, len(dist1)):\\n for j in range(0, len(dist2)):\\n dist_M[i,j] = np.linalg.norm(dist1[i]-dist2[j])\\n row_ind, col_ind = linear_sum_assignment(dist_M)\\n for i in range(0, len(col_ind)):\\n map_dict.append(col_ind[i]+lcnt)\\n else:\\n for i in range(0, len(dist1)):\\n idx = find_min_square_dist(dist1[i], dist2, op, map_dict, lcnt)\\n map_dict.append(idx)\\n\\n return map_dict\",\n \"def findSubsetIndices(grdMODEL, min_lat, max_lat, min_lon, max_lon):\\n\\n\\n if min_lon<0 and max_lon>0:\\n splitExtract = True; Turns=2\\n grdMODEL.splitExtract=splitExtract\\n else:\\n splitExtract = False; Turns=1\\n grdMODEL.splitExtract=splitExtract\\n grdMODEL.lon = np.where(grdMODEL.lon>180,grdMODEL.lon-360,grdMODEL.lon)\\n \\n # Array to store the results returned from the function\\n res=np.zeros((Turns,4),dtype=np.float64)\\n \\n lats=grdMODEL.lat[:,0]\\n lons=grdMODEL.lon[0,:]\\n\\n \\n for k in range(Turns):\\n\\n if k==0 and splitExtract == True:\\n minLon=min_lon; maxLon=0\\n minLon=minLon+360\\n maxLon=maxLon+360\\n elif k==1 and splitExtract == True:\\n minLon=0; maxLon=max_lon\\n else:\\n minLon=min_lon; maxLon=max_lon\\n \\n distances1 = []\\n distances2 = []\\n indices=[]\\n index=1\\n for point in lats:\\n s1 = max_lat-point # (vector subtract)\\n s2 = min_lat-point # (vector subtract)\\n distances1.append((np.dot(s1, s1), point, index))\\n distances2.append((np.dot(s2, s2), point, index-1))\\n index=index+1\\n\\n distances1.sort()\\n distances2.sort()\\n indices.append(distances1[0])\\n indices.append(distances2[0])\\n \\n distances1 = []\\n distances2 = []\\n index=1\\n \\n for point in lons:\\n s1 = maxLon-point # (vector subtract)\\n s2 = minLon-point # (vector subtract)\\n distances1.append((np.dot(s1, s1), point, index))\\n distances2.append((np.dot(s2, s2), point, index-1))\\n index=index+1\\n \\n distances1.sort()\\n distances2.sort()\\n indices.append(distances1[0])\\n indices.append(distances2[0])\\n\\n # Save final product: max_lat_indices,min_lat_indices,max_lon_indices,min_lon_indices\\n minJ=indices[1][2]\\n maxJ=indices[0][2]\\n minI=indices[3][2]\\n maxI=indices[2][2]\\n \\n res[k,0]=minI; res[k,1]=maxI; res[k,2]=minJ; res[k,3]=maxJ;\\n\\n # Save final product: max_lat_indices,min_lat_indices,max_lon_indices,min_lon_indices\\n grdMODEL.indices=res\",\n \"def read_pairwise_ld(snp1, snp2):\\n\\tif snp1.rsID == snp2.rsID:\\n\\t\\treturn 1\\n\\tif snp1.rsID in r2_cache and snp2.rsID in r2_cache:\\n\\t\\treturn r2_cache[snp1.rsID][snp2.rsID]\\n\\telse:\\n\\t\\treturn 0\",\n \"def get_closest_match(indices1, indices2):\\n \\n if len(indices1) == 1 and len(indices2) == 1:\\n return indices1[0], indices2[0]\\n \\n closest_match = (indices1[0], indices2[0])\\n min_dist = np.abs(closest_match[0][0] - closest_match[1][0])\\n for pair in itertools.product(indices1, indices2):\\n dist = np.abs(pair[0][0] - pair[1][0])\\n if dist < min_dist:\\n closest_match = pair\\n min_dist = dist\\n \\n return closest_match\",\n \"def findMatches2(personDict,matches,skepticalMatches,personDict2,s2=0):\\n try:\\n additionalMatches = {}\\n skipCount = 0\\n L1 = list(personDict['LAST'])\\n L2 = list(personDict['FIRST'])\\n L3 = list(personDict['DOB'])\\n count = 0\\n for ln in L1[:]:\\n count += 1\\n if count%600==0:\\n print (round(100*count/len(L1),3),\\\"% complete [\\\"+str(count)+\\\"/\\\"+str(len(L1))+\\\"] after\\\",round(time.time()-s2,2),\\\"seconds\\\")\\n print (len(additionalMatches),\\\"additional matches found so far...\\\",flush=True)\\n if ln=='':\\n continue\\n LNIDs = personDict['LAST'][ln]\\n for fn in L2:\\n if fn=='':\\n continue\\n \\n FNIDs = personDict['FIRST'][fn]\\n toPassOn = LNIDs.intersection(FNIDs)\\n if len(toPassOn)==0:\\n skipCount += 1\\n continue\\n \\n for dob in L3:\\n if dob=='':\\n continue\\n DOBIDs = personDict['DOB'][dob]\\n finalSet = toPassOn.intersection(DOBIDs)\\n if len(finalSet)==0:\\n skipCount += 1\\n continue\\n pairs = itertools.combinations(finalSet,2)\\n for p in pairs:\\n k = tuple(sorted(p))\\n \\n info1b = personDict2['EnterpriseID'][p[0]]\\n info2b = personDict2['EnterpriseID'][p[1]]\\n \\n if (k not in matches) and (k not in skepticalMatches) and (k not in additionalMatches):\\n badness = (L.distance(info1b[1],info2b[1])+L.distance(info1b[2],info2b[2])+2*L.distance(info1b[5],info2b[5]))\\n score = getScorePair(info1b,info2b)\\n if info1b[7]!=\\\"\\\" and info2b[7]!=\\\"\\\":\\n badness+=L.distance(info1b[7],info2b[7])\\n if len(info1b[12])>4 and len(info2b[12])>4:\\n if info1b[12][0:4]==info2b[12][0:4]:\\n badness-=2\\n if badness>2 and score<5:\\n continue\\n \\n additionalMatches[k] = score\\n except KeyboardInterrupt:\\n return additionalMatches\\n return additionalMatches\",\n \"def match2(img1, img2, coordinates1, coordinates2, PATCH_SIZE):\\n\\n\\tpossible_matches = pd.DataFrame(columns=['feature1', 'feature2', 'diff'])\\n\\n\\t# iteration through all the possible pairs of features from img1 and img2\\n\\tfor (feature1, feature2) in product(coordinates1, coordinates2):\\n\\t\\tpatch1 = make_patch(feature1, PATCH_SIZE, img1)\\n\\t\\tpatch2 = make_patch(feature2, PATCH_SIZE, img2)\\n\\t\\tdiff = count_difference(patch1, patch2)\\n\\t\\t# print(feature1, feature2, diff)\\n\\t\\t# next line is weird, don't ask\\n\\t\\tpossible_matches = possible_matches.append({'feature1': feature1, 'feature2': feature2, 'diff': diff}, ignore_index=True)\\n\\n\\n\\t# sorting the possible_matches according to their difference and resetin the index\\n\\t# inplace=True means that changes will be performed in-place, so they will change the variable and there is no need to reassign\\n\\tpossible_matches.sort_values(['diff'], inplace=True)\\n\\tpossible_matches.reset_index(inplace=True, drop=True)\\n\\t# print(\\\"SORTED\\\")\\n\\t# print(possible_matches)\\n\\n\\t# adding only the best matches\\n\\tmatches = []\\n\\twhile not possible_matches.empty:\\n\\t\\tbest_match = possible_matches.loc[0]\\n\\t\\tmatches.append(list(best_match))\\n\\t\\t# creating a list of indicies to be dropped\\n\\t\\ttrash = []\\n\\n\\t\\t#finding and deleting rows with features that are already used and reseting the index\\n\\t\\tfor i, (f1, f2, d) in enumerate(possible_matches.values):\\n\\t\\t \\n\\t\\t\\tif np.all(f1 == best_match[0]) or np.all(f2 == best_match[1]):\\n\\t\\t\\t\\ttrash.append(i)\\n\\t\\n\\t\\tfor i in trash:\\n\\t\\t\\tpossible_matches.drop(i, inplace=True)\\n\\t\\tpossible_matches.reset_index(inplace=True, drop=True)\\n\\t\\t# print(possible_matches)\\n\\n\\treturn matches\",\n \"def one_to_one_compare(comparison_1, comparison_2):\\r\\n total = comparison_1.shape[0]\\r\\n interm = 0\\r\\n one2one = 0\\r\\n for row in comparison_1.itertuples():\\r\\n if row.gene_type == \\\"one_to_one_mapping\\\":\\r\\n interm += 1\\r\\n Q_gene = row.Query_gene\\r\\n S_gene = row.Sytentic_genes.split(\\\",\\\")[0]\\r\\n # get the index of the query gene in second file using subject gene var\\r\\n idx = comparison_2[comparison_2.Query_gene.isin([S_gene])].index.tolist()\\r\\n # check to see if the index is empty\\r\\n if idx:\\r\\n if comparison_2.at[idx[0], \\\"gene_type\\\"] == \\\"one_to_one_mapping\\\":\\r\\n comp_2_S_gene = comparison_2.at[idx[0], \\\"Sytentic_genes\\\"].split(\\\",\\\")[0]\\r\\n if comp_2_S_gene == Q_gene:\\r\\n one2one += 1\\r\\n return(total, interm, one2one)\",\n \"def find_dimm_ids(**kwargs):\\n member = kwargs.get(\\\"data\\\", {})\\n memory_members = kwargs.get(\\\"resources\\\").get(\\\"memory\\\", [])\\n interleave_sets = member.get(\\\"InterleaveSets\\\", [])\\n locations = []\\n for interleave_set in interleave_sets:\\n for pmem in memory_members:\\n if PmemHelpers.compare_id(\\n interleave_set.get(\\\"Memory\\\").get(\\\"@odata.id\\\"), pmem.get(\\\"@odata.id\\\")\\n ):\\n location = Mapper.get_single_attribute(\\n pmem, \\\"Location\\\", MappingTable.device.value, output_as_json=True\\n )\\n locations.append(location.get(\\\"Location\\\", \\\"\\\"))\\n return PmemHelpers.location_format_converter(locations)[0]\",\n \"def get_similarities(tags):\\n return [(a, b)\\n for (a, b) in itertools.permutations(tags, 2)\\n if difflib.SequenceMatcher(a=a.lower(), b=b.lower()).ratio() > SIMILAR\\n and a != b\\n and b.endswith('s')]\",\n \"def seq_dist(i1: int, s1: t.Collection[SeqGene],\\n i2: int, s2: t.Collection[SeqGene]) -> t.Tuple[int, int, float]:\\n m1, m2 = map(\\n lambda s: dict(chain.from_iterable(\\n ((pos, aa) for pos, aa in zip(g.Pos, g.Seq)) for g in s)),\\n [s1, s2])\\n d = 0.\\n for p in set(m1) | set(m2):\\n if p in m1 and p in m2 and m1[p] == m2[p]:\\n continue\\n d += 1\\n return i1, i2, d\",\n \"def pointfind2(plat, plon, lat, lon, pdif=1):\\n\\n\\tdist_min = 1000000.\\n\\t\\n\\t\\n\\tfor i in range(lon.shape[0]):\\n\\t\\tfor j in range(lon.shape[1]):\\n\\t\\t\\tdist = Ngl.gc_dist(plat,plon,lat[i,j],lon[i,j])\\n\\t\\t\\tif dist_min > dist:\\n\\t\\t\\t\\tdist_min = dist\\n\\t\\t\\t\\ti_min = i\\n\\t\\t\\t\\tj_min = j\\n\\t\\t\\t\\tlat_min = lat[i,j]\\n\\t\\t\\t\\tlon_min = lon[i,j]\\n\\t\\n\\tprint(i_min,j_min,lat_min,lon_min)\\n\\tgg1 = i_min, j_min\\n\\t\\n\\treturn(gg1, lat_min, lon_min)\",\n \"def splitNodes(matching):\\n outer = set(range(self.n))\\n inner = set([])\\n for (u, v) in matching:\\n if u in outer:\\n outer.remove(u)\\n if v in outer:\\n outer.remove(v)\\n inner.add(u)\\n inner.add(v)\\n return list(inner), list(outer)\",\n \"def diff_index_calc(oct_abund_list1, oct_abund_list2):\\n rel_index_list = []\\n abs_index_list = []\\n smty_index_list = []\\n for i in range(10):\\n abund_data_array = sc.asarray(oct_abund_list1[i], dtype='double')\\n abund_sim_array = sc.asarray(oct_abund_list2[i], dtype = 'double')\\n \\n # make the length of the arrays similar to each other\\n if len(abund_data_array) < len(abund_sim_array):\\n small_len = abund_data_array\\n long_len = abund_sim_array\\n else:\\n small_len = abund_sim_array\\n long_len = abund_data_array\\n diff = len(long_len) - len(small_len) \\n small_len = sc.append(small_len, [0]*diff)\\n \\n relative_index_vect = abs(long_len - small_len)/long_len \\n rel_index_list.append(sum(relative_index_vect)/len(relative_index_vect))\\n \\n absolute_index_vect = abs(long_len - small_len)\\n abs_index_list.append(sum(absolute_index_vect)/len(absolute_index_vect))\\n \\n similarity_index_vect = []\\n for i in range(len(long_len)):\\n similarity_index_vect.append(sc.minimum(long_len[i], small_len[i])/sc.amax([long_len[i], small_len[i]]))\\n \\n smty_index_list.append(sum(similarity_index_vect)/len(similarity_index_vect)) \\n \\n rel_index_final = sum(rel_index_list)/10\\n abs_index_final = sum(abs_index_list)/10\\n smty_index_final = sum(smty_index_list)/10\\n \\n return (rel_index_final, abs_index_final, smty_index_final)\",\n \"def compare_trees(tree1, tree2):\\n \\tresponse = {}\\n \\tstart_time = time.time()\\n \\ttry:\\t\\n \\t\\ttns = dendropy.TaxonNamespace() \\t\\n \\t\\n \\t\\ttree_obj1 = dendropy.Tree.get(data=tree1, schema=\\\"newick\\\",taxon_namespace=tns)\\n \\t\\ttree_obj2 = dendropy.Tree.get(data=tree2, schema=\\\"newick\\\",taxon_namespace=tns)\\n\\n \\t\\ttree_obj1.encode_bipartitions()\\n \\t\\ttree_obj2.encode_bipartitions()\\n\\n \\t\\t#-----------------------------------------------------------\\n \\t\\t#This method returns the symmetric distance between two trees. \\n \\t\\t#The symmetric distance between two trees is the sum of the number of splits found in one of the trees but not the other. \\n \\t\\t#It is common to see this statistic called the Robinson-Foulds distance\\n\\n \\t\\tareSame = True if treecompare.symmetric_difference(tree_obj1, tree_obj2) == 0 else False\\n \\t\\tstatus = 200\\n \\t\\tmessage = \\\"Success\\\"\\n \\t\\tresponse['are_same_tree'] = areSame\\n \\n \\texcept Exception, e:\\n \\t\\tif \\\"Incomplete or improperly-terminated tree statement\\\" in str(e): #invalid: \\\"((A,B),C,D));\\\" valid: ((A,B),(C,D)); \\n \\t\\t\\tmessage = \\\"NewickReaderIncompleteTreeStatementError: \\\" + str(e)\\n \\t \\t\\tstatus = 400\\n \\t\\telif \\\"Unbalanced parentheses at tree statement\\\" in str(e): #invalid: \\\"((A,B),(C,D);\\\" valid: ((A,B),(C,D)); \\n \\t\\t\\tmessage = \\\"NewickReaderMalformedStatementError: \\\"+str(e) \\n \\t \\t\\tstatus = 400\\n \\t\\telif \\\"Multiple occurrences of the same taxa\\\" in str(e): #invalid: \\\"((A,B),(C,C));\\\" valid: ((A,B),(C,D));\\n \\t\\t\\tmessage = \\\"NewickReaderDuplicateTaxonError: \\\"+str(e)\\n \\t \\t\\tstatus = 400\\n \\t\\telif \\\"Unexpected end of stream\\\" in str(e): # invalid: \\\"((A,B),(C,D))\\\" valid: ((A,B),(C,D));\\n \\t\\t\\tmessage = \\\"UnexpectedEndOfStreamError: \\\"+str(e)\\n \\t \\t\\tstatus = 400\\n \\t\\telse:\\n \\t\\t\\tmessage = \\\"Error: Failed to compare trees. \\\"+str(e)\\n \\t \\t\\tstatus = 500\\n \\t \\t\\n \\tresponse['status_code'] = status\\n \\tresponse['message'] = message\\n\\n \\tend_time = time.time()\\n \\texecution_time = end_time-start_time\\n #service result creation time\\n \\tcreation_time = datetime.datetime.now().isoformat()\\n \\tmeta_data = {'creation_time': creation_time, 'execution_time': float('{:4.2f}'.format(execution_time)), 'source_urls':[\\\"http://dendropy.org/library/treecompare.html#module-dendropy.calculate.treecompare\\\"] }\\n\\n \\tresponse['meta_data'] = meta_data\\n \\tprint response\\n \\treturn response\",\n \"def find_matches(id1, id2, adj_list_ids, adj_list_words):\\n\\n # combine words from tweets\\n stanza_words = adj_list_ids[id1] + adj_list_ids[id2]\\n\\n # look for other tweets with those words\\n pot_ids = set().union(*[adj_list_words[w] for w in stanza_words])\\n\\n # --- filter down ---\\n # remove start tweets\\n # ensure tweets contain subset of master_word_set\\n pot_ids = pot_ids - {id1, id2}\\n pot_ids = [x for x in pot_ids if set(adj_list_ids[x]) <= set(stanza_words)]\\n\\n # look for valid pairs of potential tweets\\n if len(pot_ids) > 1:\\n return find_valid_matches(pot_ids, adj_list_ids, stanza_words)\\n return []\",\n \"def match_all(data_dir):\\n print('Loading GT')\\n gt_cells = load(os.path.join(data_dir, 'cell_obj', 'cells_final_selected.hdf5'))\\n storm_i = np.load(os.path.join(data_dir, 'images', 'storm_inner.npy'))\\n\\n for ph in [10000, 1000, 500]:\\n print('Photons {}'.format(ph))\\n\\n m_cells = load(os.path.join(data_dir, 'cell_obj', 'cell_ph_{}_raw.hdf5'.format(ph)))\\n print('Measured cells loaded')\\n\\n bin_predicted = tifffile.imread(os.path.join(data_dir, 'images', 'binary_{}photons_predicted.tif'.format(ph)))\\n print('Filtering')\\n filtered_pred = filter_binaries(bin_predicted, min_size=495, max_size=2006.4, min_minor=7.57, max_minor=17.3,\\n min_major=15.41, max_major=54.97)\\n\\n gt_match, m_match, = match_cells(gt_cells, m_cells, storm_i, filtered_pred, max_d=5)\\n\\n print('Matched {} cells out of max {}'.format(len(m_match), len(m_cells)))\\n\\n for i, (m_, gt_) in tqdm(enumerate(zip(m_match, gt_match))):\\n m_i = m_cells.name.tolist().index(m_.rstrip())\\n g_i = gt_cells.name.tolist().index(gt_.rstrip())\\n\\n try:\\n assert len(m_cells[m_i].data.data_dict['storm_inner']) == len(gt_cells[g_i].data.data_dict['storm_inner'])\\n except AssertionError:\\n print('Assertion error:', i)\\n\\n with open(os.path.join(data_dir, 'matched_names', 'gt_cells_ph_{}_match.txt'.format(ph)), 'w') as f:\\n f.writelines(gt_match)\\n\\n with open(os.path.join(data_dir, 'matched_names', 'm_cells_ph_{}_match.txt'.format(ph)), 'w') as f:\\n f.writelines(m_match)\",\n \"def pairs(data1, r, data2=None, period=None):\\n \\n #work with arrays!\\n data1 = np.asarray(data1)\\n if data2==None:\\n data2 = np.asarray(data1)\\n self_match=False\\n else:\\n data2 = np.asarray(data2)\\n self_match=True\\n \\n #Check to make sure both data sets have the same dimension. Otherwise, throw an error!\\n if np.shape(data1)[-1]!=np.shape(data2)[-1]:\\n raise ValueError(\\\"data1 and data2 inputs do not have the same dimension.\\\")\\n return None\\n \\n #Process period entry and check for consistency.\\n if period is None:\\n period = np.array([np.inf]*np.shape(data1)[-1])\\n else:\\n period = np.asarray(period).astype(\\\"float64\\\")\\n if np.shape(period) == ():\\n period = np.array([period]*np.shape(data1)[-1])\\n if np.shape(period)[0] != np.shape(data1)[-1]:\\n raise ValueError(\\\"period should have len == dimension of points\\\")\\n return None\\n \\n tree_1 = cKDTree(data1)\\n \\n pairs = tree_1.query_ball_tree(tree_2, r, period=period)\\n \\n spairs = set()\\n for i in range(len(pairs)):\\n if self_match==False:\\n if pairs[i,0] != pairs[i,1]:\\n spairs.add((min(pairs[i]),max(pairs[i])))\\n if self_match==True:\\n spairs.add((min(pairs[i]),max(pairs[i])))\\n \\n return spairs\",\n \"def _node_distance(self, first, second):\\r\\n\\r\\n name_1 = first.name.split(' ')[0]\\r\\n name_2 = second.name.split(' ')[0]\\r\\n\\r\\n seq1 = self.msa_by_name[name_1]\\r\\n seq2 = self.msa_by_name[name_2]\\r\\n\\r\\n distance = self._seq_distance(seq1, seq2)\\r\\n\\r\\n return distance\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.7055238","0.5894939","0.55227906","0.5489085","0.54599357","0.5449781","0.5447405","0.5445119","0.5440812","0.53929174","0.53769183","0.537584","0.5372282","0.5365889","0.53626955","0.5340169","0.53266394","0.5322242","0.531484","0.53060037","0.5296792","0.529522","0.529191","0.52913845","0.52905315","0.5277481","0.52682483","0.5251946","0.52248424","0.5206286","0.5201795","0.52005637","0.5199909","0.5198492","0.51927567","0.5174844","0.5162947","0.5152194","0.51474786","0.51461303","0.5135061","0.51314485","0.51264846","0.51261425","0.51243114","0.51235044","0.5119747","0.5118599","0.5116199","0.51149887","0.5112493","0.5105214","0.51024306","0.5099257","0.50963527","0.5084193","0.5077266","0.5073668","0.5068819","0.5064951","0.5060139","0.50601137","0.50536627","0.50520283","0.50482464","0.5047235","0.5047022","0.5044345","0.50405383","0.5037826","0.5031654","0.50306064","0.50296587","0.50292265","0.5028269","0.5028069","0.50228727","0.502189","0.5007184","0.500663","0.5005315","0.49957496","0.49943125","0.49872774","0.49833947","0.49823073","0.4975823","0.49488786","0.49466527","0.4945128","0.49398997","0.49341485","0.49319527","0.49305314","0.4929138","0.49273553","0.49259678","0.49234957","0.49169272","0.49141714"],"string":"[\n \"0.7055238\",\n \"0.5894939\",\n \"0.55227906\",\n \"0.5489085\",\n \"0.54599357\",\n \"0.5449781\",\n \"0.5447405\",\n \"0.5445119\",\n \"0.5440812\",\n \"0.53929174\",\n \"0.53769183\",\n \"0.537584\",\n \"0.5372282\",\n \"0.5365889\",\n \"0.53626955\",\n \"0.5340169\",\n \"0.53266394\",\n \"0.5322242\",\n \"0.531484\",\n \"0.53060037\",\n \"0.5296792\",\n \"0.529522\",\n \"0.529191\",\n \"0.52913845\",\n \"0.52905315\",\n \"0.5277481\",\n \"0.52682483\",\n \"0.5251946\",\n \"0.52248424\",\n \"0.5206286\",\n \"0.5201795\",\n \"0.52005637\",\n \"0.5199909\",\n \"0.5198492\",\n \"0.51927567\",\n \"0.5174844\",\n \"0.5162947\",\n \"0.5152194\",\n \"0.51474786\",\n \"0.51461303\",\n \"0.5135061\",\n \"0.51314485\",\n \"0.51264846\",\n \"0.51261425\",\n \"0.51243114\",\n \"0.51235044\",\n \"0.5119747\",\n \"0.5118599\",\n \"0.5116199\",\n \"0.51149887\",\n \"0.5112493\",\n \"0.5105214\",\n \"0.51024306\",\n \"0.5099257\",\n \"0.50963527\",\n \"0.5084193\",\n \"0.5077266\",\n \"0.5073668\",\n \"0.5068819\",\n \"0.5064951\",\n \"0.5060139\",\n \"0.50601137\",\n \"0.50536627\",\n \"0.50520283\",\n \"0.50482464\",\n \"0.5047235\",\n \"0.5047022\",\n \"0.5044345\",\n \"0.50405383\",\n \"0.5037826\",\n \"0.5031654\",\n \"0.50306064\",\n \"0.50296587\",\n \"0.50292265\",\n \"0.5028269\",\n \"0.5028069\",\n \"0.50228727\",\n \"0.502189\",\n \"0.5007184\",\n \"0.500663\",\n \"0.5005315\",\n \"0.49957496\",\n \"0.49943125\",\n \"0.49872774\",\n \"0.49833947\",\n \"0.49823073\",\n \"0.4975823\",\n \"0.49488786\",\n \"0.49466527\",\n \"0.4945128\",\n \"0.49398997\",\n \"0.49341485\",\n \"0.49319527\",\n \"0.49305314\",\n \"0.4929138\",\n \"0.49273553\",\n \"0.49259678\",\n \"0.49234957\",\n \"0.49169272\",\n \"0.49141714\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.82478267"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":89898,"cells":{"query":{"kind":"string","value":"Check for equality, in everything but the last provenance."},"document":{"kind":"string","value":"def verify_slim_restart_equality(self, in_ts, out_ts):\n assert in_ts.num_provenances + 1 == out_ts.num_provenances\n in_tables = in_ts.dump_tables()\n in_tables.sort()\n out_tables = out_ts.dump_tables()\n out_tables.sort()\n self.assertTableCollectionsEqual(in_tables, out_tables, skip_provenance=-1)"},"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 testEquality(self):\n pass","def test_equality(self):\n self.assertTrue(Record(1, 2) == Record(1, 2))\n self.assertFalse(Record(1, 2) == Record(1, 3))\n self.assertFalse(Record(1, 2) == Record(2, 2))\n self.assertFalse(Record(1, 2) == Record(3, 4))","def test_equal_on_equal(self):\n a = objects.OpaqueObject(self.bytes_a, enums.OpaqueDataType.NONE)\n b = objects.OpaqueObject(self.bytes_a, enums.OpaqueDataType.NONE)\n self.assertTrue(a == b)\n self.assertTrue(b == a)","def test_equality(self):\n self.assertEqual(self._version1, self._version1)\n self.assertNotEqual(self._version2, self._version1)\n self.assertEqual(self._version1, PrcsVersion(self._version1))","def test_equal_on_equal(self):\n a = Certificate(\n certificate_type=self.certificate_type_b,\n certificate_value=self.certificate_value_b)\n b = Certificate(\n certificate_type=self.certificate_type_b,\n certificate_value=self.certificate_value_b)\n\n self.assertTrue(a == b)\n self.assertTrue(b == a)","def is_equivalence(self) -> bool:","def test_equal_on_equal(self):\n a = Digest(\n hashing_algorithm=self.hashing_algorithm_b,\n digest_value=self.digest_value_b,\n key_format_type=self.key_format_type_b)\n b = Digest(\n hashing_algorithm=self.hashing_algorithm_b,\n digest_value=self.digest_value_b,\n key_format_type=self.key_format_type_b)\n\n self.assertTrue(a == b)\n self.assertTrue(b == a)","def test_equal(self):\n self.assertTrue(self.a == self.a)\n self.assertFalse(self.a != self.a)","def test_unequality(self):\n self.assertFalse(Record(1, 2) != Record(1, 2))\n self.assertTrue(Record(1, 2) != Record(1, 3))\n self.assertTrue(Record(1, 2) != Record(2, 2))\n self.assertTrue(Record(1, 2) != Record(3, 4))","def test_equal_on_equal_and_empty(self):\n a = Certificate(\n certificate_type=self.certificate_type_a,\n certificate_value=self.certificate_value_a)\n b = Certificate(\n certificate_type=self.certificate_type_a,\n certificate_value=self.certificate_value_a)\n\n self.assertTrue(a == b)\n self.assertTrue(b == a)","def test_almost_equal(self):\n x = Point(\n lat=23.4,\n lng=23.1,\n author=self.u\n )\n self.assertTrue(self.a == x)\n self.assertFalse(self.a != x)","def test_not_equal_on_equal(self):\n a = objects.OpaqueObject(self.bytes_a, enums.OpaqueDataType.NONE)\n b = objects.OpaqueObject(self.bytes_a, enums.OpaqueDataType.NONE)\n self.assertFalse(a != b)\n self.assertFalse(b != a)","def test_equal_on_equal_and_empty(self):\n a = Digest()\n b = Digest()\n\n self.assertTrue(a == b)\n self.assertTrue(b == a)","def test_eq_true(self):\n self.assertTrue(self.instance == Commit(self.instance.sha))","def test_equals(self):\n parameters = [\n (1, 'a', False),\n (1, None, False),\n (1, 2, False),\n (1, 1, True)\n ]\n for pair in parameters:\n with self.subTest(pair=pair):\n self.getLogger().info('Next pair %s', pair)\n _obj1 = Node(pair[0])\n _obj2 = None if not pair[1] else Node(pair[1])\n self.assertEqual(_obj1._equals(_obj2), pair[2])\n _objSelf = Node(1)\n self.assertTrue(_objSelf._equals(_objSelf))","def __eq__(self, other):\n if not isinstance(other, ApiBuildProvenance):\n return False\n\n return self.__dict__ == other.__dict__","def test_not_equal_on_equal(self):\n a = Certificate(\n certificate_type=self.certificate_type_b,\n certificate_value=self.certificate_value_b)\n b = Certificate(\n certificate_type=self.certificate_type_b,\n certificate_value=self.certificate_value_b)\n\n self.assertFalse(a != b)\n self.assertFalse(b != a)","def is_equal (self, p):\n assert isinstance (p, Problem), \"Must be comparing two of same type\"\n if self.objects != p.objects:\n print(\"objects\")\n return False\n\n if self.init != p.init:\n #print \"init\"\n #print \"*self*\"\n #print self.init\n #print \"*p*\"\n #print p.init\n return False\n\n if self.goal != p.goal:\n print(\"goal\")\n return False\n\n if not all ([sa == pa for sa, pa in zip (self.actions, p.actions)]):\n print(\"actions\")\n return False\n\n if not all ([sp == pp for sp, pp in zip (self.predicates, p.predicates)]):\n print(\"predicates\")\n return False\n\n if self.types != p.types or self.parent_types != p.parent_types:\n print(\"types\")\n return False\n\n return True","def test_not_equal_on_not_equal(self):\n a = Digest(\n hashing_algorithm=self.hashing_algorithm_b,\n digest_value=self.digest_value_b,\n key_format_type=self.key_format_type_b)\n b = Digest()\n c = Digest(\n hashing_algorithm=self.hashing_algorithm_d,\n digest_value=self.digest_value_b,\n key_format_type=self.key_format_type_c)\n d = Digest(\n key_format_type=self.key_format_type_c)\n\n self.assertTrue(a != b)\n self.assertTrue(b != a)\n self.assertTrue(b != c)\n self.assertTrue(b != d)","def test_eqprops_same(self):\n # Perform diff.\n df = Differ(key=\"name\", props=[\"same\"])\n d = df.diff(*self.engines)\n # Check results.\n self.assertEqual(len(d[Differ.CHANGED]), 0)","def test_not_equal_on_equal(self):\n a = Digest(\n hashing_algorithm=self.hashing_algorithm_b,\n digest_value=self.digest_value_b,\n key_format_type=self.key_format_type_b)\n b = Digest(\n hashing_algorithm=self.hashing_algorithm_b,\n digest_value=self.digest_value_b,\n key_format_type=self.key_format_type_b)\n\n self.assertFalse(a != b)\n self.assertFalse(b != a)","def test_not_equal_on_equal_and_empty(self):\n a = Certificate(\n certificate_type=self.certificate_type_a,\n certificate_value=self.certificate_value_a)\n b = Certificate(\n certificate_type=self.certificate_type_a,\n certificate_value=self.certificate_value_a)\n\n self.assertFalse(a != b)\n self.assertFalse(b != a)","def test_equal_on_not_equal_value(self):\n a = objects.OpaqueObject(self.bytes_a, enums.OpaqueDataType.NONE)\n b = objects.OpaqueObject(self.bytes_b, enums.OpaqueDataType.NONE)\n self.assertFalse(a == b)\n self.assertFalse(b == a)","def test_identical(self):\n write this test!","def __eq__(self, other):\n if not isinstance(other, BaseCommitAllOfSummary):\n return False\n\n return self.__dict__ == other.__dict__","def identical_to(self, elem):\n\n return (self.n1 == elem.n1) and (self.n2 == elem.n2) and (self.n3 == elem.n3) and (self.n4 == elem.n4)","def test_not_equal_on_not_equal(self):\n a = Certificate(\n certificate_type=self.certificate_type_a,\n certificate_value=self.certificate_value_a)\n b = Certificate(\n certificate_type=self.certificate_type_b,\n certificate_value=self.certificate_value_b)\n\n self.assertTrue(a != b)\n self.assertTrue(b != a)","def is_equals(self):\n return self.prop.is_equals()","def test_equal_on_not_equal(self):\n a = Certificate(\n certificate_type=self.certificate_type_a,\n certificate_value=self.certificate_value_a)\n b = Certificate(\n certificate_type=self.certificate_type_b,\n certificate_value=self.certificate_value_b)\n\n self.assertFalse(a == b)\n self.assertFalse(b == a)","def consistent(self):\n if self.var1.get_value() is None or self.var2.get_value() is None:\n return True\n\n return self.var1.value != self.var2.value","def test_eq(self):\n dummy = DummyCryptographicObject()\n self.assertTrue(dummy == dummy)","def __eq__(self, other):\n return self.sha == other.sha","def test_not_equal_on_equal_and_empty(self):\n a = Digest()\n b = Digest()\n\n self.assertFalse(a != b)\n self.assertFalse(b != a)","def test_not_equal_on_not_equal_value(self):\n a = objects.OpaqueObject(self.bytes_a, enums.OpaqueDataType.NONE)\n b = objects.OpaqueObject(self.bytes_b, enums.OpaqueDataType.NONE)\n self.assertTrue(a != b)\n self.assertTrue(b != a)","def __eq__(self, other):\n if type(self) != type(other):\n return False\n s_vars = vars(self)\n o_vars = vars(other)\n for v in vars(self):\n if s_vars[v] != o_vars[v]:\n print(\"unequal property {0}\\n\".format(v))\n if v.endswith(\"last_count_update_time\"):\n print(\"self: {0}\\n\".format(s_vars[v]))\n print(\"othr: {0}\\n\".format(o_vars[v]))\n return False\n return True","def are_equal(self, sp1, sp2):\n return","def are_equal(self, sp1, sp2):\n return True","def identical_to(self, elem):\n\n return (self.n1 == elem.n1) and (self.n2 == elem.n2)","def __eq__(self, p_object):\n if any([self[i] != p_object[i] for i in range(9)]):\n return False\n return True","def __eq__(self, other: 'PairwiseInfo') -> bool:\n\n return (\n self.their_did == other.their_did and\n self.their_verkey == other.their_verkey and\n self.my_did == other.my_did and\n self.my_verkey == other.my_verkey and\n self.metadata == other.metadata)","def almost_equals(self, other, decimal=...): # -> bool:\n ...","def test_is_consistent(self):\n self.assertTrue(self.phonebook.is_consistent())\n self.phonebook.add(\"Bob\", \"12345\")\n self.assertTrue(self.phonebook.is_consistent())\n self.phonebook.add(\"Mary\", \"012345\")\n self.assertTrue(self.phonebook.is_consistent())\n self.phonebook.add(\"Sue\", \"12345\") # identical to Bob\n self.assertTrue(self.phonebook.is_consistent())\n self.phonebook.add(\"Sue\", \"123\") # prefix of Bob\n self.assertTrue(self.phonebook.is_consistent())","def test_eq(self):\n assert self.app2 == self.app4\n assert self.app1 != self.app3","def is_equal(self, a, b):\n return a.X[0] == b.X[0]","def test_eq_false(self):\n self.assertFalse(self.instance == Commit('f3ccd0b70fe758b539c28319735d9a6489c0fb10'))","def check(self, expected, debug=True):\r\n for v1, v2, go in expected:\r\n for gj, oj in go:\r\n r1 = is_same_graph(v1, v2, givens=gj, debug=debug)\r\n assert r1 == oj\r\n r2 = is_same_graph(v2, v1, givens=gj, debug=debug)\r\n assert r2 == oj","def test_equality_check_against_other_object_doesnt_raise_exception(self):\n test_object = Vec3(1, 2, 3)\n self.assertFalse(test_object == Quat(1, 2, 3, 4))\n self.assertFalse(Quat(1, 2, 3, 4) == test_object)\n self.assertTrue(test_object != Quat(1, 2, 3, 4))\n self.assertTrue(Quat(1, 2, 3, 4) != test_object)","def _are_assumed_equal(a, b, assumed_equivs):\n\n # Are we just assuming that the two are equal?\n equiv = (id(a), id(b))\n if equiv in assumed_equivs:\n return True\n\n # If we see these two again assume they're equal. If they're not then the\n # traversal will detect it.\n assumed_equivs.add(equiv)\n return False","def is_equal(self, state1, state2):\n return self._replace_unks(state1) == self._replace_unks(state2)","def isIsosceles(self):\n\t\treturn self.a == self.b or self.a == self.c or self.b == self.c","def all_equal(sequence):\n return all(x == sequence[0] for x in sequence)","def check_consistency(self):\n raise NotImplementedError()","def e_paralelo(self, other):\n if (self == other) or (self.normaliza() == other.normaliza()):\n return True\n else:\n return False","def test_c(self):\n v1 = versions.Version(version='1.2.3', name='foo')\n v2 = versions.Version(version='1.2.3', name='bar')\n\n self.assertFalse(v1 != v2)\n self.assertFalse(v2 != v1)","def consistent(self):\n return self.incore_digest == self.ondisk_digest","def relative_eq(self, other):\n meta_compare = self.compare_meta_version(other)\n return self.version == other.version and meta_compare == 0","def test_hash_equality(self):\n origin = np.random.randn(3)\n normal = np.random.randn(3)\n up_vector = np.random.randn(3)\n up_vector2 = np.random.randn(3)\n p1 = shapes_3d.CoordinatePlane(origin, normal, up_vector)\n p2 = shapes_3d.CoordinatePlane(origin, normal, up_vector)\n p3 = shapes_3d.CoordinatePlane(origin, normal, up_vector2)\n \n self.assertEqual(p1, p2)\n self.assertNotEqual(p1, p3)","def testEquality(self) -> None:\n r = data_types.Result('test_1', ('win', 'x86'), (1, 10), 'id')\n other = data_types.Result('test_1', ('win', 'x86'), (1, 10), 'id')\n self.assertEqual(r, other)\n\n other = data_types.Result('test_2', ('win', 'x86'), (1, 10), 'id')\n self.assertNotEqual(r, other)\n\n other = data_types.Result('test_1', ('win', 'arm64'), (1, 10), 'id')\n self.assertNotEqual(r, other)\n\n other = data_types.Result('test_1', ('win', 'x86'), (2, 11), 'id')\n self.assertNotEqual(r, other)\n\n other = data_types.Result('test_1', ('win', 'x86'), (1, 10), 'id_2')\n self.assertNotEqual(r, other)\n\n other = None\n self.assertNotEqual(r, other)","def test_c(self):\n v1 = versions.Version(version='1.2.3', name='foo')\n v2 = versions.Version(version='2.2.3', name='bar')\n\n self.assertFalse(v1 == v2)\n self.assertFalse(v2 == v1)","def test_equals(self):\n measurement_1 = Measurement(self.metric())\n measurement_2 = Measurement(self.metric())\n self.assertTrue(measurement_1.equals(measurement_2))","def __eq__(self, other):\n return self.properties == other.properties","def test_eq(self):\n st_1 = State(substance=\"water\", T=Q_(400.0, \"K\"), p=Q_(101325.0, \"Pa\"))\n st_2 = State(substance=\"water\", T=Q_(400.0, \"K\"), p=Q_(101325.0, \"Pa\"))\n assert st_1 == st_2","def check_consistency(self, es):","def test_verify_equivalency(self):\r\n\r\n fasta_data = {'seq1': 'AATC', 'seq2': 'GGAT'}\r\n\r\n qual_data = {'seq1': [\"40\", \"36\", \"35\", \"18\"],\r\n 'seq2': [\"39\", \"18\", \"22\", \"23\"]}\r\n\r\n # Should not raise any errors\r\n verify_equivalency(fasta_data, qual_data)\r\n\r\n # Make number of sequences unequal, and should raise error.\r\n fasta_data = {'seq1': 'AATC', 'seq2': 'GGAT', 'seq3': 'ACTG'}\r\n\r\n qual_data = {'seq1': [\"40\", \"36\", \"35\", \"18\"],\r\n 'seq2': [\"39\", \"18\", \"22\", \"23\"]}\r\n\r\n self.assertRaises(\r\n ValueError,\r\n verify_equivalency,\r\n fasta_data,\r\n qual_data)\r\n\r\n # Should raise error if lens of values different\r\n fasta_data = {'seq1': 'AATC', 'seq2': 'GGAT'}\r\n\r\n qual_data = {'seq1': [\"50\", \"40\", \"36\", \"35\", \"18\"],\r\n 'seq2': [\"39\", \"18\", \"22\", \"23\"]}\r\n\r\n self.assertRaises(\r\n ValueError,\r\n verify_equivalency,\r\n fasta_data,\r\n qual_data)","def is_equal(self, codon_pair: 'CodonPair') -> bool:\n return self.sequence == codon_pair.sequence","def check_pairs(self, all_pr, curr):\n flag = True\n for pair_ox in all_pr:\n if (curr[0] == pair_ox or curr[1] == pair_ox):\n flag = False\n return flag","def __eq__(self, other):\n if type(other) == type(self):\n if other.triple.relation == self.triple.relation:\n if (other.triple.concept1 == self.triple.concept1 \n and other.triple.concept2 == self.triple.concept2):\n return True\n return False","def __eq__(self, v):\n\t\treturn self is v or (self.__class__ == v.__class__ and self.AEM_comparable() == v.AEM_comparable())","def __eq__(self,*args):\r\n pass","def __eq__(self,*args):\r\n pass","def __eq__(self,*args):\r\n pass","def __eq__(self,*args):\r\n pass","def __eq__(self,*args):\r\n pass","def __eq__(self,*args):\r\n pass","def __eq__(self,*args):\r\n pass","def __eq__(self,*args):\r\n pass","def __eq__(self,*args):\r\n pass","def __eq__(self,*args):\r\n pass","def __eq__(self,*args):\r\n pass","def __eq__(self,*args):\r\n pass","def __eq__(self,*args):\r\n pass","def __eq__(self,*args):\r\n pass","def __eq__(self,*args):\r\n pass","def __eq__(self,*args):\r\n pass","def __eq__(self,*args):\r\n pass","def __eq__(self,*args):\r\n pass","def __eq__(self,*args):\r\n pass","def __eq__(self,*args):\r\n pass","def test_instance_equality(self):\n class EqualityModel(Model):\n pk = columns.Integer(primary_key=True)\n\n m0 = EqualityModel(pk=0)\n m1 = EqualityModel(pk=1)\n\n self.assertEqual(m0, m0)\n self.assertNotEqual(m0, m1)","def test_a(self):\n v1 = versions.Version(version='1.2.3', name='foo')\n v2 = versions.Version(version='2.2.3', name='bar')\n\n self.assertTrue(v1 != v2)\n self.assertTrue(v2 != v1)","def test_b(self):\n v1 = versions.Version(version='1.2.3', name='foo')\n v2 = versions.Version(version='1.2', name='bar')\n\n self.assertFalse(v1 == v2)\n self.assertFalse(v2 == v1)","def test_not_equal(self):\n x = Point(\n lat=24.4,\n lng=23.1,\n author=self.u\n )\n self.assertFalse(self.a == x)\n self.assertTrue(self.a != x)","def are_equal(self, sp1, sp2):\n return sp1 == sp2","def almost_equals(self, other):\n if self.__class__ is other.__class__ and len(self) == len(other):\n for a, b in zip(self, other):\n if not a.almost_equals(b):\n return False\n return True\n else:\n return False","def test_b(self):\n v1 = versions.Version(version='1.2.3', name='foo')\n v2 = versions.Version(version='1.2', name='bar')\n\n self.assertTrue(v1 != v2)\n self.assertTrue(v2 != v1)","def equal(self, other):\n Pok = self == other\n Dok = (self.decomposer.get_params() == other.decomposer.get_params())\n if self.rx is not None:\n if other.rx is not None:\n Rok = (np.allclose(self.rx, other.rx) and\n ((self.cRDF is None and other.cRDF is None) or\n (self.cRDF is not None and\n other.cRDF is not None and\n np.allclose(self.cRDF.df, other.cRDF.df))) and\n ((self.nRDF is None and other.nRDF is None) or\n (self.nRDF is not None and\n other.nRDF is not None and\n np.allclose(self.nRDF.df, other.nRDF.df))))\n else:# pragma: no cover\n Rok = False\n else:\n Rok = True\n if self.ax is not None:\n if other.ax is not None:\n Aok = (np.allclose(self.ax, other.ax) and\n ((self.cADF is None and other.cADF is None) or\n (self.cADF is not None and\n other.cADF is not None and\n np.allclose(self.cADF.df, other.cADF.df))) and\n ((self.nADF is None and other.nADF is None) or\n (self.nADF is not None and\n other.nADF is not None and\n np.allclose(self.nADF.df, other.nADF.df))))\n else:# pragma: no cover\n Aok = False\n else:\n Aok = True\n \n return Pok and Dok and Rok and Aok","def is_equal(self, a, b):\n return a == b","def test_differentClassesInequality(self):\n self.assertTrue(Record(1, 2) != DifferentRecord(1, 2))","def __eq__(self, other: Any) -> bool:\n if not isinstance(other, Transaction):\n return False\n return self.to_solders() == other.to_solders()","def test_instance_equality(self):\r\n class EqualityModel(Model):\r\n pk = columns.Integer(primary_key=True)\r\n\r\n m0 = EqualityModel(pk=0)\r\n m1 = EqualityModel(pk=1)\r\n\r\n self.assertEqual(m0, m0)\r\n self.assertNotEqual(m0, m1)","def __eq__(self, other):\n return isinstance(other, type(self)) and (self.data_store, self.unique_id) == (\n other.data_store,\n other.unique_id,\n )"],"string":"[\n \"def testEquality(self):\\n pass\",\n \"def test_equality(self):\\n self.assertTrue(Record(1, 2) == Record(1, 2))\\n self.assertFalse(Record(1, 2) == Record(1, 3))\\n self.assertFalse(Record(1, 2) == Record(2, 2))\\n self.assertFalse(Record(1, 2) == Record(3, 4))\",\n \"def test_equal_on_equal(self):\\n a = objects.OpaqueObject(self.bytes_a, enums.OpaqueDataType.NONE)\\n b = objects.OpaqueObject(self.bytes_a, enums.OpaqueDataType.NONE)\\n self.assertTrue(a == b)\\n self.assertTrue(b == a)\",\n \"def test_equality(self):\\n self.assertEqual(self._version1, self._version1)\\n self.assertNotEqual(self._version2, self._version1)\\n self.assertEqual(self._version1, PrcsVersion(self._version1))\",\n \"def test_equal_on_equal(self):\\n a = Certificate(\\n certificate_type=self.certificate_type_b,\\n certificate_value=self.certificate_value_b)\\n b = Certificate(\\n certificate_type=self.certificate_type_b,\\n certificate_value=self.certificate_value_b)\\n\\n self.assertTrue(a == b)\\n self.assertTrue(b == a)\",\n \"def is_equivalence(self) -> bool:\",\n \"def test_equal_on_equal(self):\\n a = Digest(\\n hashing_algorithm=self.hashing_algorithm_b,\\n digest_value=self.digest_value_b,\\n key_format_type=self.key_format_type_b)\\n b = Digest(\\n hashing_algorithm=self.hashing_algorithm_b,\\n digest_value=self.digest_value_b,\\n key_format_type=self.key_format_type_b)\\n\\n self.assertTrue(a == b)\\n self.assertTrue(b == a)\",\n \"def test_equal(self):\\n self.assertTrue(self.a == self.a)\\n self.assertFalse(self.a != self.a)\",\n \"def test_unequality(self):\\n self.assertFalse(Record(1, 2) != Record(1, 2))\\n self.assertTrue(Record(1, 2) != Record(1, 3))\\n self.assertTrue(Record(1, 2) != Record(2, 2))\\n self.assertTrue(Record(1, 2) != Record(3, 4))\",\n \"def test_equal_on_equal_and_empty(self):\\n a = Certificate(\\n certificate_type=self.certificate_type_a,\\n certificate_value=self.certificate_value_a)\\n b = Certificate(\\n certificate_type=self.certificate_type_a,\\n certificate_value=self.certificate_value_a)\\n\\n self.assertTrue(a == b)\\n self.assertTrue(b == a)\",\n \"def test_almost_equal(self):\\n x = Point(\\n lat=23.4,\\n lng=23.1,\\n author=self.u\\n )\\n self.assertTrue(self.a == x)\\n self.assertFalse(self.a != x)\",\n \"def test_not_equal_on_equal(self):\\n a = objects.OpaqueObject(self.bytes_a, enums.OpaqueDataType.NONE)\\n b = objects.OpaqueObject(self.bytes_a, enums.OpaqueDataType.NONE)\\n self.assertFalse(a != b)\\n self.assertFalse(b != a)\",\n \"def test_equal_on_equal_and_empty(self):\\n a = Digest()\\n b = Digest()\\n\\n self.assertTrue(a == b)\\n self.assertTrue(b == a)\",\n \"def test_eq_true(self):\\n self.assertTrue(self.instance == Commit(self.instance.sha))\",\n \"def test_equals(self):\\n parameters = [\\n (1, 'a', False),\\n (1, None, False),\\n (1, 2, False),\\n (1, 1, True)\\n ]\\n for pair in parameters:\\n with self.subTest(pair=pair):\\n self.getLogger().info('Next pair %s', pair)\\n _obj1 = Node(pair[0])\\n _obj2 = None if not pair[1] else Node(pair[1])\\n self.assertEqual(_obj1._equals(_obj2), pair[2])\\n _objSelf = Node(1)\\n self.assertTrue(_objSelf._equals(_objSelf))\",\n \"def __eq__(self, other):\\n if not isinstance(other, ApiBuildProvenance):\\n return False\\n\\n return self.__dict__ == other.__dict__\",\n \"def test_not_equal_on_equal(self):\\n a = Certificate(\\n certificate_type=self.certificate_type_b,\\n certificate_value=self.certificate_value_b)\\n b = Certificate(\\n certificate_type=self.certificate_type_b,\\n certificate_value=self.certificate_value_b)\\n\\n self.assertFalse(a != b)\\n self.assertFalse(b != a)\",\n \"def is_equal (self, p):\\n assert isinstance (p, Problem), \\\"Must be comparing two of same type\\\"\\n if self.objects != p.objects:\\n print(\\\"objects\\\")\\n return False\\n\\n if self.init != p.init:\\n #print \\\"init\\\"\\n #print \\\"*self*\\\"\\n #print self.init\\n #print \\\"*p*\\\"\\n #print p.init\\n return False\\n\\n if self.goal != p.goal:\\n print(\\\"goal\\\")\\n return False\\n\\n if not all ([sa == pa for sa, pa in zip (self.actions, p.actions)]):\\n print(\\\"actions\\\")\\n return False\\n\\n if not all ([sp == pp for sp, pp in zip (self.predicates, p.predicates)]):\\n print(\\\"predicates\\\")\\n return False\\n\\n if self.types != p.types or self.parent_types != p.parent_types:\\n print(\\\"types\\\")\\n return False\\n\\n return True\",\n \"def test_not_equal_on_not_equal(self):\\n a = Digest(\\n hashing_algorithm=self.hashing_algorithm_b,\\n digest_value=self.digest_value_b,\\n key_format_type=self.key_format_type_b)\\n b = Digest()\\n c = Digest(\\n hashing_algorithm=self.hashing_algorithm_d,\\n digest_value=self.digest_value_b,\\n key_format_type=self.key_format_type_c)\\n d = Digest(\\n key_format_type=self.key_format_type_c)\\n\\n self.assertTrue(a != b)\\n self.assertTrue(b != a)\\n self.assertTrue(b != c)\\n self.assertTrue(b != d)\",\n \"def test_eqprops_same(self):\\n # Perform diff.\\n df = Differ(key=\\\"name\\\", props=[\\\"same\\\"])\\n d = df.diff(*self.engines)\\n # Check results.\\n self.assertEqual(len(d[Differ.CHANGED]), 0)\",\n \"def test_not_equal_on_equal(self):\\n a = Digest(\\n hashing_algorithm=self.hashing_algorithm_b,\\n digest_value=self.digest_value_b,\\n key_format_type=self.key_format_type_b)\\n b = Digest(\\n hashing_algorithm=self.hashing_algorithm_b,\\n digest_value=self.digest_value_b,\\n key_format_type=self.key_format_type_b)\\n\\n self.assertFalse(a != b)\\n self.assertFalse(b != a)\",\n \"def test_not_equal_on_equal_and_empty(self):\\n a = Certificate(\\n certificate_type=self.certificate_type_a,\\n certificate_value=self.certificate_value_a)\\n b = Certificate(\\n certificate_type=self.certificate_type_a,\\n certificate_value=self.certificate_value_a)\\n\\n self.assertFalse(a != b)\\n self.assertFalse(b != a)\",\n \"def test_equal_on_not_equal_value(self):\\n a = objects.OpaqueObject(self.bytes_a, enums.OpaqueDataType.NONE)\\n b = objects.OpaqueObject(self.bytes_b, enums.OpaqueDataType.NONE)\\n self.assertFalse(a == b)\\n self.assertFalse(b == a)\",\n \"def test_identical(self):\\n write this test!\",\n \"def __eq__(self, other):\\n if not isinstance(other, BaseCommitAllOfSummary):\\n return False\\n\\n return self.__dict__ == other.__dict__\",\n \"def identical_to(self, elem):\\n\\n return (self.n1 == elem.n1) and (self.n2 == elem.n2) and (self.n3 == elem.n3) and (self.n4 == elem.n4)\",\n \"def test_not_equal_on_not_equal(self):\\n a = Certificate(\\n certificate_type=self.certificate_type_a,\\n certificate_value=self.certificate_value_a)\\n b = Certificate(\\n certificate_type=self.certificate_type_b,\\n certificate_value=self.certificate_value_b)\\n\\n self.assertTrue(a != b)\\n self.assertTrue(b != a)\",\n \"def is_equals(self):\\n return self.prop.is_equals()\",\n \"def test_equal_on_not_equal(self):\\n a = Certificate(\\n certificate_type=self.certificate_type_a,\\n certificate_value=self.certificate_value_a)\\n b = Certificate(\\n certificate_type=self.certificate_type_b,\\n certificate_value=self.certificate_value_b)\\n\\n self.assertFalse(a == b)\\n self.assertFalse(b == a)\",\n \"def consistent(self):\\n if self.var1.get_value() is None or self.var2.get_value() is None:\\n return True\\n\\n return self.var1.value != self.var2.value\",\n \"def test_eq(self):\\n dummy = DummyCryptographicObject()\\n self.assertTrue(dummy == dummy)\",\n \"def __eq__(self, other):\\n return self.sha == other.sha\",\n \"def test_not_equal_on_equal_and_empty(self):\\n a = Digest()\\n b = Digest()\\n\\n self.assertFalse(a != b)\\n self.assertFalse(b != a)\",\n \"def test_not_equal_on_not_equal_value(self):\\n a = objects.OpaqueObject(self.bytes_a, enums.OpaqueDataType.NONE)\\n b = objects.OpaqueObject(self.bytes_b, enums.OpaqueDataType.NONE)\\n self.assertTrue(a != b)\\n self.assertTrue(b != a)\",\n \"def __eq__(self, other):\\n if type(self) != type(other):\\n return False\\n s_vars = vars(self)\\n o_vars = vars(other)\\n for v in vars(self):\\n if s_vars[v] != o_vars[v]:\\n print(\\\"unequal property {0}\\\\n\\\".format(v))\\n if v.endswith(\\\"last_count_update_time\\\"):\\n print(\\\"self: {0}\\\\n\\\".format(s_vars[v]))\\n print(\\\"othr: {0}\\\\n\\\".format(o_vars[v]))\\n return False\\n return True\",\n \"def are_equal(self, sp1, sp2):\\n return\",\n \"def are_equal(self, sp1, sp2):\\n return True\",\n \"def identical_to(self, elem):\\n\\n return (self.n1 == elem.n1) and (self.n2 == elem.n2)\",\n \"def __eq__(self, p_object):\\n if any([self[i] != p_object[i] for i in range(9)]):\\n return False\\n return True\",\n \"def __eq__(self, other: 'PairwiseInfo') -> bool:\\n\\n return (\\n self.their_did == other.their_did and\\n self.their_verkey == other.their_verkey and\\n self.my_did == other.my_did and\\n self.my_verkey == other.my_verkey and\\n self.metadata == other.metadata)\",\n \"def almost_equals(self, other, decimal=...): # -> bool:\\n ...\",\n \"def test_is_consistent(self):\\n self.assertTrue(self.phonebook.is_consistent())\\n self.phonebook.add(\\\"Bob\\\", \\\"12345\\\")\\n self.assertTrue(self.phonebook.is_consistent())\\n self.phonebook.add(\\\"Mary\\\", \\\"012345\\\")\\n self.assertTrue(self.phonebook.is_consistent())\\n self.phonebook.add(\\\"Sue\\\", \\\"12345\\\") # identical to Bob\\n self.assertTrue(self.phonebook.is_consistent())\\n self.phonebook.add(\\\"Sue\\\", \\\"123\\\") # prefix of Bob\\n self.assertTrue(self.phonebook.is_consistent())\",\n \"def test_eq(self):\\n assert self.app2 == self.app4\\n assert self.app1 != self.app3\",\n \"def is_equal(self, a, b):\\n return a.X[0] == b.X[0]\",\n \"def test_eq_false(self):\\n self.assertFalse(self.instance == Commit('f3ccd0b70fe758b539c28319735d9a6489c0fb10'))\",\n \"def check(self, expected, debug=True):\\r\\n for v1, v2, go in expected:\\r\\n for gj, oj in go:\\r\\n r1 = is_same_graph(v1, v2, givens=gj, debug=debug)\\r\\n assert r1 == oj\\r\\n r2 = is_same_graph(v2, v1, givens=gj, debug=debug)\\r\\n assert r2 == oj\",\n \"def test_equality_check_against_other_object_doesnt_raise_exception(self):\\n test_object = Vec3(1, 2, 3)\\n self.assertFalse(test_object == Quat(1, 2, 3, 4))\\n self.assertFalse(Quat(1, 2, 3, 4) == test_object)\\n self.assertTrue(test_object != Quat(1, 2, 3, 4))\\n self.assertTrue(Quat(1, 2, 3, 4) != test_object)\",\n \"def _are_assumed_equal(a, b, assumed_equivs):\\n\\n # Are we just assuming that the two are equal?\\n equiv = (id(a), id(b))\\n if equiv in assumed_equivs:\\n return True\\n\\n # If we see these two again assume they're equal. If they're not then the\\n # traversal will detect it.\\n assumed_equivs.add(equiv)\\n return False\",\n \"def is_equal(self, state1, state2):\\n return self._replace_unks(state1) == self._replace_unks(state2)\",\n \"def isIsosceles(self):\\n\\t\\treturn self.a == self.b or self.a == self.c or self.b == self.c\",\n \"def all_equal(sequence):\\n return all(x == sequence[0] for x in sequence)\",\n \"def check_consistency(self):\\n raise NotImplementedError()\",\n \"def e_paralelo(self, other):\\n if (self == other) or (self.normaliza() == other.normaliza()):\\n return True\\n else:\\n return False\",\n \"def test_c(self):\\n v1 = versions.Version(version='1.2.3', name='foo')\\n v2 = versions.Version(version='1.2.3', name='bar')\\n\\n self.assertFalse(v1 != v2)\\n self.assertFalse(v2 != v1)\",\n \"def consistent(self):\\n return self.incore_digest == self.ondisk_digest\",\n \"def relative_eq(self, other):\\n meta_compare = self.compare_meta_version(other)\\n return self.version == other.version and meta_compare == 0\",\n \"def test_hash_equality(self):\\n origin = np.random.randn(3)\\n normal = np.random.randn(3)\\n up_vector = np.random.randn(3)\\n up_vector2 = np.random.randn(3)\\n p1 = shapes_3d.CoordinatePlane(origin, normal, up_vector)\\n p2 = shapes_3d.CoordinatePlane(origin, normal, up_vector)\\n p3 = shapes_3d.CoordinatePlane(origin, normal, up_vector2)\\n \\n self.assertEqual(p1, p2)\\n self.assertNotEqual(p1, p3)\",\n \"def testEquality(self) -> None:\\n r = data_types.Result('test_1', ('win', 'x86'), (1, 10), 'id')\\n other = data_types.Result('test_1', ('win', 'x86'), (1, 10), 'id')\\n self.assertEqual(r, other)\\n\\n other = data_types.Result('test_2', ('win', 'x86'), (1, 10), 'id')\\n self.assertNotEqual(r, other)\\n\\n other = data_types.Result('test_1', ('win', 'arm64'), (1, 10), 'id')\\n self.assertNotEqual(r, other)\\n\\n other = data_types.Result('test_1', ('win', 'x86'), (2, 11), 'id')\\n self.assertNotEqual(r, other)\\n\\n other = data_types.Result('test_1', ('win', 'x86'), (1, 10), 'id_2')\\n self.assertNotEqual(r, other)\\n\\n other = None\\n self.assertNotEqual(r, other)\",\n \"def test_c(self):\\n v1 = versions.Version(version='1.2.3', name='foo')\\n v2 = versions.Version(version='2.2.3', name='bar')\\n\\n self.assertFalse(v1 == v2)\\n self.assertFalse(v2 == v1)\",\n \"def test_equals(self):\\n measurement_1 = Measurement(self.metric())\\n measurement_2 = Measurement(self.metric())\\n self.assertTrue(measurement_1.equals(measurement_2))\",\n \"def __eq__(self, other):\\n return self.properties == other.properties\",\n \"def test_eq(self):\\n st_1 = State(substance=\\\"water\\\", T=Q_(400.0, \\\"K\\\"), p=Q_(101325.0, \\\"Pa\\\"))\\n st_2 = State(substance=\\\"water\\\", T=Q_(400.0, \\\"K\\\"), p=Q_(101325.0, \\\"Pa\\\"))\\n assert st_1 == st_2\",\n \"def check_consistency(self, es):\",\n \"def test_verify_equivalency(self):\\r\\n\\r\\n fasta_data = {'seq1': 'AATC', 'seq2': 'GGAT'}\\r\\n\\r\\n qual_data = {'seq1': [\\\"40\\\", \\\"36\\\", \\\"35\\\", \\\"18\\\"],\\r\\n 'seq2': [\\\"39\\\", \\\"18\\\", \\\"22\\\", \\\"23\\\"]}\\r\\n\\r\\n # Should not raise any errors\\r\\n verify_equivalency(fasta_data, qual_data)\\r\\n\\r\\n # Make number of sequences unequal, and should raise error.\\r\\n fasta_data = {'seq1': 'AATC', 'seq2': 'GGAT', 'seq3': 'ACTG'}\\r\\n\\r\\n qual_data = {'seq1': [\\\"40\\\", \\\"36\\\", \\\"35\\\", \\\"18\\\"],\\r\\n 'seq2': [\\\"39\\\", \\\"18\\\", \\\"22\\\", \\\"23\\\"]}\\r\\n\\r\\n self.assertRaises(\\r\\n ValueError,\\r\\n verify_equivalency,\\r\\n fasta_data,\\r\\n qual_data)\\r\\n\\r\\n # Should raise error if lens of values different\\r\\n fasta_data = {'seq1': 'AATC', 'seq2': 'GGAT'}\\r\\n\\r\\n qual_data = {'seq1': [\\\"50\\\", \\\"40\\\", \\\"36\\\", \\\"35\\\", \\\"18\\\"],\\r\\n 'seq2': [\\\"39\\\", \\\"18\\\", \\\"22\\\", \\\"23\\\"]}\\r\\n\\r\\n self.assertRaises(\\r\\n ValueError,\\r\\n verify_equivalency,\\r\\n fasta_data,\\r\\n qual_data)\",\n \"def is_equal(self, codon_pair: 'CodonPair') -> bool:\\n return self.sequence == codon_pair.sequence\",\n \"def check_pairs(self, all_pr, curr):\\n flag = True\\n for pair_ox in all_pr:\\n if (curr[0] == pair_ox or curr[1] == pair_ox):\\n flag = False\\n return flag\",\n \"def __eq__(self, other):\\n if type(other) == type(self):\\n if other.triple.relation == self.triple.relation:\\n if (other.triple.concept1 == self.triple.concept1 \\n and other.triple.concept2 == self.triple.concept2):\\n return True\\n return False\",\n \"def __eq__(self, v):\\n\\t\\treturn self is v or (self.__class__ == v.__class__ and self.AEM_comparable() == v.AEM_comparable())\",\n \"def __eq__(self,*args):\\r\\n pass\",\n \"def __eq__(self,*args):\\r\\n pass\",\n \"def __eq__(self,*args):\\r\\n pass\",\n \"def __eq__(self,*args):\\r\\n pass\",\n \"def __eq__(self,*args):\\r\\n pass\",\n \"def __eq__(self,*args):\\r\\n pass\",\n \"def __eq__(self,*args):\\r\\n pass\",\n \"def __eq__(self,*args):\\r\\n pass\",\n \"def __eq__(self,*args):\\r\\n pass\",\n \"def __eq__(self,*args):\\r\\n pass\",\n \"def __eq__(self,*args):\\r\\n pass\",\n \"def __eq__(self,*args):\\r\\n pass\",\n \"def __eq__(self,*args):\\r\\n pass\",\n \"def __eq__(self,*args):\\r\\n pass\",\n \"def __eq__(self,*args):\\r\\n pass\",\n \"def __eq__(self,*args):\\r\\n pass\",\n \"def __eq__(self,*args):\\r\\n pass\",\n \"def __eq__(self,*args):\\r\\n pass\",\n \"def __eq__(self,*args):\\r\\n pass\",\n \"def __eq__(self,*args):\\r\\n pass\",\n \"def test_instance_equality(self):\\n class EqualityModel(Model):\\n pk = columns.Integer(primary_key=True)\\n\\n m0 = EqualityModel(pk=0)\\n m1 = EqualityModel(pk=1)\\n\\n self.assertEqual(m0, m0)\\n self.assertNotEqual(m0, m1)\",\n \"def test_a(self):\\n v1 = versions.Version(version='1.2.3', name='foo')\\n v2 = versions.Version(version='2.2.3', name='bar')\\n\\n self.assertTrue(v1 != v2)\\n self.assertTrue(v2 != v1)\",\n \"def test_b(self):\\n v1 = versions.Version(version='1.2.3', name='foo')\\n v2 = versions.Version(version='1.2', name='bar')\\n\\n self.assertFalse(v1 == v2)\\n self.assertFalse(v2 == v1)\",\n \"def test_not_equal(self):\\n x = Point(\\n lat=24.4,\\n lng=23.1,\\n author=self.u\\n )\\n self.assertFalse(self.a == x)\\n self.assertTrue(self.a != x)\",\n \"def are_equal(self, sp1, sp2):\\n return sp1 == sp2\",\n \"def almost_equals(self, other):\\n if self.__class__ is other.__class__ and len(self) == len(other):\\n for a, b in zip(self, other):\\n if not a.almost_equals(b):\\n return False\\n return True\\n else:\\n return False\",\n \"def test_b(self):\\n v1 = versions.Version(version='1.2.3', name='foo')\\n v2 = versions.Version(version='1.2', name='bar')\\n\\n self.assertTrue(v1 != v2)\\n self.assertTrue(v2 != v1)\",\n \"def equal(self, other):\\n Pok = self == other\\n Dok = (self.decomposer.get_params() == other.decomposer.get_params())\\n if self.rx is not None:\\n if other.rx is not None:\\n Rok = (np.allclose(self.rx, other.rx) and\\n ((self.cRDF is None and other.cRDF is None) or\\n (self.cRDF is not None and\\n other.cRDF is not None and\\n np.allclose(self.cRDF.df, other.cRDF.df))) and\\n ((self.nRDF is None and other.nRDF is None) or\\n (self.nRDF is not None and\\n other.nRDF is not None and\\n np.allclose(self.nRDF.df, other.nRDF.df))))\\n else:# pragma: no cover\\n Rok = False\\n else:\\n Rok = True\\n if self.ax is not None:\\n if other.ax is not None:\\n Aok = (np.allclose(self.ax, other.ax) and\\n ((self.cADF is None and other.cADF is None) or\\n (self.cADF is not None and\\n other.cADF is not None and\\n np.allclose(self.cADF.df, other.cADF.df))) and\\n ((self.nADF is None and other.nADF is None) or\\n (self.nADF is not None and\\n other.nADF is not None and\\n np.allclose(self.nADF.df, other.nADF.df))))\\n else:# pragma: no cover\\n Aok = False\\n else:\\n Aok = True\\n \\n return Pok and Dok and Rok and Aok\",\n \"def is_equal(self, a, b):\\n return a == b\",\n \"def test_differentClassesInequality(self):\\n self.assertTrue(Record(1, 2) != DifferentRecord(1, 2))\",\n \"def __eq__(self, other: Any) -> bool:\\n if not isinstance(other, Transaction):\\n return False\\n return self.to_solders() == other.to_solders()\",\n \"def test_instance_equality(self):\\r\\n class EqualityModel(Model):\\r\\n pk = columns.Integer(primary_key=True)\\r\\n\\r\\n m0 = EqualityModel(pk=0)\\r\\n m1 = EqualityModel(pk=1)\\r\\n\\r\\n self.assertEqual(m0, m0)\\r\\n self.assertNotEqual(m0, m1)\",\n \"def __eq__(self, other):\\n return isinstance(other, type(self)) and (self.data_store, self.unique_id) == (\\n other.data_store,\\n other.unique_id,\\n )\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.7151801","0.67575616","0.6750969","0.6594036","0.65184104","0.64447683","0.64215165","0.6413873","0.63874745","0.6368648","0.636855","0.6347611","0.63152367","0.63029677","0.6300809","0.6295113","0.6253116","0.62390214","0.6235458","0.62001276","0.6181665","0.6176305","0.6160885","0.6159017","0.6150097","0.61500055","0.6141949","0.61402285","0.612671","0.6124643","0.61233586","0.61207515","0.6114137","0.61133605","0.60806364","0.6080514","0.6077746","0.6073963","0.6068947","0.60664177","0.6058046","0.60559297","0.60539955","0.60531914","0.60515785","0.60511607","0.6044366","0.60392636","0.60262984","0.60252416","0.6015308","0.59932154","0.5966131","0.5958621","0.59537685","0.59502554","0.5949241","0.59350246","0.59309244","0.59134257","0.59013724","0.58948404","0.58946","0.5879858","0.5879232","0.5862058","0.585745","0.5856688","0.58559424","0.58559424","0.58559424","0.58559424","0.58559424","0.58559424","0.58559424","0.58559424","0.58559424","0.58559424","0.58559424","0.58559424","0.58559424","0.58559424","0.58559424","0.58559424","0.58559424","0.58559424","0.58559424","0.58559424","0.5854482","0.5850174","0.5849262","0.58475846","0.58473736","0.5839652","0.5838381","0.58381885","0.5837841","0.5835102","0.58275974","0.5825256","0.5822511"],"string":"[\n \"0.7151801\",\n \"0.67575616\",\n \"0.6750969\",\n \"0.6594036\",\n \"0.65184104\",\n \"0.64447683\",\n \"0.64215165\",\n \"0.6413873\",\n \"0.63874745\",\n \"0.6368648\",\n \"0.636855\",\n \"0.6347611\",\n \"0.63152367\",\n \"0.63029677\",\n \"0.6300809\",\n \"0.6295113\",\n \"0.6253116\",\n \"0.62390214\",\n \"0.6235458\",\n \"0.62001276\",\n \"0.6181665\",\n \"0.6176305\",\n \"0.6160885\",\n \"0.6159017\",\n \"0.6150097\",\n \"0.61500055\",\n \"0.6141949\",\n \"0.61402285\",\n \"0.612671\",\n \"0.6124643\",\n \"0.61233586\",\n \"0.61207515\",\n \"0.6114137\",\n \"0.61133605\",\n \"0.60806364\",\n \"0.6080514\",\n \"0.6077746\",\n \"0.6073963\",\n \"0.6068947\",\n \"0.60664177\",\n \"0.6058046\",\n \"0.60559297\",\n \"0.60539955\",\n \"0.60531914\",\n \"0.60515785\",\n \"0.60511607\",\n \"0.6044366\",\n \"0.60392636\",\n \"0.60262984\",\n \"0.60252416\",\n \"0.6015308\",\n \"0.59932154\",\n \"0.5966131\",\n \"0.5958621\",\n \"0.59537685\",\n \"0.59502554\",\n \"0.5949241\",\n \"0.59350246\",\n \"0.59309244\",\n \"0.59134257\",\n \"0.59013724\",\n \"0.58948404\",\n \"0.58946\",\n \"0.5879858\",\n \"0.5879232\",\n \"0.5862058\",\n \"0.585745\",\n \"0.5856688\",\n \"0.58559424\",\n \"0.58559424\",\n \"0.58559424\",\n \"0.58559424\",\n \"0.58559424\",\n \"0.58559424\",\n \"0.58559424\",\n \"0.58559424\",\n \"0.58559424\",\n \"0.58559424\",\n \"0.58559424\",\n \"0.58559424\",\n \"0.58559424\",\n \"0.58559424\",\n \"0.58559424\",\n \"0.58559424\",\n \"0.58559424\",\n \"0.58559424\",\n \"0.58559424\",\n \"0.58559424\",\n \"0.5854482\",\n \"0.5850174\",\n \"0.5849262\",\n \"0.58475846\",\n \"0.58473736\",\n \"0.5839652\",\n \"0.5838381\",\n \"0.58381885\",\n \"0.5837841\",\n \"0.5835102\",\n \"0.58275974\",\n \"0.5825256\",\n \"0.5822511\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":89899,"cells":{"query":{"kind":"string","value":"Number of tree encounters when slope is (3,1)"},"document":{"kind":"string","value":"def solve_part1(input):\n\n def is_tree(cell):\n return 1 if cell == \"#\" else 0\n\n def get_cell(row, pos):\n return row[pos % len(row)]\n\n pos = 0\n trees = 0\n for row in input:\n trees += is_tree(get_cell(row, pos))\n pos += 3\n return trees"},"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 leaf_count(t: Tree) -> int:\n if t.children == []:\n return 1\n else:\n return sum([leaf_count(child) for child in t.children])","def leaf_count(self) -> int:\n if self.children == []:\n return 1\n else:\n return sum([x.leaf_count() for x in self.children])","def leaf_count(T):\n if T.is_leaf:\n return 1\n else:\n# s = 0\n# for child in T:\n# s += leaf_count(child)\n# return s\n return reduce(add, map(leaf_count, T))","def nbr_nodes(tree_depth):\n return 2**(tree_depth+1)-1","def numNodes(T):\r\n n = 1\r\n if T.isLeaf:\r\n return n\r\n for i in range(len(T.child)):\r\n n += numNodes(T.child[i])\r\n return n","def solve_for(m: Map, slope: Coordinates) -> int:\n n_trees = h = w = 0\n h_step, w_step = slope\n\n while h < m.max_h:\n n_trees += m[h, w] == \"#\"\n h += h_step\n w += w_step\n\n return n_trees","def count_trees(matrix, dx, dy):\n\n # We begin in the upper left corner\n x = 0\n y = 0\n count = 0\n\n # We continue until y > [height of matrix]\n while(y < len(matrix)):\n if matrix[y][x] == '#':\n count += 1\n\n # X is special since it needs to be wrapped around\n x = (x + dx) % len(matrix[0])\n y += dy\n\n return count","def leaf_count(T):\n if T.is_leaf:\n return 1\n else:\n s = 0\n for child in T:\n s += leaf_count(child)\n return s\n # Can you put the else clause in one line instead?\n return functools.reduce(operator.add, map(leaf_count, T), 0)","def count_leaf(self):\n if self.is_empty():\n return 0\n elif self.is_leaf():\n return 1\n else:\n if self.get_left():\n if self.get_right():\n return 0 + self.get_left().count_leaf() + self.get_right().count_leaf()\n else:\n return 0 + self.get_left().count_leaf()\n else:\n return 0 + self.get_right().count_leaf()","def count_nodes(self):\n if self.is_empty():\n return 0\n elif self.is_leaf():\n return 1\n else:\n if self.get_left():\n if self.get_right():\n return 1 + self.get_left().count_nodes() + self.get_right().count_nodes()\n else:\n return 1 + self.get_left().count_nodes()\n else:\n return 1 + self.get_right().count_nodes()","def get_n_leaves(clf):\n leaves = clf.tree_.children_left == -1\n leaves = np.arange(0,clf.tree_.node_count)[leaves]\n return len(leaves)","def n_trees(self):\n return len(self.data_kd)","def leafScore(self) :\n return 0","def counterCompute(line, nodes, rowname):\n counter = 0\n if nodes != 1: #node has parents \n parent = line[1: nodes] \n for par in parent:\n if (\"Not \" + par) in rowname: #one parent is \"Not par\"\n counter = counter + math.pow(2, nodes - 2 - parent.index(par))\n return counter","def _children_count(self):\n cnt = 0\n if self.left:\n cnt += 1\n if self.right:\n cnt += 1\n return cnt","def height(T):\r\n if T.isLeaf:\r\n return 0\r\n return 1 + height(T.child[0])","def num_leaves(tree):\n return ((tree.n_node_samples > 0) & (tree.feature == INVALID_VALUE)).sum()","def count_level(self):\r\n count = 0\r\n\r\n for i in range(0, len(self.matrix)):\r\n for j in range(0,len(self.matrix[i])):\r\n if self.matrix[i][j] == \"0\":\r\n count += 1\r\n\r\n # We substract 1 to count level from 0\r\n return count - 1","def num_children(self, n):\n counter = 0\n if self.left(n):\n counter += 1\n if self.right(n):\n counter += 1\n return counter","def num_depth(self):\n if self._index == 0:\n return len(self._ratios)\n else:\n return len(self._sizes) + len(self._ratios) - 1","def depth(self) -> int:\n if len(self.children) == 0:\n return 0\n\n # Regresar la altura máxima de sus hijos más uno\n return max([n.depth() for n in self.children]) + 1","def count_taxa_tree(tree_nxobj):\n\tnode_count = 0 #number of taxa in the tree\n\tfor node in tree_nxobj.preorder_node_iter():\n\t\tnode_count += 1\n\n\treturn node_count","def _tree_depth(self):\n return self._flat_data._tree_depth()","def branchLength(self,branch):\n\t\t\n\t\tlength = 0\n\t\tfor p,point in enumerate(branch[:-1]):\n\t\t\tlength+=self.eucdist3d(branch[p],branch[p+1])\n\t\t\n\t\treturn(length)","def depth_zero_finder(self, node):\n for depth, prev_node in self.m_stack.lineage_with_level():\n for typ in (markers.lower, markers.upper, markers.ints,\n markers.roman):\n if prev_node.label[-1] in typ and node.label[-1] in typ:\n typ = list(typ)\n prev_idx = typ.index(prev_node.label[-1])\n current_idx = typ.index(node.label[-1])\n if current_idx == prev_idx + 1:\n return depth\n return self.depth + 1","def _height1(self): #works but n^2 time\n return max(self.depth(p) for p in self.positions() if self.is_leaf(p))","def _numconditions(self, node_p):\n node_p = self.getnodenamed(node_p) # Verify pointer.\n parents = self.getnodeparents(node_p) # nl_p\n nparents = self.lengthnodelist(parents) # integer\n # Get the number of states in each parent node, multiply them\n npstates = 1\n for idx in range(nparents):\n node_i = self.nthnode(parents, idx)\n nstates_i = self.getnodenumberstates(node_i)\n npstates *= nstates_i\n\n return npstates","def depth(self):\n if self.size == 0:\n return 0\n return int(math.log(self.size, 2)) + 1","def num_actual_nodes(tree):\n return (tree.n_node_samples > 0).sum()","def complexity(self):\n n = 0\n ctx = self\n while ctx is not None:\n n += 1\n ctx = ctx.parent()\n return n","def get_tree_length(x):\n length = list(self.__plan_graph.objects(subject=x, predicate=AGORA.length)).pop()\n return length","def dfs(node):\n nonlocal ans \n if not node: return 0\n lx, rx = dfs(node.left), dfs(node.right) \n if not node.left or node.left.val != node.val: lx = 0\n if not node.right or node.right.val != node.val: rx = 0 \n ans = max(ans, 1 + lx + rx)\n return 1 + max(lx, rx)","def countPanelTrajectoryExpressions(self):\n nbr = 0\n for e in self.children:\n nbr += e.countPanelTrajectoryExpressions()\n return nbr","def num_trees(self):\n return self._ll_tree_sequence.get_num_trees()","def depth(self, p):\n if self.is_root(p):\n return 0\n else:\n return 1 + self.depth(self.parent(p))","def node_count(self):\n if self.value:\n cnt = 0\n else:\n left_cnt = self.left.node_count()\n right_cnt = self.right.node_count()\n cnt = 1 + left_cnt + right_cnt\n return cnt","def num_depth(self):\n return len(self._sizes) + len(self._ratios) - 1","def depth(self):\n return 0","def countNodes(epr):\n result = 1\n argLst = epr.args\n for arg in argLst:\n result += countNodes(arg)\n return result","def test_depth(known_bst):\n assert known_bst[0].depth() == 3","def get_tree_size(self, node):\n\n # If the tree has not been created yet.\n if node == None:\n return 0\n n_nodes = 1\n for child in node.children:\n n_nodes += self.get_tree_size(node.children[child])\n return n_nodes","def count_gold(pyramid):\n\n #replace this for solution\n return 0","def _calculate_points(tree):\n leafs = []\n points = 0\n\n def order(tree):\n if tree is not None:\n if tree.get_left_child() is not None:\n order(tree.get_left_child())\n elif tree.get_right_child() is not None:\n order(tree.get_right_child())\n else:\n leafs.append(tree.key)\n\n order(tree)\n\n for board in leafs:\n if board.is_winner()[0]:\n if board.is_winner()[1] == 5:\n points -= 1\n else:\n points += 1\n\n return points","def CountPred(self, node):\n if node.children: \n res = 0;\n for child in node.children:\n res += self.CountPred(child);\n return res;\n else:\n if node.tag.startswith(\"V\"):\n self.vv += 1;\n if len(node.arguments) != 0:\n self.vpred += 1;\n return 1;\n else:\n return 0;","def count_leafs(self):\n\n def walk(block, count=0):\n # This is a non-ope leaf, count it\n if block.is_leaf and not block.is_open:\n count += 1\n\n # This is a non-leaf block. Recurse\n if not block.is_leaf:\n for child in block.blocks.values():\n count += walk(child)\n\n return count\n\n # Recursive walk and count\n return walk(self)","def num_of_children_steps(self):\n total = 0\n for child in self.children:\n total += child.total_steps\n return total","def _height1(self): # works, but O(n^2) worst-case time\n return max(self.depth(p) for p in self.positions() if self.is_leaf(p))","def numNodes(self):\n res = 0\n for n in self.iternodes():\n res += 1\n return res","def _get_level(self, node):\n level = 0\n while node.parent:\n node = node.parent\n level += 1\n return level","def numPaths(self):\n if self.numpaths > -1:\n return self.numpaths\n\n if self.jolt == 0:\n return 1\n\n paths = 0\n for parent in self.parents:\n paths += parent.numPaths()\n \n return paths","def test_findtotalConsecutive(self):\n treesList = [1, 2, 5, 3]\n result = findtotalConsecutive(treesList, 2, 2)\n self.assertEqual(result, 8)","def height(t: Tree):\n if len(t.children) == 0:\n return 1\n else:\n return 1 + max([height(c) for c in t.children])","def depth(self):\n L, R = 0,0\n if self.left:\n L = self.left.depth()\n if self.right:\n R = self.right.depth()\n\n return 1 + max(L, R)","def dfs(node):\n nonlocal ans\n if not node: return []\n if node.left is node.right is None: return [0]\n left,right = dfs(node.left), dfs(node.right)\n ans += sum(2 + x + y <= distance for x in left for y in right)\n return [1 + x for x in left + right]","def depht(self, p):\n if self.is_root(p):\n return 0\n else:\n return 1 + self.depht(self.parents(p))","def test_ternary_tree_of_height_3_with_deepest_path_in_middle(self):\n parents = [ -1, 0, 0, 0, 2 ]\n self.init(parents)\n self.assertEqual(3, self.method_under_test())","def ask_depth(orders: pandas.DataFrame) -> int:\n return len(asks(orders))","def min_depth(t):\n if is_leaf(t):\n return 0\n h = float('inf')\n for b in branches(t):\n # Still works fine!\n h = min(h, 1 + min_depth(b))\n return h","def fn(node):\n if not node: return 0\n if not node.left or not node.right: return 1 + fn(node.left) + fn(node.right)\n return 1 + min(fn(node.left), fn(node.right))","def depth(self, p):\n if self.is root(p):\n return 0\n else:\n return 1 + self.depth(self.parent(p))","def complexity(self, mode='#nodes'):\n if mode == '#nodes':\n return len(self.nodes)","def _number_of_intervals(self):\n return self._number_of_levels - 1","def _calc_tree_depth(refinement_tree):\n if not refinement_tree:\n return 0\n\n depth = 0\n for k, v in refinement_tree.items():\n d = _calc_tree_depth(v)\n if d > depth:\n depth = d\n\n return 1 + depth","def test_ternary_tree_of_height_3_with_deepest_path_on_left(self):\n parents = [ -1, 0, 0, 0, 1 ]\n self.init(parents)\n self.assertEqual(3, self.method_under_test())","def depth(self):\n left_depth = self.left.depth() if self.left is not None else 0\n right_depth = self.right.depth() if self.right is not None else 0\n return max(left_depth, right_depth) + 1","def helper(root):\n if not root or not root.children: return 0\n \n if len(root.children) == 1:\n depth = 1 + helper(root.children[0])\n self.diameter = max(self.diameter, depth)\n return depth\n \n else:\n depths = [1+helper(child) for child in root.children]\n max1, max2 = 0, 0\n for depth in depths:\n if depth >= max1:\n max1, max2 = depth, max1\n elif depth < max1 and depth > max2:\n max2 = depth\n self.diameter = max(self.diameter, max1+max2)\n return max1","def test_balanced_tree_with_3_nodes_has_depth_one(balanced_3_nodes):\n assert balanced_3_nodes.depth() == 1","def dfs(self, node):\n if not node:\n return 0\n\n l = self.dfs(node.left)\n r = self.dfs(node.right)\n self.ret = max(self.ret, l + 1 + r - 1) # path length is the #nodes - 1\n return max(l, r) + 1","def numIslands(grid):\n # count to store each new island found\n count = 0\n # If the grid is empty, return 0\n if not grid:\n return count\n\n y_max = len(grid)\n x_max = len(grid[0])\n \n for i in range(len(grid)):\n for j in range(len(grid[0])):\n if grid[i][j] == '1':\n dfs(grid, i, j)\n count += 1\n return count","def count_height(self, node: TreeNode) -> int:\n if not node.left or not node.right:\n if node.left == node.right:\n return 1\n if node.left and not node.right:\n return node.left.height + 1\n return node.right.height + 1\n return max(node.left.height, node.right.height) + 1","def children_num(self,p):\n counter = 0\n for child in self.children(p):\n counter += 1\n return counter","def get_tree_depth(attributes):\n depth = 0\n for attribute in attributes:\n if attribute == -1:\n depth = depth + 1\n return depth","def size(self):\n return self.variables.end_of_tree - 1","def dfs(self, root: TreeNode) -> int:\n if not root:\n return 0\n\n def dfs(node):\n if not node:\n return float('inf')\n if not node.left and not node.right:\n return 1\n return min(dfs(node.left), dfs(node.right)) + 1\n\n return dfs(root)","def depth(self):\n ch = self.children\n return 0 if not ch else 1 + max([c.depth for c in ch])","def number_of_new_components(self):\n t_low = self.lower_binary_tree().to_tilting()\n t_up = self.upper_binary_tree().to_tilting()\n return len([p for p in t_low if p in t_up])","def __len__(self):\n return len(self.subtrees())","def leaf_switch_count(self):\n leafs = GetSwitchDetails().get_leaf_switch_ip()\n totalLeafs = len(leafs)\n return totalLeafs","def fn(node):\n if not node: return 0 \n left, right = fn(node.left), fn(node.right)\n if node.val == x: \n cnt[0], cnt[1] = left, right\n return 1 + left + right","def Depth(self):\n return self.path.count('.') + (self.parent is not None)","def depth(self):\n result = 0\n if self.val is None:\n return result\n return max(self.left.depth(), self.right.depth()) + 1","def count_nodes(self):\n if self.children is None:\n return 0\n\n total_count = 0\n for child in self.children:\n if child is None:\n return 0\n child_count = child.count_nodes()\n total_count = total_count + child_count\n\n return total_count+1","def depth(self):\n if self.children is None:\n return 1\n\n max_depth = 0\n for child in self.children:\n if child is None:\n return 1\n child_depth = child.depth()\n if child_depth > max_depth:\n max_depth = child_depth\n\n return max_depth+1","def traverse_map(map, x_step, y_step):\n trees_hit = 0\n map_depth = len(map)\n y_steps = range(0,map_depth,y_step)\n for j,step in enumerate(y_steps):\n trees_hit += 1 if tree_in_path(map[step],j*x_step) else 0\n return trees_hit","def number_of_trees_of_order(n):\n if n < 2:\n return n\n result = 0\n for k in range(1, n):\n result += k * number_of_trees_of_order(k) * _s(n-1, k)\n return result // (n - 1)","def count_nodes(self):\n\t\treturn self.__count_nodes(self)","def depth(state):\n current_depth = 0\n for i in range(0, len(state.board)):\n for j in range(0, len(state.board[0])):\n if state.board[i][j] == '_':\n current_depth += 1\n return current_depth","def count_leaves(self) -> int:\n # binary search tree == empty\n if self.root is None:\n return 0\n\n #recursive helper function +=count total leaf\n return self.count_leaves_helper(self.root)","def _height1(self): # works, but O(n^2) worst-case time\n return max(self.depth(p) for p in self.positions() if self.is_leaf(p))","def height_helper(self, node: object) -> int:\n #current node == a leaf\n if self.is_leaf(node):\n return 0\n\n #current node == a single child\n if node.left is not None and node.right is None:\n return 1 + self.height_helper(node.left)\n if node.left is None and node.right is not None:\n return 1 + self.height_helper(node.right)\n\n #node ==2 child leaf\n if self.height_helper(node.left) > self.height_helper(node.right):\n return 1 + self.height_helper(node.left)\n else:\n return 1 + self.height_helper(node.right)","def test_findtotalConsecutive(self):\n treesList = [1, 2, 5, 3]\n result = findtotalConsecutive(treesList, 2, 4)\n self.assertEqual(result, -1)","def get_nodes_pixel_count(self):\n sum_count = self.pixel_count\n for i in range(8):\n node = self.children[i]\n if node:\n sum_count += node.pixel_count\n return sum_count","def depth(self, p):\n if self.is_root(p):\n return 0\n else:\n return 1 + self.depth(self.parent(p))","def depth(self, p):\n if self.is_root(p):\n return 0\n else:\n return 1 + self.depth(self.parent(p))","def depth(self, p):\n if self.is_root(p):\n return 0\n else:\n return 1 + self.depth(self.parent(p))","def depth(self, node):\n\n if not node:\n return 0\n else:\n l_depth = self.depth(node.left)\n r_depth = self.depth(node.right)\n\n if l_depth > r_depth:\n return l_depth + 1\n else:\n return r_depth + 1","def depth(self):\n raise NotImplementedError()","def getArea(rob):\r\n def dfs(visit, i, j):\r\n visit.add((i, j))\r\n for k in range(4):\r\n newi, newj = i + x[k], j + y[k]\r\n if (newi, newj) in visit or not rob.move(k):\r\n continue\r\n dfs(visit, newi, newj)\r\n rob.move((k + 2) % 4)\r\n visit = set()\r\n dfs(visit, 0, 0)\r\n return len(visit)","def cyclomaticComplexity (self):\n self.tarjan()\n return len(self.__edges) - len(self.__nodes) + 2 * len(self.__scc)","def depth(x):\n return max(int(x * depth_multiplier), 8)","def depth(self,p):\n return 0 if self.is_root(p) else 1 + self.depth(self.parent(p))"],"string":"[\n \"def leaf_count(t: Tree) -> int:\\n if t.children == []:\\n return 1\\n else:\\n return sum([leaf_count(child) for child in t.children])\",\n \"def leaf_count(self) -> int:\\n if self.children == []:\\n return 1\\n else:\\n return sum([x.leaf_count() for x in self.children])\",\n \"def leaf_count(T):\\n if T.is_leaf:\\n return 1\\n else:\\n# s = 0\\n# for child in T:\\n# s += leaf_count(child)\\n# return s\\n return reduce(add, map(leaf_count, T))\",\n \"def nbr_nodes(tree_depth):\\n return 2**(tree_depth+1)-1\",\n \"def numNodes(T):\\r\\n n = 1\\r\\n if T.isLeaf:\\r\\n return n\\r\\n for i in range(len(T.child)):\\r\\n n += numNodes(T.child[i])\\r\\n return n\",\n \"def solve_for(m: Map, slope: Coordinates) -> int:\\n n_trees = h = w = 0\\n h_step, w_step = slope\\n\\n while h < m.max_h:\\n n_trees += m[h, w] == \\\"#\\\"\\n h += h_step\\n w += w_step\\n\\n return n_trees\",\n \"def count_trees(matrix, dx, dy):\\n\\n # We begin in the upper left corner\\n x = 0\\n y = 0\\n count = 0\\n\\n # We continue until y > [height of matrix]\\n while(y < len(matrix)):\\n if matrix[y][x] == '#':\\n count += 1\\n\\n # X is special since it needs to be wrapped around\\n x = (x + dx) % len(matrix[0])\\n y += dy\\n\\n return count\",\n \"def leaf_count(T):\\n if T.is_leaf:\\n return 1\\n else:\\n s = 0\\n for child in T:\\n s += leaf_count(child)\\n return s\\n # Can you put the else clause in one line instead?\\n return functools.reduce(operator.add, map(leaf_count, T), 0)\",\n \"def count_leaf(self):\\n if self.is_empty():\\n return 0\\n elif self.is_leaf():\\n return 1\\n else:\\n if self.get_left():\\n if self.get_right():\\n return 0 + self.get_left().count_leaf() + self.get_right().count_leaf()\\n else:\\n return 0 + self.get_left().count_leaf()\\n else:\\n return 0 + self.get_right().count_leaf()\",\n \"def count_nodes(self):\\n if self.is_empty():\\n return 0\\n elif self.is_leaf():\\n return 1\\n else:\\n if self.get_left():\\n if self.get_right():\\n return 1 + self.get_left().count_nodes() + self.get_right().count_nodes()\\n else:\\n return 1 + self.get_left().count_nodes()\\n else:\\n return 1 + self.get_right().count_nodes()\",\n \"def get_n_leaves(clf):\\n leaves = clf.tree_.children_left == -1\\n leaves = np.arange(0,clf.tree_.node_count)[leaves]\\n return len(leaves)\",\n \"def n_trees(self):\\n return len(self.data_kd)\",\n \"def leafScore(self) :\\n return 0\",\n \"def counterCompute(line, nodes, rowname):\\n counter = 0\\n if nodes != 1: #node has parents \\n parent = line[1: nodes] \\n for par in parent:\\n if (\\\"Not \\\" + par) in rowname: #one parent is \\\"Not par\\\"\\n counter = counter + math.pow(2, nodes - 2 - parent.index(par))\\n return counter\",\n \"def _children_count(self):\\n cnt = 0\\n if self.left:\\n cnt += 1\\n if self.right:\\n cnt += 1\\n return cnt\",\n \"def height(T):\\r\\n if T.isLeaf:\\r\\n return 0\\r\\n return 1 + height(T.child[0])\",\n \"def num_leaves(tree):\\n return ((tree.n_node_samples > 0) & (tree.feature == INVALID_VALUE)).sum()\",\n \"def count_level(self):\\r\\n count = 0\\r\\n\\r\\n for i in range(0, len(self.matrix)):\\r\\n for j in range(0,len(self.matrix[i])):\\r\\n if self.matrix[i][j] == \\\"0\\\":\\r\\n count += 1\\r\\n\\r\\n # We substract 1 to count level from 0\\r\\n return count - 1\",\n \"def num_children(self, n):\\n counter = 0\\n if self.left(n):\\n counter += 1\\n if self.right(n):\\n counter += 1\\n return counter\",\n \"def num_depth(self):\\n if self._index == 0:\\n return len(self._ratios)\\n else:\\n return len(self._sizes) + len(self._ratios) - 1\",\n \"def depth(self) -> int:\\n if len(self.children) == 0:\\n return 0\\n\\n # Regresar la altura máxima de sus hijos más uno\\n return max([n.depth() for n in self.children]) + 1\",\n \"def count_taxa_tree(tree_nxobj):\\n\\tnode_count = 0 #number of taxa in the tree\\n\\tfor node in tree_nxobj.preorder_node_iter():\\n\\t\\tnode_count += 1\\n\\n\\treturn node_count\",\n \"def _tree_depth(self):\\n return self._flat_data._tree_depth()\",\n \"def branchLength(self,branch):\\n\\t\\t\\n\\t\\tlength = 0\\n\\t\\tfor p,point in enumerate(branch[:-1]):\\n\\t\\t\\tlength+=self.eucdist3d(branch[p],branch[p+1])\\n\\t\\t\\n\\t\\treturn(length)\",\n \"def depth_zero_finder(self, node):\\n for depth, prev_node in self.m_stack.lineage_with_level():\\n for typ in (markers.lower, markers.upper, markers.ints,\\n markers.roman):\\n if prev_node.label[-1] in typ and node.label[-1] in typ:\\n typ = list(typ)\\n prev_idx = typ.index(prev_node.label[-1])\\n current_idx = typ.index(node.label[-1])\\n if current_idx == prev_idx + 1:\\n return depth\\n return self.depth + 1\",\n \"def _height1(self): #works but n^2 time\\n return max(self.depth(p) for p in self.positions() if self.is_leaf(p))\",\n \"def _numconditions(self, node_p):\\n node_p = self.getnodenamed(node_p) # Verify pointer.\\n parents = self.getnodeparents(node_p) # nl_p\\n nparents = self.lengthnodelist(parents) # integer\\n # Get the number of states in each parent node, multiply them\\n npstates = 1\\n for idx in range(nparents):\\n node_i = self.nthnode(parents, idx)\\n nstates_i = self.getnodenumberstates(node_i)\\n npstates *= nstates_i\\n\\n return npstates\",\n \"def depth(self):\\n if self.size == 0:\\n return 0\\n return int(math.log(self.size, 2)) + 1\",\n \"def num_actual_nodes(tree):\\n return (tree.n_node_samples > 0).sum()\",\n \"def complexity(self):\\n n = 0\\n ctx = self\\n while ctx is not None:\\n n += 1\\n ctx = ctx.parent()\\n return n\",\n \"def get_tree_length(x):\\n length = list(self.__plan_graph.objects(subject=x, predicate=AGORA.length)).pop()\\n return length\",\n \"def dfs(node):\\n nonlocal ans \\n if not node: return 0\\n lx, rx = dfs(node.left), dfs(node.right) \\n if not node.left or node.left.val != node.val: lx = 0\\n if not node.right or node.right.val != node.val: rx = 0 \\n ans = max(ans, 1 + lx + rx)\\n return 1 + max(lx, rx)\",\n \"def countPanelTrajectoryExpressions(self):\\n nbr = 0\\n for e in self.children:\\n nbr += e.countPanelTrajectoryExpressions()\\n return nbr\",\n \"def num_trees(self):\\n return self._ll_tree_sequence.get_num_trees()\",\n \"def depth(self, p):\\n if self.is_root(p):\\n return 0\\n else:\\n return 1 + self.depth(self.parent(p))\",\n \"def node_count(self):\\n if self.value:\\n cnt = 0\\n else:\\n left_cnt = self.left.node_count()\\n right_cnt = self.right.node_count()\\n cnt = 1 + left_cnt + right_cnt\\n return cnt\",\n \"def num_depth(self):\\n return len(self._sizes) + len(self._ratios) - 1\",\n \"def depth(self):\\n return 0\",\n \"def countNodes(epr):\\n result = 1\\n argLst = epr.args\\n for arg in argLst:\\n result += countNodes(arg)\\n return result\",\n \"def test_depth(known_bst):\\n assert known_bst[0].depth() == 3\",\n \"def get_tree_size(self, node):\\n\\n # If the tree has not been created yet.\\n if node == None:\\n return 0\\n n_nodes = 1\\n for child in node.children:\\n n_nodes += self.get_tree_size(node.children[child])\\n return n_nodes\",\n \"def count_gold(pyramid):\\n\\n #replace this for solution\\n return 0\",\n \"def _calculate_points(tree):\\n leafs = []\\n points = 0\\n\\n def order(tree):\\n if tree is not None:\\n if tree.get_left_child() is not None:\\n order(tree.get_left_child())\\n elif tree.get_right_child() is not None:\\n order(tree.get_right_child())\\n else:\\n leafs.append(tree.key)\\n\\n order(tree)\\n\\n for board in leafs:\\n if board.is_winner()[0]:\\n if board.is_winner()[1] == 5:\\n points -= 1\\n else:\\n points += 1\\n\\n return points\",\n \"def CountPred(self, node):\\n if node.children: \\n res = 0;\\n for child in node.children:\\n res += self.CountPred(child);\\n return res;\\n else:\\n if node.tag.startswith(\\\"V\\\"):\\n self.vv += 1;\\n if len(node.arguments) != 0:\\n self.vpred += 1;\\n return 1;\\n else:\\n return 0;\",\n \"def count_leafs(self):\\n\\n def walk(block, count=0):\\n # This is a non-ope leaf, count it\\n if block.is_leaf and not block.is_open:\\n count += 1\\n\\n # This is a non-leaf block. Recurse\\n if not block.is_leaf:\\n for child in block.blocks.values():\\n count += walk(child)\\n\\n return count\\n\\n # Recursive walk and count\\n return walk(self)\",\n \"def num_of_children_steps(self):\\n total = 0\\n for child in self.children:\\n total += child.total_steps\\n return total\",\n \"def _height1(self): # works, but O(n^2) worst-case time\\n return max(self.depth(p) for p in self.positions() if self.is_leaf(p))\",\n \"def numNodes(self):\\n res = 0\\n for n in self.iternodes():\\n res += 1\\n return res\",\n \"def _get_level(self, node):\\n level = 0\\n while node.parent:\\n node = node.parent\\n level += 1\\n return level\",\n \"def numPaths(self):\\n if self.numpaths > -1:\\n return self.numpaths\\n\\n if self.jolt == 0:\\n return 1\\n\\n paths = 0\\n for parent in self.parents:\\n paths += parent.numPaths()\\n \\n return paths\",\n \"def test_findtotalConsecutive(self):\\n treesList = [1, 2, 5, 3]\\n result = findtotalConsecutive(treesList, 2, 2)\\n self.assertEqual(result, 8)\",\n \"def height(t: Tree):\\n if len(t.children) == 0:\\n return 1\\n else:\\n return 1 + max([height(c) for c in t.children])\",\n \"def depth(self):\\n L, R = 0,0\\n if self.left:\\n L = self.left.depth()\\n if self.right:\\n R = self.right.depth()\\n\\n return 1 + max(L, R)\",\n \"def dfs(node):\\n nonlocal ans\\n if not node: return []\\n if node.left is node.right is None: return [0]\\n left,right = dfs(node.left), dfs(node.right)\\n ans += sum(2 + x + y <= distance for x in left for y in right)\\n return [1 + x for x in left + right]\",\n \"def depht(self, p):\\n if self.is_root(p):\\n return 0\\n else:\\n return 1 + self.depht(self.parents(p))\",\n \"def test_ternary_tree_of_height_3_with_deepest_path_in_middle(self):\\n parents = [ -1, 0, 0, 0, 2 ]\\n self.init(parents)\\n self.assertEqual(3, self.method_under_test())\",\n \"def ask_depth(orders: pandas.DataFrame) -> int:\\n return len(asks(orders))\",\n \"def min_depth(t):\\n if is_leaf(t):\\n return 0\\n h = float('inf')\\n for b in branches(t):\\n # Still works fine!\\n h = min(h, 1 + min_depth(b))\\n return h\",\n \"def fn(node):\\n if not node: return 0\\n if not node.left or not node.right: return 1 + fn(node.left) + fn(node.right)\\n return 1 + min(fn(node.left), fn(node.right))\",\n \"def depth(self, p):\\n if self.is root(p):\\n return 0\\n else:\\n return 1 + self.depth(self.parent(p))\",\n \"def complexity(self, mode='#nodes'):\\n if mode == '#nodes':\\n return len(self.nodes)\",\n \"def _number_of_intervals(self):\\n return self._number_of_levels - 1\",\n \"def _calc_tree_depth(refinement_tree):\\n if not refinement_tree:\\n return 0\\n\\n depth = 0\\n for k, v in refinement_tree.items():\\n d = _calc_tree_depth(v)\\n if d > depth:\\n depth = d\\n\\n return 1 + depth\",\n \"def test_ternary_tree_of_height_3_with_deepest_path_on_left(self):\\n parents = [ -1, 0, 0, 0, 1 ]\\n self.init(parents)\\n self.assertEqual(3, self.method_under_test())\",\n \"def depth(self):\\n left_depth = self.left.depth() if self.left is not None else 0\\n right_depth = self.right.depth() if self.right is not None else 0\\n return max(left_depth, right_depth) + 1\",\n \"def helper(root):\\n if not root or not root.children: return 0\\n \\n if len(root.children) == 1:\\n depth = 1 + helper(root.children[0])\\n self.diameter = max(self.diameter, depth)\\n return depth\\n \\n else:\\n depths = [1+helper(child) for child in root.children]\\n max1, max2 = 0, 0\\n for depth in depths:\\n if depth >= max1:\\n max1, max2 = depth, max1\\n elif depth < max1 and depth > max2:\\n max2 = depth\\n self.diameter = max(self.diameter, max1+max2)\\n return max1\",\n \"def test_balanced_tree_with_3_nodes_has_depth_one(balanced_3_nodes):\\n assert balanced_3_nodes.depth() == 1\",\n \"def dfs(self, node):\\n if not node:\\n return 0\\n\\n l = self.dfs(node.left)\\n r = self.dfs(node.right)\\n self.ret = max(self.ret, l + 1 + r - 1) # path length is the #nodes - 1\\n return max(l, r) + 1\",\n \"def numIslands(grid):\\n # count to store each new island found\\n count = 0\\n # If the grid is empty, return 0\\n if not grid:\\n return count\\n\\n y_max = len(grid)\\n x_max = len(grid[0])\\n \\n for i in range(len(grid)):\\n for j in range(len(grid[0])):\\n if grid[i][j] == '1':\\n dfs(grid, i, j)\\n count += 1\\n return count\",\n \"def count_height(self, node: TreeNode) -> int:\\n if not node.left or not node.right:\\n if node.left == node.right:\\n return 1\\n if node.left and not node.right:\\n return node.left.height + 1\\n return node.right.height + 1\\n return max(node.left.height, node.right.height) + 1\",\n \"def children_num(self,p):\\n counter = 0\\n for child in self.children(p):\\n counter += 1\\n return counter\",\n \"def get_tree_depth(attributes):\\n depth = 0\\n for attribute in attributes:\\n if attribute == -1:\\n depth = depth + 1\\n return depth\",\n \"def size(self):\\n return self.variables.end_of_tree - 1\",\n \"def dfs(self, root: TreeNode) -> int:\\n if not root:\\n return 0\\n\\n def dfs(node):\\n if not node:\\n return float('inf')\\n if not node.left and not node.right:\\n return 1\\n return min(dfs(node.left), dfs(node.right)) + 1\\n\\n return dfs(root)\",\n \"def depth(self):\\n ch = self.children\\n return 0 if not ch else 1 + max([c.depth for c in ch])\",\n \"def number_of_new_components(self):\\n t_low = self.lower_binary_tree().to_tilting()\\n t_up = self.upper_binary_tree().to_tilting()\\n return len([p for p in t_low if p in t_up])\",\n \"def __len__(self):\\n return len(self.subtrees())\",\n \"def leaf_switch_count(self):\\n leafs = GetSwitchDetails().get_leaf_switch_ip()\\n totalLeafs = len(leafs)\\n return totalLeafs\",\n \"def fn(node):\\n if not node: return 0 \\n left, right = fn(node.left), fn(node.right)\\n if node.val == x: \\n cnt[0], cnt[1] = left, right\\n return 1 + left + right\",\n \"def Depth(self):\\n return self.path.count('.') + (self.parent is not None)\",\n \"def depth(self):\\n result = 0\\n if self.val is None:\\n return result\\n return max(self.left.depth(), self.right.depth()) + 1\",\n \"def count_nodes(self):\\n if self.children is None:\\n return 0\\n\\n total_count = 0\\n for child in self.children:\\n if child is None:\\n return 0\\n child_count = child.count_nodes()\\n total_count = total_count + child_count\\n\\n return total_count+1\",\n \"def depth(self):\\n if self.children is None:\\n return 1\\n\\n max_depth = 0\\n for child in self.children:\\n if child is None:\\n return 1\\n child_depth = child.depth()\\n if child_depth > max_depth:\\n max_depth = child_depth\\n\\n return max_depth+1\",\n \"def traverse_map(map, x_step, y_step):\\n trees_hit = 0\\n map_depth = len(map)\\n y_steps = range(0,map_depth,y_step)\\n for j,step in enumerate(y_steps):\\n trees_hit += 1 if tree_in_path(map[step],j*x_step) else 0\\n return trees_hit\",\n \"def number_of_trees_of_order(n):\\n if n < 2:\\n return n\\n result = 0\\n for k in range(1, n):\\n result += k * number_of_trees_of_order(k) * _s(n-1, k)\\n return result // (n - 1)\",\n \"def count_nodes(self):\\n\\t\\treturn self.__count_nodes(self)\",\n \"def depth(state):\\n current_depth = 0\\n for i in range(0, len(state.board)):\\n for j in range(0, len(state.board[0])):\\n if state.board[i][j] == '_':\\n current_depth += 1\\n return current_depth\",\n \"def count_leaves(self) -> int:\\n # binary search tree == empty\\n if self.root is None:\\n return 0\\n\\n #recursive helper function +=count total leaf\\n return self.count_leaves_helper(self.root)\",\n \"def _height1(self): # works, but O(n^2) worst-case time\\n return max(self.depth(p) for p in self.positions() if self.is_leaf(p))\",\n \"def height_helper(self, node: object) -> int:\\n #current node == a leaf\\n if self.is_leaf(node):\\n return 0\\n\\n #current node == a single child\\n if node.left is not None and node.right is None:\\n return 1 + self.height_helper(node.left)\\n if node.left is None and node.right is not None:\\n return 1 + self.height_helper(node.right)\\n\\n #node ==2 child leaf\\n if self.height_helper(node.left) > self.height_helper(node.right):\\n return 1 + self.height_helper(node.left)\\n else:\\n return 1 + self.height_helper(node.right)\",\n \"def test_findtotalConsecutive(self):\\n treesList = [1, 2, 5, 3]\\n result = findtotalConsecutive(treesList, 2, 4)\\n self.assertEqual(result, -1)\",\n \"def get_nodes_pixel_count(self):\\n sum_count = self.pixel_count\\n for i in range(8):\\n node = self.children[i]\\n if node:\\n sum_count += node.pixel_count\\n return sum_count\",\n \"def depth(self, p):\\n if self.is_root(p):\\n return 0\\n else:\\n return 1 + self.depth(self.parent(p))\",\n \"def depth(self, p):\\n if self.is_root(p):\\n return 0\\n else:\\n return 1 + self.depth(self.parent(p))\",\n \"def depth(self, p):\\n if self.is_root(p):\\n return 0\\n else:\\n return 1 + self.depth(self.parent(p))\",\n \"def depth(self, node):\\n\\n if not node:\\n return 0\\n else:\\n l_depth = self.depth(node.left)\\n r_depth = self.depth(node.right)\\n\\n if l_depth > r_depth:\\n return l_depth + 1\\n else:\\n return r_depth + 1\",\n \"def depth(self):\\n raise NotImplementedError()\",\n \"def getArea(rob):\\r\\n def dfs(visit, i, j):\\r\\n visit.add((i, j))\\r\\n for k in range(4):\\r\\n newi, newj = i + x[k], j + y[k]\\r\\n if (newi, newj) in visit or not rob.move(k):\\r\\n continue\\r\\n dfs(visit, newi, newj)\\r\\n rob.move((k + 2) % 4)\\r\\n visit = set()\\r\\n dfs(visit, 0, 0)\\r\\n return len(visit)\",\n \"def cyclomaticComplexity (self):\\n self.tarjan()\\n return len(self.__edges) - len(self.__nodes) + 2 * len(self.__scc)\",\n \"def depth(x):\\n return max(int(x * depth_multiplier), 8)\",\n \"def depth(self,p):\\n return 0 if self.is_root(p) else 1 + self.depth(self.parent(p))\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6907491","0.68810225","0.6854434","0.6781808","0.6753598","0.66757894","0.66155106","0.6588846","0.6567529","0.6486102","0.64605945","0.64430356","0.6425145","0.6416989","0.63806796","0.63761276","0.6331753","0.6319245","0.63084203","0.6269724","0.6227911","0.6216447","0.61870223","0.61831623","0.61382025","0.6129821","0.6123928","0.611689","0.6091851","0.6084243","0.6077563","0.60769254","0.6075377","0.6041637","0.60180855","0.60160595","0.60157704","0.60120785","0.600951","0.6008397","0.5996671","0.59812117","0.5979983","0.59770715","0.5969965","0.5969305","0.59651357","0.5950811","0.59483016","0.5940736","0.59389365","0.59345174","0.59321624","0.5931413","0.59248245","0.59179074","0.59147924","0.59128827","0.5910557","0.5910553","0.5902538","0.59002715","0.58872795","0.5879262","0.58787405","0.5877793","0.58771586","0.58769524","0.5874391","0.5873839","0.58731055","0.5869779","0.5862293","0.58595765","0.5851745","0.5851565","0.58447564","0.5843481","0.5840259","0.58356535","0.5829338","0.5826824","0.582591","0.5821228","0.58180046","0.58172864","0.5809102","0.580738","0.5807243","0.5806343","0.57990044","0.57922125","0.57902133","0.57902133","0.57902133","0.57870233","0.57845324","0.5782962","0.577576","0.57748306","0.57736516"],"string":"[\n \"0.6907491\",\n \"0.68810225\",\n \"0.6854434\",\n \"0.6781808\",\n \"0.6753598\",\n \"0.66757894\",\n \"0.66155106\",\n \"0.6588846\",\n \"0.6567529\",\n \"0.6486102\",\n \"0.64605945\",\n \"0.64430356\",\n \"0.6425145\",\n \"0.6416989\",\n \"0.63806796\",\n \"0.63761276\",\n \"0.6331753\",\n \"0.6319245\",\n \"0.63084203\",\n \"0.6269724\",\n \"0.6227911\",\n \"0.6216447\",\n \"0.61870223\",\n \"0.61831623\",\n \"0.61382025\",\n \"0.6129821\",\n \"0.6123928\",\n \"0.611689\",\n \"0.6091851\",\n \"0.6084243\",\n \"0.6077563\",\n \"0.60769254\",\n \"0.6075377\",\n \"0.6041637\",\n \"0.60180855\",\n \"0.60160595\",\n \"0.60157704\",\n \"0.60120785\",\n \"0.600951\",\n \"0.6008397\",\n \"0.5996671\",\n \"0.59812117\",\n \"0.5979983\",\n \"0.59770715\",\n \"0.5969965\",\n \"0.5969305\",\n \"0.59651357\",\n \"0.5950811\",\n \"0.59483016\",\n \"0.5940736\",\n \"0.59389365\",\n \"0.59345174\",\n \"0.59321624\",\n \"0.5931413\",\n \"0.59248245\",\n \"0.59179074\",\n \"0.59147924\",\n \"0.59128827\",\n \"0.5910557\",\n \"0.5910553\",\n \"0.5902538\",\n \"0.59002715\",\n \"0.58872795\",\n \"0.5879262\",\n \"0.58787405\",\n \"0.5877793\",\n \"0.58771586\",\n \"0.58769524\",\n \"0.5874391\",\n \"0.5873839\",\n \"0.58731055\",\n \"0.5869779\",\n \"0.5862293\",\n \"0.58595765\",\n \"0.5851745\",\n \"0.5851565\",\n \"0.58447564\",\n \"0.5843481\",\n \"0.5840259\",\n \"0.58356535\",\n \"0.5829338\",\n \"0.5826824\",\n \"0.582591\",\n \"0.5821228\",\n \"0.58180046\",\n \"0.58172864\",\n \"0.5809102\",\n \"0.580738\",\n \"0.5807243\",\n \"0.5806343\",\n \"0.57990044\",\n \"0.57922125\",\n \"0.57902133\",\n \"0.57902133\",\n \"0.57902133\",\n \"0.57870233\",\n \"0.57845324\",\n \"0.5782962\",\n \"0.577576\",\n \"0.57748306\",\n \"0.57736516\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}}],"truncated":false,"partial":true},"paginationData":{"pageIndex":898,"numItemsPerPage":100,"numTotalItems":95772,"offset":89800,"length":100}},"jwt":"eyJhbGciOiJFZERTQSIsImtpZCI6IjVHZDBvd0g5MTM2eDZjc1FvbE1zcktNWUZoRVFoUm5PVVVybEpjOUhaUEEifQ.eyJyZWFkIjp0cnVlLCJwZXJtaXNzaW9ucyI6eyJyZXBvLmNvbnRlbnQucmVhZCI6dHJ1ZX0sImlhdCI6MTc4NTc0MzIzMiwianRpIjoiZjJjMTQzNjAtZTIyMi00NDNmLThlZjItYWM3YjZkZjFmNmE2Iiwic3ViIjoiL2RhdGFzZXRzL25vbWljLWFpL2Nvcm5zdGFjay1weXRob24tdjEiLCJleHAiOjE3ODU3NDY4MzIsImlzcyI6Imh0dHBzOi8vaHVnZ2luZ2ZhY2UuY28ifQ.-6TUYCbAwH_DIifVqrqg6YKL8z1uFTAmPJbJm5o_5bbgy5Ft-hVgIZJMMigs5nprvU9WxexqnBt8W9LOiQB9DA","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 |
|---|---|---|---|---|---|---|
Determine if a player has won on the given board_state. | def has_winner(board_state, winning_length):
board_width = len(board_state)
board_height = len(board_state[0])
# check rows
for x in range(board_width):
winner = _has_winning_line(board_state[x], winning_length)
if winner != 0:
return winner
# check columns
for y in ... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def has_won(board, player):\r\n return False",
"def has_won(board, player):\n return False",
"def is_game_won(board, player):\n\n\tis_won = False\n\n\tif (\n\t\tboard[0] == board[1] == board[2] == player or\n\t\tboard[3] == board[4] == board[5] == player or\n\t\tboard[6] == board[7] == board[8] == player... | [
"0.79794073",
"0.7962099",
"0.77557176",
"0.7624931",
"0.7350112",
"0.72522813",
"0.70972157",
"0.7095919",
"0.7083247",
"0.7078027",
"0.70777637",
"0.7077196",
"0.7007858",
"0.6986884",
"0.6973706",
"0.69680285",
"0.69646233",
"0.69161004",
"0.68918866",
"0.687477",
"0.68736... | 0.6907228 | 18 |
Run a single game of tictactoe until the end, using the provided function args to determine the moves for each player. | def play_game(plus_player_func, minus_player_func, board_size=5, winning_length=4, log=False):
board_state = _new_board(board_size)
player_turn = 1
while True:
_available_moves = list(available_moves(board_state))
if len(_available_moves) == 0:
# draw
if log:
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def play_game(mc_move_function, ntrials, reverse = False):\n # Setup game\n board = TTTBoard(3, reverse)\n curplayer = PLAYERX\n winner = None\n\n # Run game\n while winner == None:\n # Move\n row, col = mc_move_function(board, curplayer, ntrials)\n board.move(row, col, curpl... | [
"0.61312234",
"0.60480046",
"0.60451484",
"0.60361534",
"0.60033566",
"0.5980271",
"0.5970943",
"0.59649867",
"0.5925829",
"0.5925095",
"0.5891507",
"0.5877892",
"0.5868325",
"0.5866884",
"0.58609414",
"0.5852589",
"0.5732131",
"0.5701758",
"0.5693335",
"0.5681218",
"0.567969... | 0.0 | -1 |
A player func that can be used in the play_game method. Given a board state it chooses a move randomly from the valid moves in the current state. | def random_player(board_state, _):
moves = list(available_moves(board_state))
return random.choice(moves) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def random_strategy(player, board):\n return random.choice(Othello.legal_moves(player, board))",
"def move_random(self, board):\n self.get_moves(board.board)\n return random.choice(self.available_moves)",
"def randomMove(board):\r\n go = True\r\n while go:\r\n y = random.randint(0... | [
"0.7818172",
"0.7593907",
"0.73932165",
"0.7253854",
"0.72194034",
"0.7201982",
"0.7074549",
"0.7062782",
"0.70347655",
"0.70231247",
"0.6997784",
"0.69781554",
"0.6972281",
"0.69547147",
"0.6952076",
"0.69505334",
"0.6949678",
"0.6943139",
"0.69346225",
"0.6917967",
"0.68817... | 0.87458694 | 0 |
shape of the whole domain with the halo points. | def shape_halo(self):
return [c.size for c in self.coords_halo] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def shape_with_halo(self):\n # TODO: Drop me after the domain-allocation switch, as this method\n # will be provided by the superclass\n return tuple(j + i + k for i, (j, k) in zip(self.shape_domain, self._halo))",
"def shape(self):",
"def shape(self):",
"def shape(self) -> Shape:",
"d... | [
"0.7041785",
"0.6348338",
"0.6348338",
"0.6217209",
"0.60234183",
"0.59201473",
"0.5863797",
"0.57955235",
"0.5774673",
"0.5743306",
"0.57097733",
"0.5701146",
"0.5701146",
"0.56974775",
"0.5685528",
"0.56634617",
"0.56310666",
"0.56310666",
"0.5606582",
"0.55863523",
"0.5581... | 0.6829687 | 1 |
shape of the interior domain. | def shape_in(self):
return [c.size for c in self.coords] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def shape(self):",
"def shape(self):",
"def shape(self):\n # TODO: perhaps this should be a list? That's what the shape\n # normally is.\n return np.array([len(self._R_boundaries)-1, len(self._P_boundaries)-1])",
"def shape(self):\n return self._shape",
"def shape(self) -> Shape:",
... | [
"0.7221017",
"0.7221017",
"0.71000314",
"0.6791237",
"0.6745107",
"0.67078817",
"0.6703702",
"0.6703702",
"0.67030513",
"0.6636736",
"0.6634805",
"0.6632598",
"0.65988344",
"0.6592197",
"0.6526844",
"0.6517238",
"0.6517238",
"0.6507547",
"0.64677215",
"0.64558387",
"0.6435168... | 0.615935 | 37 |
x component of the coordinates in the interior domain. | def x(self):
return self.coords[0] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def x_coord(self):\n\n return self.x0 + np.arange(self.nx) * self.dx",
"def x(self):\n return self._coords[0]",
"def x(self):\n if self._x is None:\n self.compute_coordinates()\n return self._x",
"def get_x(self):\n return self.coords[0]",
"def Getxcoord(self):... | [
"0.8358697",
"0.8154594",
"0.8109607",
"0.8066341",
"0.8036693",
"0.7739915",
"0.7691257",
"0.7688244",
"0.7548885",
"0.7508032",
"0.74587315",
"0.74127597",
"0.7358614",
"0.73565143",
"0.7294545",
"0.7292517",
"0.7270111",
"0.72684973",
"0.72265565",
"0.72084564",
"0.7204393... | 0.8181522 | 1 |
y component of the coordinates in the interior domain. | def y(self):
return self.coords[1] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def y_coord(self):\n\n return self.y0 + np.arange(self.ny) * self.dy",
"def y(self):\n return self._coords[1]",
"def y(self) -> int:\n return self.data.y_centre >> 4",
"def get_y(self):\n return self.coords[1]",
"def y(self):\n if self._y is None:\n self.comput... | [
"0.84114426",
"0.81654555",
"0.80646",
"0.79960674",
"0.78949875",
"0.7806516",
"0.77400583",
"0.77166253",
"0.7681602",
"0.7681602",
"0.7681602",
"0.7681602",
"0.7681602",
"0.7681602",
"0.7681602",
"0.7681602",
"0.7681602",
"0.7681602",
"0.76600176",
"0.76600176",
"0.7660017... | 0.82379454 | 1 |
z component of the coordinates in the interior domain. | def z(self):
return self.coords[2] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_z(self):\n return self.coords[2]",
"def z(self):\n return self._coords[2]",
"def getZ(self):\n\t\treturn self.coords.z",
"def getZCoord(self, x, y):\n n = self.normal()\n z = (-n.x * (x - self.p0.x) - n.y * (y - self.p0.y) + n.z * self.p0.z) / n.z\n return z",
"de... | [
"0.8204318",
"0.81756115",
"0.79953474",
"0.7745512",
"0.7492492",
"0.74836826",
"0.73827064",
"0.73827064",
"0.73827064",
"0.7358403",
"0.734638",
"0.7295331",
"0.7255795",
"0.7253108",
"0.7170729",
"0.71611345",
"0.7105172",
"0.7076959",
"0.6902277",
"0.6868089",
"0.6856292... | 0.8187841 | 1 |
x component of the coordinates of the whole domain (halo points included). | def x_halo(self):
return self.coords_halo[0] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def x_coord(self):\n\n return self.x0 + np.arange(self.nx) * self.dx",
"def x(self):\n if self._x is None:\n self.compute_coordinates()\n return self._x",
"def x(self):\n return self.coords[0]",
"def x(self):\n return self._coords[0]",
"def get_x(self):\n ... | [
"0.7628023",
"0.7627613",
"0.7605079",
"0.7560858",
"0.75197285",
"0.73364943",
"0.7319262",
"0.7208585",
"0.7040728",
"0.70402396",
"0.700919",
"0.6968909",
"0.69673264",
"0.6955738",
"0.69547075",
"0.69454676",
"0.69199395",
"0.682559",
"0.681483",
"0.6806043",
"0.6782578",... | 0.77378696 | 0 |
y component of the coordinates of the whole domain (halo points included). | def y_halo(self):
return self.coords_halo[1] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def y_coord(self):\n\n return self.y0 + np.arange(self.ny) * self.dy",
"def y(self):\n return self.coords[1]",
"def get_y(self):\n return self.__y",
"def y(self):\n return self._coords[1]",
"def y(self):\n if self._y is None:\n self.compute_coordinates()\n ... | [
"0.7791334",
"0.7649934",
"0.7597563",
"0.75450903",
"0.75338155",
"0.75070745",
"0.74508405",
"0.7420105",
"0.74109304",
"0.7409863",
"0.7409863",
"0.7409863",
"0.7409863",
"0.7409863",
"0.7409863",
"0.7409863",
"0.7409863",
"0.7409863",
"0.7409863",
"0.73475975",
"0.7347597... | 0.80401057 | 0 |
z component of the coordinates of the whole domain (halo points included). | def z_halo(self):
return self.coords_halo[2] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_z(self):\n return self.coords[2]",
"def z(self):\n return self.coords[2]",
"def z(self):\n return self._coords[2]",
"def getZ(self):\n\t\treturn self.coords.z",
"def getZCoord(self, x, y):\n n = self.normal()\n z = (-n.x * (x - self.p0.x) - n.y * (y - self.p0.y) +... | [
"0.76964957",
"0.7511645",
"0.74793464",
"0.7448726",
"0.7278982",
"0.7142226",
"0.70404834",
"0.69665307",
"0.69276017",
"0.6924901",
"0.68958646",
"0.68958646",
"0.68958646",
"0.68489766",
"0.68006426",
"0.6787681",
"0.6751956",
"0.6748075",
"0.6724205",
"0.66953576",
"0.66... | 0.7551448 | 1 |
Check the validity of the dictionnary which define the domain. Parameter | def check_dictionary(self, dico):
if dico is not None:
self.log.info('Check the dictionary')
test, aff = validate(dico, proto_domain, test_comp = False)
if test:
self.log.info(aff)
else:
self.log.error(aff)
sys.exit(... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _check_domain_additional(cls, domain: D) -> bool:\n action_space = domain.get_action_space().unwrapped()\n observation_space = domain.get_observation_space().unwrapped()\n\n if not isinstance(action_space, Iterable) and not isinstance(action_space, gym.spaces.Tuple):\n action_sp... | [
"0.65451413",
"0.6538749",
"0.6353704",
"0.6342437",
"0.6328692",
"0.63006294",
"0.6273927",
"0.61062527",
"0.60574967",
"0.6056676",
"0.60533655",
"0.59491223",
"0.5946937",
"0.59356123",
"0.5934907",
"0.5897498",
"0.5869605",
"0.5868954",
"0.58672255",
"0.586326",
"0.584886... | 0.7223405 | 0 |
Create the mpi topology | def construct_mpi_topology(self, dico):
period = [True]*self.dim
if dico is None:
comm = mpi.COMM_WORLD
else:
comm = dico.get('comm', mpi.COMM_WORLD)
self.mpi_topo = MPI_topology(self.dim, period, comm) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def createTopology(self):\n\n # find DAG root\n dagRoot = None\n for mote in self.motes:\n if mote.id == 0:\n mote.role_setDagRoot()\n dagRoot = mote\n assert dagRoot\n\n if self.settings.mobilityModel == 'RPGM':\n # put DAG roo... | [
"0.69177186",
"0.6628953",
"0.6226658",
"0.61995256",
"0.61995256",
"0.60618436",
"0.60247886",
"0.6013558",
"0.5998706",
"0.59884655",
"0.5967811",
"0.5916848",
"0.58346283",
"0.5791707",
"0.57730216",
"0.5722135",
"0.57025063",
"0.5692879",
"0.56564605",
"0.5617648",
"0.556... | 0.7762457 | 0 |
Create the coordinates of the interior domain and the whole domain with halo points. | def create_coords(self):
phys_box = self.geom.bounds # the physical box where the domain lies
# validation of the space step with the physical box size
for k in range(self.dim):
self.global_size.append((phys_box[k][1] - phys_box[k][0])/self.dx)
if not self.global_size[-1... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def shape_with_halo(self):\n # TODO: Drop me after the domain-allocation switch, as this method\n # will be provided by the superclass\n return tuple(j + i + k for i, (j, k) in zip(self.shape_domain, self._halo))",
"def get_bounds_halo(self):\n bottom_right = np.asarray([self.coords_h... | [
"0.629629",
"0.6192578",
"0.6049337",
"0.58665466",
"0.58665466",
"0.5679478",
"0.5666392",
"0.55614126",
"0.5559982",
"0.55101025",
"0.5502505",
"0.5448007",
"0.5385942",
"0.53807485",
"0.5354319",
"0.53424925",
"0.53216344",
"0.52725726",
"0.5272524",
"0.52718675",
"0.52423... | 0.68091905 | 0 |
Return the coordinates of the bottom right and upper left corner of the whole domain with halo points. | def get_bounds_halo(self):
bottom_right = np.asarray([self.coords_halo[k][0] for k in range(self.dim)])
upper_left = np.asarray([self.coords_halo[k][-1] for k in range(self.dim)])
return bottom_right, upper_left | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_bounds(self):\n bottom_right = np.asarray([self.coords[k][0] for k in range(self.dim)])\n upper_left = np.asarray([self.coords[k][-1] for k in range(self.dim)])\n return bottom_right, upper_left",
"def bottomLeftCorner(self):\n self._updateExtents()\n return (self._mMin... | [
"0.67394066",
"0.67303276",
"0.66209525",
"0.65128374",
"0.64220613",
"0.64210343",
"0.6401192",
"0.63610166",
"0.6264927",
"0.62276",
"0.6118288",
"0.59756935",
"0.59198815",
"0.5914908",
"0.5878579",
"0.58711284",
"0.58591115",
"0.580208",
"0.5798796",
"0.578806",
"0.577766... | 0.8023142 | 0 |
Return the coordinates of the bottom right and upper left corner of the interior domain. | def get_bounds(self):
bottom_right = np.asarray([self.coords[k][0] for k in range(self.dim)])
upper_left = np.asarray([self.coords[k][-1] for k in range(self.dim)])
return bottom_right, upper_left | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_bounds_halo(self):\n bottom_right = np.asarray([self.coords_halo[k][0] for k in range(self.dim)])\n upper_left = np.asarray([self.coords_halo[k][-1] for k in range(self.dim)])\n return bottom_right, upper_left",
"def bottomLeftCorner(self):\n self._updateExtents()\n ret... | [
"0.76211905",
"0.7292665",
"0.69914323",
"0.67774415",
"0.6669149",
"0.6615716",
"0.6581587",
"0.6549148",
"0.6523538",
"0.65019536",
"0.64836305",
"0.64644194",
"0.64228207",
"0.6417498",
"0.6398502",
"0.63445574",
"0.63234276",
"0.6316152",
"0.6315162",
"0.6314326",
"0.6278... | 0.77522284 | 0 |
Add an element if elem.isfluid = False as a solid part. (bw=0) if elem.isfluid = True as a fluid part. (bw=1) | def __add_elem(self, elem):
# compute the box around the element adding vmax safety points
vmax = self.stencil.vmax
elem_bl, elem_ur = elem.get_bounds()
phys_bl, phys_ur = self.get_bounds_halo()
tmp = np.array((elem_bl - phys_bl)/self.dx, np.int) - vmax
nmin = np.maximum... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def sketch_und_part(self):\n if (self.dimension == '3D'):\n #Sketch Wuerfel zeichnen\n self.sketch_Wuerfel = self.model.ConstrainedSketch(\n name='Seitenansicht_Wuerfel',\n sheetSize=200.0)\n self.sketch_Wuerfel.rectangle(\n point... | [
"0.5353897",
"0.52898836",
"0.52194977",
"0.5092196",
"0.49273452",
"0.48061937",
"0.47618276",
"0.47300842",
"0.47194925",
"0.4717585",
"0.46338245",
"0.46224457",
"0.46221817",
"0.46195388",
"0.46033767",
"0.4593283",
"0.45669478",
"0.45467424",
"0.45268017",
"0.45268017",
... | 0.61179656 | 0 |
Get the list of all the labels used in the geometry. | def list_of_labels(self):
L = np.unique(self.box_label)
return np.union1d(L, self.geom.list_of_elements_labels()) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_labels(self):\n return []",
"def get_labels(self) -> List[str]:\n raise NotImplementedError()",
"def get_labels(self) -> Set[str]:",
"def get_labels(self) -> List[str]:\n return self.labels",
"def labels(self):\n return self._labels",
"def labels_all(self):\n return sel... | [
"0.78688353",
"0.77143806",
"0.7649815",
"0.76258653",
"0.7622505",
"0.7539628",
"0.7502521",
"0.74491197",
"0.74491197",
"0.74491197",
"0.74491197",
"0.74491197",
"0.74491197",
"0.7397355",
"0.7367742",
"0.7357493",
"0.73287654",
"0.73217773",
"0.7304837",
"0.7304837",
"0.73... | 0.7938898 | 0 |
Visualize the domain by creating a plot. | def visualize(self, viewer_app=viewer.matplotlibViewer, view_distance=False, view_in=True, view_out=True, view_bound=False, label=None):
fig = viewer_app.Fig(dim = self.dim)
view = fig[0]
if isinstance(view_distance, bool):
view_seg = view_distance
view_distance = list(r... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"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 vi... | [
"0.7162099",
"0.7078026",
"0.70367897",
"0.6830851",
"0.68271685",
"0.6822806",
"0.6790577",
"0.67280227",
"0.6702536",
"0.6591383",
"0.65613216",
"0.6556937",
"0.6517892",
"0.6462875",
"0.64443344",
"0.6443013",
"0.6442326",
"0.6401814",
"0.63987905",
"0.63952917",
"0.638571... | 0.0 | -1 |
Function that writes all the informations of a domain | def verification(dom, with_color=False):
# some terminal colors
if with_color:
blue = '\033[01;05;44m'
black = '\033[0m'
green = '\033[92m'
white = '\033[01;37;44m'
else:
blue = ''
black = ''
green = ''
white = ''
print('Nombre de points :... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def write(self):\n self.__domainlist.sort()\n\n try:\n fileobject = open(filename, mode=\"w\")\n for domain in self.__domainlist:\n fileobject.write(domain + \"\\n\")\n fileobject.close()\n except:\n print(\"Error when writing file\")"... | [
"0.7394263",
"0.6997635",
"0.6566115",
"0.6418956",
"0.63475776",
"0.6291576",
"0.60947907",
"0.6093731",
"0.6071532",
"0.60149324",
"0.5960534",
"0.5881924",
"0.58262575",
"0.5778478",
"0.5778478",
"0.56793374",
"0.5558486",
"0.5536063",
"0.55333006",
"0.55250967",
"0.552432... | 0.0 | -1 |
Create snapshot with unexpected device count for previous versions. | def test_create_with_too_many_devices(test_microvm_with_api):
test_microvm = test_microvm_with_api
# Create and start a microVM with `FC_V0_23_MAX_DEVICES_ATTACHED`
# network devices.
devices_no = FC_V0_23_MAX_DEVICES_ATTACHED
_create_and_start_microvm_with_net_devices(test_microvm, devices_no)
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_snapshot_compatibility(microvm_factory, guest_kernel, rootfs):\n vm = microvm_factory.build(guest_kernel, rootfs)\n vm.spawn()\n vm.basic_config(\n vcpu_count=2,\n mem_size_mib=256,\n )\n\n # Add a memory balloon with stats enabled.\n vm.api.balloon.put(amount_mib=0, deflat... | [
"0.5707831",
"0.5573247",
"0.5530108",
"0.55096114",
"0.5387642",
"0.525641",
"0.52525467",
"0.52115786",
"0.5178012",
"0.51598006",
"0.5086971",
"0.5044647",
"0.5015125",
"0.49779987",
"0.49674007",
"0.4938787",
"0.49172089",
"0.49106458",
"0.48969096",
"0.48893365",
"0.4873... | 0.607721 | 0 |
Tests taking a snapshot at the version specified in Cargo.toml Check that it is possible to take a snapshot at the version of the upcoming release (during the release process this ensures that if we release version x.y, then taking a snapshot at version x.y works something we'd otherwise only be able to test once the x... | def test_snapshot_current_version(uvm_nano):
vm = uvm_nano
vm.start()
version = get_firecracker_version_from_toml()
# normalize to a snapshot version
target_version = f"{version.major}.{version.minor}.0"
snapshot = vm.snapshot_full(target_version=target_version)
# Fetch Firecracker binary ... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_pre_release(scraper, version_parts):\n\n new_version_parts = list(version_parts)\n if len(new_version_parts) > 4:\n new_version_parts[4] = int(new_version_parts[4]) + 1\n elif len(new_version_parts) > 3:\n new_version_parts.append(1)\n else:\n new_version_parts.extend(['a'... | [
"0.6502068",
"0.6310254",
"0.6265",
"0.6260519",
"0.6240066",
"0.62363416",
"0.6196736",
"0.61603254",
"0.6096417",
"0.6088469",
"0.60742664",
"0.6066883",
"0.6045832",
"0.6043664",
"0.603125",
"0.5988045",
"0.5978905",
"0.5974485",
"0.5948521",
"0.59446055",
"0.5923739",
"... | 0.70966417 | 0 |
Attempt to create a snapshot with newer virtio features. | def test_create_with_newer_virtio_features(uvm_nano):
test_microvm = uvm_nano
test_microvm.add_net_iface()
test_microvm.start()
# Init a ssh connection in order to wait for the VM to boot. This way
# we can be sure that the block device was activated.
test_microvm.ssh.run("true")
# Pause m... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_snapshot_compatibility(microvm_factory, guest_kernel, rootfs):\n vm = microvm_factory.build(guest_kernel, rootfs)\n vm.spawn()\n vm.basic_config(\n vcpu_count=2,\n mem_size_mib=256,\n )\n\n # Add a memory balloon with stats enabled.\n vm.api.balloon.put(amount_mib=0, deflat... | [
"0.67031753",
"0.5935706",
"0.5914112",
"0.5762848",
"0.5759202",
"0.5687569",
"0.5678241",
"0.56615245",
"0.56577706",
"0.556173",
"0.5539944",
"0.5531928",
"0.552826",
"0.54974014",
"0.54896766",
"0.5480551",
"0.54506993",
"0.5432392",
"0.54126745",
"0.54020923",
"0.5380297... | 0.7215181 | 0 |
Verifies that we can't create a snapshot with target version less than 1.5 if cpu template with additional vcpu features or kvm capabilities is in use. | def test_create_with_1_5_cpu_template(uvm_plain):
# We remove KVM_CAP_IOEVENTFD from kvm checks just for testing purpose.
custom_cpu_template = json.loads('{"kvm_capabilities": ["!36"]}')
test_microvm = uvm_plain
test_microvm.spawn()
test_microvm.basic_config(vcpu_count=2, mem_size_mib=256)
te... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_create_with_newer_virtio_features(uvm_nano):\n test_microvm = uvm_nano\n test_microvm.add_net_iface()\n test_microvm.start()\n\n # Init a ssh connection in order to wait for the VM to boot. This way\n # we can be sure that the block device was activated.\n test_microvm.ssh.run(\"true\")\... | [
"0.65462935",
"0.6420692",
"0.6118976",
"0.60601354",
"0.60190666",
"0.5678747",
"0.5554583",
"0.55517364",
"0.5539511",
"0.55231994",
"0.54974645",
"0.5484495",
"0.5428318",
"0.54254496",
"0.54118603",
"0.5407401",
"0.540111",
"0.5394907",
"0.5390333",
"0.53765833",
"0.53608... | 0.7106182 | 0 |
Compare power function with builtin exponentiation | def pass_test(power_func, num, pow):
true_pow = num**pow
# Print accordingly
if true_pow == power_func(num, pow):
print("Test Passed")
else:
print("Error: Test not passed") | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def power(num, exponent):\n return num ** exponent",
"def power(a, b):\n \n return a**b",
"def power(a, b):\n pass",
"def power(num, exponent):\n power = num ** exponent\n return power",
"def exponent(num,power=2):\n return num ** power",
"def power(num1, num2):\n exponent = num1 *... | [
"0.7698817",
"0.76238865",
"0.7567662",
"0.75390667",
"0.74961966",
"0.7377043",
"0.7375325",
"0.73349035",
"0.7298315",
"0.71073616",
"0.70669913",
"0.70454425",
"0.70377856",
"0.7021158",
"0.6987446",
"0.69689125",
"0.6905377",
"0.6866605",
"0.67770195",
"0.67557365",
"0.66... | 0.7073906 | 10 |
Test for correctness and run time. | def full_test(power_func, test_num, test_pow, test_dict):
# Get sort_func name
func_name = power_func.__name__
# Measure time function takes
start = timer()
power_func(test_num, test_pow)
end = timer()
# Store time in test dictionary
test_dict[func_name] = end-start
# Test for correc... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def check(self, runtime):",
"def check():",
"def test_check_cost():",
"def runTest(self):\n return True",
"def test_comprehensive_system(self):\n\n with ROV_Validity_Table() as db:\n\n # Run MRT_Parser to fill mrt_announcements table which will\n # be used as the input t... | [
"0.76117027",
"0.73374003",
"0.7305376",
"0.7104261",
"0.70961267",
"0.7000361",
"0.69930726",
"0.69748384",
"0.688779",
"0.688779",
"0.68223035",
"0.6801772",
"0.6791196",
"0.67599744",
"0.67599744",
"0.67599744",
"0.6759878",
"0.67136264",
"0.67136264",
"0.67119783",
"0.671... | 0.0 | -1 |
Read the special config blocks and store in a dictionary | def parse_special(special):
special_name = ""
specials = {}
for line in special:
if check_template_start(line):
special_name = line.split(":")[1]
specials[special_name] = []
elif check_template_end(line):
special_name = ""
elif special_name != "":
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_block_config():\n ret = {}\n ret[keyword.function] = []\n ret[keyword.inputs] = []\n ret[keyword.expect] = []\n return ret",
"def parse_config(fpath):\n\n with open(fpath, \"r\") as f:\n # Ignore lines consisting only of whitespace or commented lines.\n lines = [\n ... | [
"0.7062198",
"0.65265226",
"0.6522121",
"0.63530326",
"0.63237303",
"0.6279691",
"0.6254327",
"0.62248856",
"0.62101585",
"0.62071514",
"0.6206471",
"0.6194919",
"0.6155586",
"0.61548185",
"0.608414",
"0.6081995",
"0.6007709",
"0.5962564",
"0.59612393",
"0.59369946",
"0.59031... | 0.5562557 | 75 |
Replace all special lines with their blocks in the special config | def replace_base(base, specials):
new_config = []
for line in base:
new_config.append(line)
if check_template_start(line):
# Found template line, try to add special
special = line.split(":")[1]
if special in specials:
new_config.extend(specials... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def replace(lines):\n for index, line in enumerate(lines):\n if not line == '\\n':\n token_line = tokenizer.tokenize_line(line)\n for ind, tok in enumerate(token_line):\n if token_line[ind][1] in replacement_dic.keys() and token_line[ind][1] not in ignore_variable:\n ... | [
"0.60071075",
"0.59372526",
"0.5920741",
"0.57225025",
"0.5639018",
"0.56047815",
"0.5575346",
"0.5567408",
"0.5562298",
"0.55614144",
"0.55471146",
"0.55306953",
"0.5528332",
"0.5473518",
"0.5411829",
"0.54098475",
"0.5369975",
"0.53312016",
"0.5301475",
"0.5291877",
"0.5289... | 0.70681936 | 0 |
Clip a polygon with another polygon. | def polygon_clip(subjectPolygon, clipPolygon):
def inside(p):
return (cp2[0] - cp1[0]) * (p[1] - cp1[1]) > (cp2[1] - cp1[1]) * (p[0] - cp1[0])
def computeIntersection():
dc = [cp1[0] - cp2[0], cp1[1] - cp2[1]]
dp = [s[0] - e[0], s[1] - e[1]]
n1 = cp1[0] * cp2[1] - cp1[1] * cp2[0... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def clip_polygon(subject, clipper, operation = 'difference'):\n Subject = Polygon()\n Clipper = Polygon()\n\n for s in subject:\n Subject.add(Vertex(s))\n\n for c in clipper:\n Clipper.add(Vertex(c))\n\n clipped = Clipper.difference(Subject)\\\n if operation == 'reversed-diff'\\\n ... | [
"0.73871416",
"0.71527326",
"0.67622846",
"0.6655635",
"0.66529",
"0.6612446",
"0.65643936",
"0.6487739",
"0.6454339",
"0.6290975",
"0.6247579",
"0.6042842",
"0.6040423",
"0.60388094",
"0.60388094",
"0.60195905",
"0.59496385",
"0.5936355",
"0.5933871",
"0.5932276",
"0.5883224... | 0.6551858 | 7 |
Compute area of two convex hull's intersection area. p1,p2 are a list of (x,y) tuples of hull vertices. return a list of (x,y) for the intersection and its volume | def convex_hull_intersection(p1, p2):
inter_p = polygon_clip(p1,p2)
if inter_p is not None:
hull_inter = ConvexHull(inter_p)
return inter_p, hull_inter.volume
else:
return None, 0.0 | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def convex_hull_intersection(p1, p2):\n inter_p = polygon_clip(p1, p2)\n if inter_p is not None:\n hull_inter = ConvexHull(inter_p)\n return inter_p, hull_inter.volume\n else:\n return None, 0.0",
"def convex_hull_intersection(self, p1, p2):\n inter_p = self.polygon_clip(p1,p... | [
"0.8143819",
"0.8140708",
"0.70325965",
"0.6644891",
"0.65631235",
"0.63782674",
"0.6323484",
"0.629715",
"0.61973083",
"0.6167351",
"0.61586636",
"0.6157963",
"0.6141326",
"0.6125375",
"0.61231095",
"0.6099263",
"0.60979515",
"0.60971546",
"0.6084221",
"0.6077353",
"0.607299... | 0.81397164 | 3 |
All possible tiers Each tier is a tuple in alphabetical order | def build_tiers(self):
self.tiers = []
for size in range(1,len(self.sigma)+1):
for combo in itertools.combinations(self.sigma, size):
self.tiers.append(tuple(sorted(list(combo)))) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def part_1():\n return itertools.permutations(range(5))",
"def flip(tier: int) -> list:\n pool = load_minion_pool()\n n_to_show = tier // 2 + 3\n available_minions = []\n\n for t in range(1, tier + 1):\n for _ in range(settings.TIER_COUNTS[t]):\n available_minions += pool[str(t)]... | [
"0.5811346",
"0.57635534",
"0.56175697",
"0.55959123",
"0.5509604",
"0.5472255",
"0.54375213",
"0.5435182",
"0.5416104",
"0.54044276",
"0.5403584",
"0.5363441",
"0.5363441",
"0.53515655",
"0.5348641",
"0.534456",
"0.5333362",
"0.5300959",
"0.5291334",
"0.5283928",
"0.5224548"... | 0.6834271 | 0 |
Patch an object with a needed attribute. | def patch_object(mocker):
def _object(obj_to_patch, attribute, return_value):
mock_func = mocker.patch.object(obj_to_patch, attribute)
if return_value is not None:
mock_func.return_value = return_value
return _object | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def patch(self, obj, field, value):\n return Patch(obj, field, value)",
"def Patch(self, obj):\n # TODO (jason.stredwick): Change to\n # auto_update_attr = class_attr.GetPODAttrs(Bug)\n # once the special cases have been resolved.\n special_props = ['target_element', 'has_target_element',\n ... | [
"0.76002645",
"0.72562224",
"0.69803596",
"0.6769369",
"0.65772796",
"0.65772796",
"0.65426695",
"0.65337133",
"0.65073776",
"0.64899504",
"0.6477458",
"0.6455356",
"0.6347116",
"0.63402766",
"0.6297255",
"0.62557065",
"0.62532693",
"0.6205195",
"0.6205195",
"0.6205195",
"0.6... | 0.60075223 | 33 |
Mock clip.Path to get a different path than the default. | def mock_path(mocker):
def _path(module, side_effect):
mock_func = mocker.patch(f'{module}.Path.mkdir')
mock_func.side_effect = side_effect
return _path | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_set_path_4(self, verify_path2_mock):\n test_file = Path(\"/dir1/dir2/../file.txt\")\n verify_path2_mock.return_value = (True, None)\n output = basic.set_path(test_file, kind=\"file\", expect=True)\n exp = Path(\"/dir1/file.txt\")\n self.assertEqual(output, exp)",
"def ... | [
"0.62415814",
"0.6212893",
"0.6178796",
"0.6098295",
"0.6094493",
"0.59861505",
"0.5955945",
"0.5938097",
"0.584768",
"0.5844672",
"0.57498765",
"0.5744569",
"0.5736058",
"0.57053375",
"0.57032806",
"0.5697243",
"0.5694985",
"0.5653811",
"0.56268764",
"0.5626876",
"0.56013525... | 0.5195472 | 49 |
Mock clip.Path to get a different path than the default. | def mock_path_mkdir(mocker):
def _path(obj_to_patch, attribute, side_effect):
mock_func = mocker.patch.object(obj_to_patch, attribute)
mock_func.side_effect = side_effect
return _path | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_set_path_4(self, verify_path2_mock):\n test_file = Path(\"/dir1/dir2/../file.txt\")\n verify_path2_mock.return_value = (True, None)\n output = basic.set_path(test_file, kind=\"file\", expect=True)\n exp = Path(\"/dir1/file.txt\")\n self.assertEqual(output, exp)",
"def ... | [
"0.6240082",
"0.6211727",
"0.6177706",
"0.6096658",
"0.6093146",
"0.5984969",
"0.59549236",
"0.5936637",
"0.584658",
"0.5843622",
"0.5748406",
"0.57428294",
"0.5735809",
"0.5704555",
"0.5702183",
"0.5695934",
"0.5695079",
"0.56529605",
"0.562511",
"0.56249416",
"0.5601013",
... | 0.0 | -1 |
Mock the requests.get return value. If we try to set attributes on requests.get directly, we'll | def mock_requests_get(mocker, mocked_requests_get):
def _requests_get(module, content, status):
mock_func = mocker.patch(f'{module}.requests.get')
mock_func.return_value = mocked_requests_get(content, status)
return _requests_get | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def mock_requests_get(self, mocker):\n mock = mocker.patch(\"requests.get\")\n mock.return_value.__enter__.return_value.json.return_value = {\n \"item\": {\n \"icon\": \"\",\n \"icon_large\": \"\",\n \"id\": 21787,\n \"type\": \"M... | [
"0.72807246",
"0.72359955",
"0.7179954",
"0.70539004",
"0.7024782",
"0.69704086",
"0.69374245",
"0.68708456",
"0.6863891",
"0.68198556",
"0.67906505",
"0.6764723",
"0.67489815",
"0.6732757",
"0.6729054",
"0.6710932",
"0.66979325",
"0.6666944",
"0.6651065",
"0.66106665",
"0.65... | 0.719874 | 2 |
Simulate requests raising an exception. | def mock_requests_exception(mocker):
def _requests_exception(module, exception):
mock_func = mocker.patch(f'{module}.requests.get')
mock_func.side_effect = exception
return _requests_exception | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _raise_performing_request_error(self, *args, **kwargs):",
"def test_exception():\n class Handler(RequestHandler):\n def get(self):\n self.set_status(400)\n self.write('Fail')\n\n app = Application([url('/hello', Handler)])\n\n with Tester(app) as tester:\n for i i... | [
"0.7364481",
"0.72800875",
"0.69547635",
"0.6914229",
"0.67766964",
"0.67396665",
"0.6722903",
"0.6688388",
"0.6677752",
"0.6655239",
"0.66538423",
"0.6649622",
"0.66298413",
"0.6622028",
"0.66155547",
"0.66072726",
"0.65861887",
"0.65859425",
"0.65722626",
"0.6570693",
"0.65... | 0.6127084 | 63 |
Create a fake requests.Response object. | def mocked_requests_get():
class MockResponse:
def __init__(self, _content, _status):
self.content = _content
self.status_code = _status
def content(self):
return self.content
return MockResponse | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def response():\n def inner(ret_code, ret_value):\n \"\"\"Set up response with the given parameters.\n\n :param ret_code: Return code for the response\n :param ret_value: Return value for the response\n :return: Mocked Responce object with the given parameters\n \"\"... | [
"0.736011",
"0.71040297",
"0.7098835",
"0.6869094",
"0.6854902",
"0.6733961",
"0.6733961",
"0.6719025",
"0.6631267",
"0.6599584",
"0.6549238",
"0.65430015",
"0.6531704",
"0.6485677",
"0.64722425",
"0.643935",
"0.64389443",
"0.6423061",
"0.642237",
"0.6392279",
"0.63886",
"0... | 0.73249215 | 1 |
Delete all schedules from storage | def wipe(self): | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def remove_all():\n storage = FileStorage()\n objects = storage.all()\n objects = list(objects.values())\n\n for element in objects:\n storage.delete(element)\n objects = storage.all()",
"def remove_all():\n \"\"\" Removes all from the database \"\"\"\n ... | [
"0.67903996",
"0.6692977",
"0.65550745",
"0.6550395",
"0.6493148",
"0.64656925",
"0.64595354",
"0.6438414",
"0.6422963",
"0.63632655",
"0.6361692",
"0.63402975",
"0.63228196",
"0.6302844",
"0.6288532",
"0.62680525",
"0.62613064",
"0.624178",
"0.62197363",
"0.6144944",
"0.6121... | 0.0 | -1 |
Return all JobStates present in storage | def all_stored_job_state(self, repository_origin_id=None, job_type=None): | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_states():\n states = []\n for state in storage.all(\"State\").values():\n states.append(state.to_dict())\n return jsonify(states)",
"def get_states():\n all_states = []\n states = storage.all(State).values()\n for state in states:\n all_states.append(state.to_dict())\n ... | [
"0.70959705",
"0.70369786",
"0.70325696",
"0.6953881",
"0.6952176",
"0.6944491",
"0.6943182",
"0.68910843",
"0.6842506",
"0.6766063",
"0.6744036",
"0.6644306",
"0.649214",
"0.64365315",
"0.6280112",
"0.6280112",
"0.62451684",
"0.62207997",
"0.62207997",
"0.621835",
"0.6201651... | 0.732007 | 0 |
Return the unique job with the given id | def get_job_state(self, job_origin_id): | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_job_by_id(self, job_id):\n return self.get_resource(category=SYSTEM, resource_level=JOB,\n resource_level_id=job_id)",
"def get_job(self, _id):\n data = {\n 'class': 'Job',\n 'id': _id,\n 'attrs': {},\n }\n job =... | [
"0.7371126",
"0.7347247",
"0.7267338",
"0.725329",
"0.71483725",
"0.71149886",
"0.7078288",
"0.7053403",
"0.70340437",
"0.7011335",
"0.6989745",
"0.698619",
"0.69853693",
"0.6967988",
"0.69580775",
"0.69107187",
"0.6877992",
"0.68590534",
"0.68409127",
"0.67786914",
"0.673982... | 0.0 | -1 |
Add a job to storage. | def add_job_state(self, job): | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def add(self, job):\r\n self.jobs.put(job)",
"def add_job(self, job):\n self.job_list.append(job)\n return",
"def add_job(self, job):\n with self._mutex:\n self._jobs.append(job)",
"def add_job(self, job):\n self.job_list.append(job)\n self.num_jobs += 1",... | [
"0.8303181",
"0.7816713",
"0.769324",
"0.76033986",
"0.72202975",
"0.71949184",
"0.7073336",
"0.7073336",
"0.7062141",
"0.68707186",
"0.68078905",
"0.6772507",
"0.6732047",
"0.6640165",
"0.6637045",
"0.66317594",
"0.65742826",
"0.6526206",
"0.6507963",
"0.63838726",
"0.638387... | 0.61567235 | 29 |
Update a job in storage. | def update_job_state(self, job): | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def update(self):\n self._log.debug(\"About to update job {0}\".format(self.id))\n resp = self._api.get_job(self.id)\n\n if resp.success:\n self.submission = self._format_submission(resp.result)\n return True\n\n else:\n raise resp.result",
"def update... | [
"0.68505573",
"0.67774576",
"0.6659658",
"0.6659658",
"0.6659658",
"0.6659658",
"0.6564279",
"0.6517204",
"0.6458511",
"0.6458511",
"0.64496225",
"0.6410681",
"0.6359297",
"0.6357958",
"0.6333834",
"0.63191736",
"0.63028765",
"0.62683195",
"0.61782503",
"0.6171958",
"0.616505... | 0.66005653 | 6 |
Delete a job in storage. | def delete_job_state(self, job_origin_id): | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _delete_job(self, job):",
"def _delete_job(self, job):\n with self.db_lock:\n return self.rcon.zrem(job)",
"def job_delete(job):\n\n if os.path.exists(job.output_abspath):\n os.remove(job.output_abspath)\n db.session.delete(job)\n db.session.commit()",
"def delete_job(se... | [
"0.812532",
"0.7588499",
"0.7546053",
"0.7532317",
"0.7443797",
"0.7427653",
"0.7349561",
"0.73434865",
"0.72797036",
"0.7231576",
"0.6949614",
"0.6915326",
"0.68772835",
"0.687612",
"0.6850112",
"0.6781744",
"0.67704695",
"0.67349565",
"0.6731967",
"0.66634506",
"0.66589355"... | 0.611005 | 54 |
Get the ticks for a given job. | def get_job_ticks(self, job_origin_id): | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_job_tick_stats(self, job_origin_id):",
"def get_ticks(self):\n return pg.time.get_ticks()",
"def get_latest_job_tick(self, job_origin_id):",
"def get_ticks(self, market, period):\n return self.__call__('market', 'GetTicks',\n {'marketName': market,\n ... | [
"0.6805147",
"0.65050817",
"0.63807094",
"0.6250666",
"0.5612657",
"0.5576679",
"0.55496687",
"0.5537462",
"0.5457608",
"0.54030746",
"0.5366965",
"0.53657764",
"0.5344443",
"0.5304836",
"0.53023386",
"0.529134",
"0.528076",
"0.5270107",
"0.52592474",
"0.5257897",
"0.52511895... | 0.79622924 | 0 |
Get the most recent tick for a given job. | def get_latest_job_tick(self, job_origin_id): | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def last_job(self): # TOFIX model the job and return an object instead of dictionary\n return self._data.get('summary_fields', {}).get('last_job')",
"def latest_job(self):\n return self.jobmanagers[self.current_network].latest_job",
"def get_last_job_id():\n\n return JobDetail.query.with_enti... | [
"0.6885023",
"0.68426526",
"0.63668716",
"0.625937",
"0.61686134",
"0.61422634",
"0.6088384",
"0.60683393",
"0.60473347",
"0.604174",
"0.5943635",
"0.5943489",
"0.58863485",
"0.58651054",
"0.5843796",
"0.58378553",
"0.5831277",
"0.57627594",
"0.57353145",
"0.5645166",
"0.5631... | 0.79333454 | 0 |
Add a job tick to storage. | def create_job_tick(self, job_tick_data): | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def add(self, job):\r\n self.jobs.put(job)",
"def update_job_tick(self, tick):",
"def add_job(self, job):\n self.job_list.append(job)\n self.num_jobs += 1",
"def add_job(self, job):\n self.job_list.append(job)\n return",
"def add_job(self, job):\n with self._mutex:... | [
"0.68822646",
"0.644974",
"0.6336911",
"0.60865444",
"0.6081882",
"0.5925319",
"0.58823025",
"0.5867289",
"0.58074796",
"0.5784127",
"0.5779706",
"0.5779706",
"0.576042",
"0.5738642",
"0.5720947",
"0.56882465",
"0.56653124",
"0.56326026",
"0.561558",
"0.56124854",
"0.5605226"... | 0.6734833 | 1 |
Update a job tick already in storage. | def update_job_tick(self, tick): | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def update_tick(self, tick: InstigatorTick):",
"def update_job_state(self, job):",
"def update(self, ticks):\n self.quantity_cursor.update(ticks)",
"def on_job_update(_job):\n nonlocal job\n job = _job",
"def on_job_update(_job):\n nonlocal job\n job = _job",
"def on_jo... | [
"0.65579045",
"0.6554705",
"0.6091657",
"0.6049211",
"0.6049211",
"0.6049211",
"0.6049211",
"0.5960409",
"0.5899886",
"0.5852035",
"0.5800887",
"0.5797093",
"0.5778178",
"0.5775377",
"0.5766446",
"0.57579905",
"0.57497984",
"0.5748029",
"0.5748029",
"0.5748029",
"0.5717909",
... | 0.78228307 | 0 |
Wipe ticks for a job for a certain status and timestamp. | def purge_job_ticks(self, job_origin_id, tick_status, before): | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def purge_ticks(self, origin_id: str, tick_status: TickStatus, before: float):",
"def __delete_job_status(self, job: Job):\n\n keys = self._get_keys(f'jobstatus:{job.id}:*')\n for key in keys:\n self.redis_client.delete(key)",
"def _cleanupDownCounts(self):\n now = datetime.now(... | [
"0.6632468",
"0.5895949",
"0.5505163",
"0.5471308",
"0.5446002",
"0.5350745",
"0.5347354",
"0.53052574",
"0.5266057",
"0.5187827",
"0.51671374",
"0.516343",
"0.51591295",
"0.51247317",
"0.5116081",
"0.5100693",
"0.5090704",
"0.50796276",
"0.5065009",
"0.50444114",
"0.5044082"... | 0.7620381 | 0 |
Get tick stats for a given job. | def get_job_tick_stats(self, job_origin_id): | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_job_stats(self, job_name):\n return self.manager.get_job_stats(job_name)",
"def get_job_ticks(self, job_origin_id):",
"def stats(self):\n resp = self.server.request(\"get\", \"/jobs/%s/%s/stats\" %\n (self.sessionid, self.name))\n return self.server.json_body(resp)",... | [
"0.686602",
"0.6589052",
"0.61278665",
"0.59427047",
"0.58626354",
"0.57995313",
"0.5791054",
"0.57735854",
"0.56960267",
"0.5658474",
"0.56300795",
"0.5602183",
"0.55705327",
"0.55694175",
"0.5538241",
"0.5442942",
"0.54197836",
"0.5391828",
"0.53831077",
"0.53716314",
"0.53... | 0.7929325 | 0 |
Perform any needed migrations | def upgrade(self): | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def migration():",
"def post_migrations(self):",
"def migrate(self):\n\tpass",
"def run_migration_checks():\n check_model_state()\n check_migration_state()",
"def perform_migration():\n with cd(env.code_dir):\n with _virtualenv():\n sudo('python manage.py migrate --settings=prod_... | [
"0.77959275",
"0.77799666",
"0.7711844",
"0.73845613",
"0.73517853",
"0.73338085",
"0.7192316",
"0.7185039",
"0.715605",
"0.71404064",
"0.7015841",
"0.6983788",
"0.6967566",
"0.68327975",
"0.68189925",
"0.680037",
"0.6735632",
"0.66867834",
"0.66476285",
"0.66215956",
"0.6595... | 0.0 | -1 |
Allows for optimizing database connection / use in the context of a long lived dagit process | def optimize_for_dagit(self, statement_timeout): | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def db():\n raise TimeoutError",
"def _db_connection(self):\n pass",
"def main():\n config = Config.init_from_env()\n\n while True:\n logger.info('running query...')\n\n conn = connect_to_db(config)\n with conn.cursor() as cur:\n cur.execute(\"\"\"SELECT datname ... | [
"0.6886876",
"0.6700232",
"0.6482189",
"0.6420081",
"0.633664",
"0.6292243",
"0.6285649",
"0.6235156",
"0.61463004",
"0.6138491",
"0.6135904",
"0.6121325",
"0.61131597",
"0.6103187",
"0.6099227",
"0.6063172",
"0.60518104",
"0.60201025",
"0.60201025",
"0.60201025",
"0.60201025... | 0.0 | -1 |
Initialize the source object | def __init__(self, RA, DEC, AST, I_data, Q_data, U_data, V_data):
self.RA = RA
self.DEC = DEC
self.AST = AST
self.I_data = I_data
self.Q_data = Q_data
self.U_data = U_data
self.V_data = V_data
self.fit_p = None
self.e_fit_p = None
self.good... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __init__(self, source):\n self._source = source",
"def __init__(self, source):\n self.source = source",
"def __init__(self, source):\n self.source = source",
"def __init__(self, source):\r\n self.source = source",
"def __init__(self, source, *args, **kwargs):\n super(... | [
"0.84137446",
"0.81543994",
"0.81543994",
"0.81408143",
"0.8004293",
"0.7625181",
"0.71825546",
"0.71825546",
"0.71825546",
"0.71825546",
"0.71825546",
"0.71825546",
"0.71825546",
"0.71825546",
"0.71547294",
"0.71457464",
"0.7138613",
"0.7136901",
"0.7135622",
"0.7135622",
"0... | 0.0 | -1 |
Fit cluster I vs RAcos(Dec) and Dec | def fit(self, filename, **options):
amp_guess = np.max(self.I_data)
center_x_guess = self.RA[self.I_data.argmax()]
center_y_guess = self.DEC[self.I_data.argmax()]
# cos dec correction
center_x_guess = center_x_guess*np.cos(np.deg2rad(center_y_guess))
sigma_x_guess = optio... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def fit(self):\n self.cluseter_agglomerative(n_clusters=20, linkage='average', iterate=5)\n self.sub_clustering(n_clusters=3, index_cluster=[79], linkage='complete')\n self.merge_clusters([[0,9,53],[1,83],[46,35,67],[88,23],[6,68]])\n self.merge_clusters([[6,33,52],[17,14]])\n se... | [
"0.6232339",
"0.5684823",
"0.5617525",
"0.553194",
"0.547829",
"0.541152",
"0.54086167",
"0.53931034",
"0.53846407",
"0.537234",
"0.5349465",
"0.53037167",
"0.5292465",
"0.5263835",
"0.5233318",
"0.5226791",
"0.5207712",
"0.520619",
"0.52058524",
"0.51855236",
"0.5173525",
... | 0.0 | -1 |
Converts a series of consumption data into a lagged, scaled sample. | def prepare_training_data(consumption_series, lag):
# scale training data
scaler = MinMaxScaler(feature_range=(-1, 1))
consumption_vals = scaler.fit_transform(consumption_series.values.reshape(-1, 1))
# convert consumption series to lagged features
consumption_lagged = create_lagged_featu... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def downsample(time_series,res = '0.2S'):\n\n Nvalues = len(time_series.index)\n samplerate = 1/ ((time_series.timestamp[Nvalues-1] - time_series.timestamp[0]) / Nvalues)\n timestart = dt.datetime(1970, 1, 1, 0, 0, 0, 0) #dt.datetime.now()\n start = pd.Timestamp(timestart)\n end = pd.Timestamp(times... | [
"0.58058953",
"0.5682728",
"0.5602917",
"0.558418",
"0.55332106",
"0.5464574",
"0.54036844",
"0.53578377",
"0.5353402",
"0.52929103",
"0.5281908",
"0.524232",
"0.52113897",
"0.5205267",
"0.51940095",
"0.5193135",
"0.51782006",
"0.5166779",
"0.51162773",
"0.5104673",
"0.508758... | 0.6613549 | 0 |
Uses last hour's prediction to generate next for num_pred_hours, initialized by most recent cold start prediction. Inverts scale of predictions before return. | def generate_hourly_forecast(num_pred_hours, consumption, model, scaler, lag):
# allocate prediction frame
preds_scaled = np.zeros(num_pred_hours)
# initial X is last lag values from the cold start
X = scaler.transform(consumption.values.reshape(-1, 1))[-lag:]
# forecast
for i ... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def predict(self):\n # format data\n df = self.normalize(self.daily)\n x = df.index.astype(np.int64).values.reshape(-1, 1)\n y = self.normalize(df[['Adj Close']]).values\n\n # format time\n one_day_time = 86400000000000\n x_tomorrow = x[-1] + one_day_time\n x... | [
"0.6147885",
"0.60168874",
"0.5948102",
"0.59448326",
"0.5736109",
"0.5730648",
"0.5723199",
"0.5713034",
"0.57063735",
"0.56251585",
"0.56192535",
"0.5606722",
"0.5595283",
"0.5580066",
"0.55339456",
"0.5530532",
"0.5509373",
"0.550588",
"0.54749984",
"0.5469587",
"0.5446055... | 0.7551356 | 0 |
Recursively parse requirements from nested pip files. | def parse_reqs(req_path='./requirements.txt'):
req = []
with codecs.open(req_path, 'r') as handle:
# remove comments and empty lines
lines = (line.strip() for line in handle
if line.strip() and not line.startswith('#'))
for line in lines:
# check for nested ... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def parse_req_file(req_file, verbatim=False):\n req_list = []\n requirements = req_file.readlines()\n for requirement in requirements:\n requirement_no_comments = requirement.split(\"#\")[0].strip()\n\n # if matching requirement line (Thing==1.2.3), update dict, continue\n req_match =... | [
"0.6786804",
"0.6664783",
"0.6641698",
"0.66211325",
"0.66119075",
"0.65428483",
"0.6501512",
"0.6493474",
"0.63900733",
"0.63147587",
"0.6300729",
"0.62659717",
"0.61893356",
"0.6095277",
"0.60434747",
"0.60229355",
"0.6022184",
"0.59152234",
"0.5904207",
"0.58895177",
"0.58... | 0.69987404 | 0 |
Parse contents of the README. | def parse_readme():
# Get the long description from the relevant file
readme_path = path.join(here, 'README.md')
with codecs.open(readme_path, encoding='utf-8') as handle:
desc = handle.read()
return desc | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_readme():\n readme = Path(README_PATH).read_text()\n Actions.read_from_md(readme)",
"def readme():\n with open('README.md') as readme_file:\n return readme_file.read()",
"def readme():\n with open('README.md') as _file:\n return _file.read()",
"def readme():\n with open(... | [
"0.6963818",
"0.68499607",
"0.6843953",
"0.68420315",
"0.67245597",
"0.6724281",
"0.66542006",
"0.663165",
"0.65984565",
"0.6555213",
"0.65377915",
"0.6471558",
"0.6464941",
"0.6371735",
"0.6349831",
"0.63303596",
"0.6280362",
"0.6276107",
"0.6224707",
"0.62189406",
"0.621518... | 0.8034528 | 0 |
Get the string representation of the model | def __str__(self):
return json.dumps(self.to_dict()) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __str__(self):\n return super().__str__() + self.model.__str__()",
"def __str__(self) -> str:\n # noinspection PyUnresolvedReferences\n opts = self._meta\n if self.name_field:\n result = str(opts.get_field(self.name_field).value_from_object(self))\n else:\n ... | [
"0.8463654",
"0.7898162",
"0.77145106",
"0.77145106",
"0.76879215",
"0.7655091",
"0.7650248",
"0.757232",
"0.75623566",
"0.7551965",
"0.7551965",
"0.7551292",
"0.7549884",
"0.7536579",
"0.7519798",
"0.7517772",
"0.75146",
"0.745953",
"0.74590117",
"0.74517524",
"0.7426484",
... | 0.0 | -1 |
Given the pixels which are mapped to the closed field line region, return the pixel with the largest radial coordinate for each poloidal coordinate. | def surface_line(sep_pixels, mode='max'):
# Index all pixels radially
lin_array = np.repeat(np.arange(64), 64).reshape(64, 64).T
# Apply the mask
la_masked = ma.array(lin_array, mask=sep_pixels)
# Return the maximum radial indices for each poloidal position
if (mode == 'max'):
return ... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_max_point(image):\r\n max_value= 0\r\n better_point= None\r\n for line in range(len(image)):\r\n for column in range(len(image[0])):\r\n if image[line][column]>max_value:\r\n max_value= image[line][column]\r\n better_point = [line,column]\r\n retu... | [
"0.63896453",
"0.6343119",
"0.6170493",
"0.61105126",
"0.6010083",
"0.58846235",
"0.5847404",
"0.5814799",
"0.57171196",
"0.5709415",
"0.5709284",
"0.56938785",
"0.5640586",
"0.56322056",
"0.5615116",
"0.5602537",
"0.56014585",
"0.557604",
"0.55760396",
"0.55375856",
"0.55284... | 0.5977568 | 5 |
Computes cross entropy between targets (encoded as onehot vectors) and predictions. | def cross_entropy_loss(predictions, targets, epsilon=1e-12):
predictions = np.clip(predictions, epsilon, 1. - epsilon)
N = predictions.shape[0]
ce = -np.sum(targets*np.log(predictions+1e-9))/N
return ce | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def cross_entropy(predictions, targets):\n likelihood = targets * np.log(predictions)\n return -np.sum(likelihood) / predictions.shape[0]",
"def cross_entropy(predicted, target):\n batch_size, num_classes = predicted.shape\n\n e_x = predicted.exp()\n log_e_x = e_x.log()\n a = log_sum_x_trick(pr... | [
"0.7892568",
"0.75793386",
"0.75247025",
"0.751529",
"0.7430935",
"0.73616475",
"0.73616475",
"0.7344533",
"0.7198154",
"0.7078395",
"0.7066774",
"0.7011896",
"0.69843245",
"0.6977101",
"0.69487417",
"0.69227016",
"0.6911786",
"0.68707484",
"0.685989",
"0.68182206",
"0.679910... | 0.7006511 | 12 |
get a mapping of dn and domain name, sid | def domainnames(l):
mapping = {}
# locate all the samba domains in the ldap
r = l.search_s('dc=elex', ldap.SCOPE_SUBTREE, '(objectClass=sambaDomain)', ['sambaDomainName','sambaSID'])
for dn, entry in r:
mapping[dn] = (entry['sambaDomainName'][0], entry['sambaSID'][0])
return mapping | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _get_domain_mappings(domain_to_intents: Dict) -> Dict:\n domain2id = {}\n domains = list(domain_to_intents)\n for index, domain in enumerate(domains):\n domain2id[domain] = index\n return domain2id",
"def get_ingkey_ndbno_map(session):\n alias_ndbno = {}\n\n for a... | [
"0.6582829",
"0.56286347",
"0.5624903",
"0.5525862",
"0.55090404",
"0.55004203",
"0.5462208",
"0.5441851",
"0.53912187",
"0.53654265",
"0.535627",
"0.5353621",
"0.53343844",
"0.5332277",
"0.5325799",
"0.52989244",
"0.52860177",
"0.5236246",
"0.51990306",
"0.5192915",
"0.51833... | 0.7258395 | 0 |
get the domain ldap root for the given dn >>> dn = "sambaDomainName=IEPERTEST,dc=Ieper,dc=elex" >>> domainroot(dn) 'dc=Ieper,dc=elex' | def domainroot(d):
dn = str2dn(d)
dn.pop(0)
return dn2str(dn) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_root_domain(url):\n if url is None:\n return ''\n\n http = text.find_between(url, 'http://', '/')\n https = text.find_between(url, 'https://', '/')\n if http != '':\n if http.startswith('www.'):\n return http[4:]\n else:\n return http\n else:\n ... | [
"0.59731376",
"0.58926845",
"0.58213747",
"0.57498807",
"0.5353788",
"0.53386265",
"0.5327255",
"0.53180313",
"0.52835435",
"0.5229424",
"0.51967984",
"0.51759446",
"0.5168741",
"0.512568",
"0.51203126",
"0.5037568",
"0.5010395",
"0.49844295",
"0.49844295",
"0.49776703",
"0.4... | 0.78520805 | 0 |
get a list of dn's of all the sambaaccounts for a given domainroot | def sambaaccountsindomainroot(domainroot, l):
dns = {}
r = l.search_s(domainroot, ldap.SCOPE_SUBTREE, '(objectClass=sambaSamAccount)', ['uidNumber'])
for dn, entry in r:
try:
dns[dn] = entry['uidNumber'][0]
except KeyError:
sys.stderr.write("dn %s has no uidNumber!\n" % dn)
return dns | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def domainnames(l):\n mapping = {}\n # locate all the samba domains in the ldap\n r = l.search_s('dc=elex', ldap.SCOPE_SUBTREE, '(objectClass=sambaDomain)', ['sambaDomainName','sambaSID'])\n for dn, entry in r:\n mapping[dn] = (entry['sambaDomainName'][0], entry['sambaSID'][0])\n return mapping",
"def ge... | [
"0.66664594",
"0.6225633",
"0.6047989",
"0.5977809",
"0.5909574",
"0.58053553",
"0.5803501",
"0.57814616",
"0.57603765",
"0.57531065",
"0.5686316",
"0.5632562",
"0.56190073",
"0.5612749",
"0.5571444",
"0.5562495",
"0.55482376",
"0.55228823",
"0.5510787",
"0.55037886",
"0.5493... | 0.790107 | 0 |
update an account with a new sid number | def updatesid(dn, sid, l):
mod_attrs = [(ldap.MOD_REPLACE, 'sambaSID', sid )]
l.modify_s(dn, mod_attrs) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def update(self, account):\n model = models.load('Account', account)\n return self.client.update_account(model=model)",
"def updateAccount(accountNumber: int, payload: str ):\n statement = \"update account set \" + payload+ f\" where account_number = {accountNumber}\"\n cursor = connection.cu... | [
"0.68811387",
"0.65051657",
"0.6367951",
"0.6271997",
"0.62145466",
"0.61361814",
"0.6134124",
"0.6107987",
"0.60869086",
"0.59739476",
"0.5946718",
"0.5814789",
"0.5802594",
"0.5763696",
"0.5756033",
"0.5756033",
"0.5756033",
"0.5756033",
"0.5756033",
"0.5756033",
"0.5725383... | 0.6992691 | 0 |
returns the squareneighborhoodenvironment second to last column is the action last column is the outcome | def get_all_patterns(self, game_state: Union[GridGameState, np.ndarray], action=None,
next_game_state: Union[GridGameState, np.ndarray, None] = None,
differential=False):
if isinstance(game_state, GridGameState):
game_state_grid = game_state.get_tile... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_transition(self, row, col, action, tot_row, tot_col):\n\n '''\n Expand the grid of the environment to handle when the \n agent decides to move in the direction of a wall \n '''\n state_probabilities = np.zeros((int(np.sqrt(self.env.observation_space.n)) + 2, int(np.sqrt(s... | [
"0.62888545",
"0.62888545",
"0.61843216",
"0.6090792",
"0.60547835",
"0.5863124",
"0.58260244",
"0.5782786",
"0.5765824",
"0.57480395",
"0.5636127",
"0.5619147",
"0.55536985",
"0.55308455",
"0.548652",
"0.5456624",
"0.5455377",
"0.5453422",
"0.5447977",
"0.5441266",
"0.542942... | 0.0 | -1 |
r"""Create input tensors given the list of prompt tokens. | def _create_input(inputs: List[Tensor], initial: bool = False) \
-> Dict[str, Tensor]:
word_embed = torch.stack(inputs, dim=0)
seq_len, batch_size, embed_dim = word_embed.size()
if not initial:
# Add a dummy token at the end that stands for the token
# to pred... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_inputs(title, list_labels):\n print(f\"{title}\")\n # list which holds the input answers from user\n user_inputs = []\n for item in list_labels:\n user_inputs.append(input(f\"{item}: \"))\n return user_inputs",
"def get_inputs(list_labels, title):\n inputs = []\n\n print(f\"\\... | [
"0.5943801",
"0.5874354",
"0.5750032",
"0.5678299",
"0.55471927",
"0.55375314",
"0.55304873",
"0.55301905",
"0.5503433",
"0.55009323",
"0.54978406",
"0.5443688",
"0.54417616",
"0.5436629",
"0.54334015",
"0.537875",
"0.53765416",
"0.5369801",
"0.53374743",
"0.5288369",
"0.5286... | 0.59976834 | 0 |
r"""Perform autoregressive decoding using XLNet. The algorithm is | def forward(self, # type: ignore
start_tokens: torch.LongTensor,
memory: Optional[State] = None,
cache_len: int = 512,
max_decoding_length: Optional[int] = 500,
recompute_memory: bool = True,
print_steps: bool = False,
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def forward(self, x):\n # Encoder1 --block1\n encode_block1 = self.conv_encoder1(x)\n if self.residus[0] == 1:\n encode_block1 += self.residual_shortcut1(x)\n encode_pool1 = self.max_pool_encoder1(encode_block1)\n\n # Encoder2 --block2\n encode_block2 ... | [
"0.5537087",
"0.55339885",
"0.54327846",
"0.54184777",
"0.5396983",
"0.5360435",
"0.53085345",
"0.52792335",
"0.5273877",
"0.52571446",
"0.5235639",
"0.5223918",
"0.5216948",
"0.5197833",
"0.51948017",
"0.5164546",
"0.5149774",
"0.5149628",
"0.51201344",
"0.5116834",
"0.51032... | 0.0 | -1 |
Get the symbol definition and random weight of a network | def get_network(name, batch_size, dtype='float32', ir='relay'):
if ir == 'relay':
from tvm.relay import testing
else:
raise Exception("ir must be `relay`, but you used `{}`".format(ir))
input_shape = (batch_size, 3, 224, 224)
if name == 'mobilenet':
net, params = testing.mobilen... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_weights(self):",
"def get_weights(net):\n return [p.data for p in net.parameters()]",
"def wsngraph():\n G = nx.Graph()\n G.add_node(1)\n G.add_node(2)\n G.add_node(3)\n G.add_node(4)\n G.add_node(5)\n G.add_node(6)\n G.add_node(7)\n G.add_node(8)\n G.add_node(9)\n G... | [
"0.6108389",
"0.5802951",
"0.5793653",
"0.5750533",
"0.57088494",
"0.56437266",
"0.5613346",
"0.5592894",
"0.554547",
"0.55027777",
"0.5497525",
"0.5497525",
"0.54788816",
"0.54666185",
"0.54370296",
"0.5430508",
"0.5430508",
"0.54239696",
"0.5417186",
"0.54112595",
"0.540771... | 0.0 | -1 |
given a list of system dicts and fact namespace, return a dict of comparisons, along with a dict of system data | def build_comparisons(inventory_service_systems, fact_namespace):
fact_comparison = _select_applicable_info(inventory_service_systems, fact_namespace)
system_mappings = [_system_mapping(system) for system in inventory_service_systems]
return {'facts': fact_comparison, 'systems': system_mappings} | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _select_applicable_info(systems, fact_namespace):\n # create dicts of id + info\n ids_and_info = [_system_facts_and_id(system, fact_namespace) for system in systems]\n\n # union the keys into one big set\n available_info_names = set()\n for fact_ids in ids_and_info:\n available_info_names... | [
"0.6751611",
"0.64506835",
"0.59273654",
"0.54507446",
"0.5415962",
"0.53574604",
"0.52777123",
"0.5273807",
"0.52517354",
"0.5235233",
"0.5234047",
"0.52329373",
"0.5217976",
"0.5211301",
"0.51864505",
"0.5144741",
"0.5138967",
"0.51296264",
"0.5087264",
"0.50721955",
"0.502... | 0.7789255 | 0 |
Take a list of systems with fact namespace, and output a "pivoted" list of facts, where each fact key has a dict of systems and their values. This is useful when comparing facts across systems. | def _select_applicable_info(systems, fact_namespace):
# create dicts of id + info
ids_and_info = [_system_facts_and_id(system, fact_namespace) for system in systems]
# union the keys into one big set
available_info_names = set()
for fact_ids in ids_and_info:
available_info_names |= fact_ids... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _find_facts_for_namespace(system, fact_namespace):\n # TODO: we are assuming we just need to handle one namespace\n for facts in system['facts']:\n if facts['namespace'] == fact_namespace:\n dataframe = json_normalize(_flatten_list_facts(facts['facts']), sep='.')\n # TODO: we... | [
"0.599296",
"0.57565916",
"0.5621143",
"0.5443486",
"0.5262978",
"0.5095327",
"0.50548106",
"0.50017583",
"0.48622108",
"0.48508248",
"0.4813298",
"0.47710633",
"0.4763719",
"0.46962604",
"0.46861643",
"0.4658715",
"0.4652692",
"0.46504876",
"0.46204603",
"0.46028978",
"0.459... | 0.4845707 | 10 |
return the facts for the given namespace | def _find_facts_for_namespace(system, fact_namespace):
# TODO: we are assuming we just need to handle one namespace
for facts in system['facts']:
if facts['namespace'] == fact_namespace:
dataframe = json_normalize(_flatten_list_facts(facts['facts']), sep='.')
# TODO: we should tr... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _facts(facts):\n return {'swift_facts': facts}",
"def get_all_by_namespace(context, namespace_name, session):\n\n # namespace get raises an exception if not visible\n namespace = namespace_api.get(\n context, namespace_name, session)\n\n db_recs = (\n session.query(models.Metade... | [
"0.6179005",
"0.60052156",
"0.5814096",
"0.57992786",
"0.5792006",
"0.57476157",
"0.5712751",
"0.56517786",
"0.562293",
"0.5562041",
"0.55495805",
"0.55207497",
"0.55160123",
"0.5473524",
"0.5363391",
"0.5360087",
"0.5358159",
"0.53243786",
"0.53009593",
"0.5258396",
"0.52021... | 0.71858376 | 0 |
Pull the system facts dict out from a system record and add the ID to the dict | def _system_facts_and_id(system, fact_namespace):
facts_and_id = _find_facts_for_namespace(system, fact_namespace)
facts_and_id[SYSTEM_ID_KEY] = system[SYSTEM_ID_KEY]
return facts_and_id | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _system_mapping(system):\n return {'id': system['id'], 'fqdn': system['fqdn'], 'last_updated': system['updated']}",
"def create_system_data():\n system_data = dict()\n system_data['system'] = dict()\n system_data['system']['primary'] = dict()\n system_data['system']['primary']['controllers'] =... | [
"0.6592336",
"0.5519249",
"0.52790916",
"0.52427906",
"0.511191",
"0.51064813",
"0.5094681",
"0.50490534",
"0.5019681",
"0.50044346",
"0.49629274",
"0.49606988",
"0.49120373",
"0.49032432",
"0.48786232",
"0.4853964",
"0.4850545",
"0.48393828",
"0.483793",
"0.48377714",
"0.481... | 0.6877349 | 0 |
Take an individual fact, search for it across all systems, and create a dict of each system's ID and fact value. Additionally, add a "state" field that says if all systems have the same values or different values. Note that when passing in "systems" to this method, the ID needs to be listed as a fact key. | def _create_comparison(systems, info_name):
info_comparison = COMPARISON_DIFFERENT
system_id_values = [{'id': x['id'], 'value': x.get(info_name, "FACT_NOT_SET")} for x in systems]
system_values = {system['value'] for system in system_id_values}
if "FACT_NOT_SET" in system_values:
info_compari... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _system_facts_and_id(system, fact_namespace):\n facts_and_id = _find_facts_for_namespace(system, fact_namespace)\n facts_and_id[SYSTEM_ID_KEY] = system[SYSTEM_ID_KEY]\n return facts_and_id",
"def _select_applicable_info(systems, fact_namespace):\n # create dicts of id + info\n ids_and_info = [... | [
"0.61924046",
"0.5710258",
"0.5444056",
"0.5426606",
"0.5076391",
"0.50066507",
"0.5004025",
"0.49934798",
"0.49750796",
"0.49106765",
"0.46943542",
"0.4599882",
"0.4599882",
"0.4599882",
"0.45977145",
"0.45152375",
"0.45084983",
"0.4507461",
"0.44489235",
"0.4419014",
"0.441... | 0.5402677 | 4 |
create a header mapping for one system | def _system_mapping(system):
return {'id': system['id'], 'fqdn': system['fqdn'], 'last_updated': system['updated']} | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def setSoapHdr(self):\n mapHdrData = {}\n\n for task, taskMap in self.mapHdrRaw.items():\n if len(taskMap) == 0:\n # skip this task if there are no elements in it\n continue\n \n taskStruct = structType(data = taskMap)\n\n m... | [
"0.6216434",
"0.620413",
"0.6202114",
"0.60866916",
"0.6065891",
"0.6005825",
"0.6005363",
"0.5992969",
"0.59732544",
"0.59199125",
"0.5913567",
"0.5901967",
"0.5893599",
"0.5864299",
"0.5859369",
"0.5817306",
"0.5784841",
"0.5782217",
"0.57806534",
"0.5770666",
"0.5756628",
... | 0.54142433 | 49 |
Takes a parameter of a database table, database column and input value. Open a connection to the database. Inserts the given input to the given database column in the given database table. Saves and closes the connection. | def insertData(table, column, input):
try:
con = sqlite3.connect('PampDb.db')
cur = con.cursor()
cur.execute("INSERT INTO '" + table + "' (" + column + ") VALUES ('" + input + "')")
con.commit()
con.close()
except:
print('Could not run function insertData from DbController') | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def commit_to_database(self, table, output):\n try:\n # TODO: Is this the correct method for this?\n with SESSION.begin_nested():\n i = insert(getattr(db, table))\n vals = i.values(output)\n SESSION.execute(vals) # TODO: What is this?\n ... | [
"0.6499374",
"0.6467502",
"0.6432609",
"0.642731",
"0.6394885",
"0.6324648",
"0.6303387",
"0.6270057",
"0.6249122",
"0.6245554",
"0.61839783",
"0.61709726",
"0.61705667",
"0.61124736",
"0.60817313",
"0.6029818",
"0.6000239",
"0.5996185",
"0.59731865",
"0.5967328",
"0.5955773"... | 0.8079351 | 0 |
Takes a parameter of a database table. Open a connection to the database. Asks for the latest added row in database. Saves and closes the connection. Returns the id of the row. | def getLatestId(table):
try:
con = sqlite3.connect('PampDb.db')
cur = con.cursor()
cur.execute("SELECT max( measurementId ) FROM Measurement")
id = cur.fetchone()
con.commit()
con.close()
return id[0]
except:
print('Could not run function getLatestId from DbController') | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def insert(q, *params):\n db = Database()\n db.cur.execute(q, *params)\n ret_id = db.cur.lastrowid\n db.con.close()\n return ret_id",
"def getLastId(self,table):\n\tif self.dbType==\"sqlite\":\n\t query = \"SELECT LAST_INSERT_ROWID() FROM %s LIMIT 1\"%table\n\telse:\n\t query = \"SELECT LAST_I... | [
"0.66030145",
"0.6529629",
"0.649401",
"0.640542",
"0.6362824",
"0.6284276",
"0.62791777",
"0.6267712",
"0.62239826",
"0.62156045",
"0.6184368",
"0.6179019",
"0.6103859",
"0.6077099",
"0.60505813",
"0.598806",
"0.5979676",
"0.59573686",
"0.5955495",
"0.5923925",
"0.5921158",
... | 0.6293333 | 5 |
Takes a parameter of a database table and a name. Open a connection to the database. Selects all rows from given table where the name matches the given name. Checks if there is no rows and save the given name if not. Returns an object of the organizations data. Saves and closes the connection. | def checkIfOrganisationExists(table, name):
try:
con = sqlite3.connect('PampDb.db')
cur = con.cursor()
cur.execute("SELECT * FROM " + table + " WHERE name='" + name + "'")
ob = cur.fetchall()
if not ob:
cur.execute("INSERT INTO '" + table + "' (name) VALUES ('" + name + "')")
con.commit()
cur.execu... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def getAllWhereNameIs2(table, name, orgName):\n\ttry:\n\t\tcon = sqlite3.connect('PampDb.db')\n\t\tcur = con.cursor()\n\t\tcur.execute(\"SELECT * FROM \" + table + \" WHERE name like'\" + name + \"%' and organisationId like (SELECT organisationId FROM Organisation WHERE name like '\" + orgName + \"' )\")\n\t\tob =... | [
"0.6584832",
"0.56436473",
"0.56424224",
"0.5445914",
"0.53992385",
"0.5322616",
"0.5317675",
"0.5276783",
"0.52582735",
"0.5035784",
"0.49893025",
"0.49835908",
"0.49494904",
"0.4946467",
"0.4929817",
"0.49230644",
"0.49134114",
"0.490836",
"0.48627073",
"0.48460436",
"0.482... | 0.6698518 | 0 |
Takes a parameter of a database table, a name and a foreign key. Open a connection to the database. Selects all rows from given table where the name matches the given name. Checks if there is no rows with matching name and save the given name if not the return a object of the measurement object. Otherwise loops through... | def checkIfMeasuringObjectExists(table, name, fk):
try:
con = sqlite3.connect('PampDb.db')
cur = con.cursor()
cur.execute("SELECT * FROM " + table + " WHERE name='" + name + "'")
ob = cur.fetchall()
bo = False
if not ob:
cur.execute("INSERT INTO '" + table + "' (name, organisationId) VALUES ('" + name +... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def checkIfAntennaExists(table, name, fk):\n\ttry:\n\t\tcon = sqlite3.connect('PampDb.db')\n\t\tcur = con.cursor()\n\t\tcur.execute(\"SELECT * FROM \" + table + \" WHERE name='\" + name + \"'\")\n\t\tob = cur.fetchall()\n\t\tbo = False\n\t\tif not ob:\n\t\t\tcur.execute(\"INSERT INTO '\" + table + \"' (name, measu... | [
"0.5825028",
"0.54133224",
"0.52821904",
"0.5057512",
"0.4970804",
"0.4853761",
"0.483541",
"0.48263484",
"0.47983626",
"0.47972316",
"0.47867805",
"0.47804394",
"0.47424772",
"0.473968",
"0.473309",
"0.4724627",
"0.47091377",
"0.4699343",
"0.46908638",
"0.46786463",
"0.46757... | 0.6349163 | 0 |
Takes a parameter of a database table, a name and a foreign key. Open a connection to the database. Selects all rows from given table where the name matches the given name. Checks if there is no rows with matching name and save the given name if not the return a object of the antenna. Otherwise loops through the list o... | def checkIfAntennaExists(table, name, fk):
try:
con = sqlite3.connect('PampDb.db')
cur = con.cursor()
cur.execute("SELECT * FROM " + table + " WHERE name='" + name + "'")
ob = cur.fetchall()
bo = False
if not ob:
cur.execute("INSERT INTO '" + table + "' (name, measuringObjectId) VALUES ('" + name + "', ... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def checkIfMeasuringObjectExists(table, name, fk):\n\ttry:\n\t\tcon = sqlite3.connect('PampDb.db')\n\t\tcur = con.cursor()\n\t\tcur.execute(\"SELECT * FROM \" + table + \" WHERE name='\" + name + \"'\")\n\t\tob = cur.fetchall()\n\t\tbo = False\n\t\tif not ob:\n\t\t\tcur.execute(\"INSERT INTO '\" + table + \"' (nam... | [
"0.5775556",
"0.55818015",
"0.52031857",
"0.5173361",
"0.51214767",
"0.50995225",
"0.49776843",
"0.49723682",
"0.49298635",
"0.49137506",
"0.49100566",
"0.4876978",
"0.48237494",
"0.48185825",
"0.47975516",
"0.47720587",
"0.47643965",
"0.476333",
"0.47346067",
"0.47134042",
"... | 0.6691352 | 0 |
Takes a parameter of a database table. Open a connection to the database. Collects all rows from that table and return as a list. Saves and closes the connection. | def getAllName(table):
try:
con = sqlite3.connect('PampDb.db')
cur = con.cursor()
cur.execute("SELECT * FROM " + table)
names = cur.fetchall()
con.commit()
con.close()
return names
except:
print('Could not run function getAllName from DbController') | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_all_rows(table, db_file):\n \n try:\n conn, c = connect_to_db(db_file) \n c.execute('SELECT * FROM {t}'.format(t=safe(table)))\n allrows = c.fetchall()\n conn.close()\n return allrows\n except Exception as e:\n print(\"Error when trying to fetch all row... | [
"0.71056473",
"0.6945642",
"0.69364375",
"0.69354993",
"0.6890469",
"0.6853193",
"0.68162286",
"0.6810731",
"0.68048996",
"0.67670256",
"0.6726298",
"0.6682274",
"0.6635236",
"0.6629247",
"0.66119444",
"0.6593554",
"0.6505351",
"0.64627415",
"0.6428178",
"0.6420916",
"0.63942... | 0.0 | -1 |
Takes a parameter of a database table and a name. Open a connection to the database. Select the rowa from given table where name matches the given name. If no match returns an empty string otherwise returns an object of the matching organization. Saves and closes the connection. | def getAllWhereNameIs(table, name):
try:
con = sqlite3.connect('PampDb.db')
cur = con.cursor()
cur.execute("SELECT * FROM " + table + " WHERE name like'" + name + "%'")
ob = cur.fetchall()
if not ob:
return ""
else:
obje = ob[0]
return obje
con.commit()
con.close()
except:
print('Could not ... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def getAllWhereNameIs2(table, name, orgName):\n\ttry:\n\t\tcon = sqlite3.connect('PampDb.db')\n\t\tcur = con.cursor()\n\t\tcur.execute(\"SELECT * FROM \" + table + \" WHERE name like'\" + name + \"%' and organisationId like (SELECT organisationId FROM Organisation WHERE name like '\" + orgName + \"' )\")\n\t\tob =... | [
"0.7150075",
"0.644911",
"0.62818587",
"0.6092429",
"0.6091963",
"0.5959734",
"0.59330434",
"0.5920153",
"0.58863497",
"0.5806769",
"0.5781294",
"0.5738642",
"0.5728878",
"0.57224065",
"0.5719498",
"0.5671159",
"0.56409097",
"0.5638782",
"0.5627955",
"0.55980676",
"0.5566317"... | 0.6432116 | 2 |
Takes a parameter of a database table, a name and a organization name. Open a connection to the database. Select the row from given table where name matches the given name and the foreign key matches the organisationsId from the organization with the given name. If no match returns an empty string otherwise returns an ... | def getAllWhereNameIs2(table, name, orgName):
try:
con = sqlite3.connect('PampDb.db')
cur = con.cursor()
cur.execute("SELECT * FROM " + table + " WHERE name like'" + name + "%' and organisationId like (SELECT organisationId FROM Organisation WHERE name like '" + orgName + "' )")
ob = cur.fetchall()
if not ob... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def checkIfOrganisationExists(table, name):\n\ttry:\n\t\tcon = sqlite3.connect('PampDb.db')\n\t\tcur = con.cursor()\n\t\tcur.execute(\"SELECT * FROM \" + table + \" WHERE name='\" + name + \"'\")\n\t\tob = cur.fetchall()\n\n\t\tif not ob:\n\t\t\tcur.execute(\"INSERT INTO '\" + table + \"' (name) VALUES ('\" + name... | [
"0.649052",
"0.58591986",
"0.5553993",
"0.541119",
"0.53702897",
"0.53158283",
"0.5298932",
"0.52573925",
"0.5228335",
"0.51941264",
"0.5193201",
"0.51424927",
"0.5105643",
"0.5103786",
"0.50759363",
"0.50589263",
"0.50571203",
"0.50493544",
"0.50341445",
"0.50220186",
"0.502... | 0.6875108 | 0 |
Takes a parameter of a database table, a name, a measuring object name and a organization name. Open a connection to the database. Select the row from given table where name matches the given name and the foreign key matches the measuringObjectId from the measuring object with the given name, which foreign key should m... | def getAllWhereNameIs3(table, name, objectName, orgName):
try:
con = sqlite3.connect('PampDb.db')
cur = con.cursor()
cur.execute("SELECT * FROM " + table + " WHERE name like'" + name + "%' and measuringObjectId like (SELECT measureingObjectId FROM MeasuringObject WHERE name like'" + objectName + "' and organisat... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def checkIfMeasuringObjectExists(table, name, fk):\n\ttry:\n\t\tcon = sqlite3.connect('PampDb.db')\n\t\tcur = con.cursor()\n\t\tcur.execute(\"SELECT * FROM \" + table + \" WHERE name='\" + name + \"'\")\n\t\tob = cur.fetchall()\n\t\tbo = False\n\t\tif not ob:\n\t\t\tcur.execute(\"INSERT INTO '\" + table + \"' (nam... | [
"0.647255",
"0.59009075",
"0.5862029",
"0.5327575",
"0.5271932",
"0.51865",
"0.51475155",
"0.5062982",
"0.50051904",
"0.4929531",
"0.48816788",
"0.4817058",
"0.47862557",
"0.47796994",
"0.47717777",
"0.4741117",
"0.47383088",
"0.47381008",
"0.47295547",
"0.46936247",
"0.46817... | 0.6301946 | 1 |
Checks that the default parameters of a CoolantChannelRingStraight are correct. | def test_default_parameters(self):
# assert self.test_shape.rotation_angle == 360
assert self.test_shape.start_angle == 0 | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def check_raw_parameters(self):\n # exclude some irrelevant or mandatory parameters\n excluded_keys = (\"cmd\", \"client\", \"resource_group_name\", \"name\")\n # check whether the remaining parameters are set\n # the default value None or False (and other empty values, like empty strin... | [
"0.57292235",
"0.5649407",
"0.5493077",
"0.54790646",
"0.5410326",
"0.54050815",
"0.539264",
"0.53915656",
"0.5389374",
"0.53777575",
"0.53308314",
"0.5328452",
"0.52771133",
"0.5256819",
"0.5243553",
"0.52401507",
"0.5219868",
"0.5205472",
"0.5191979",
"0.5157206",
"0.515077... | 0.5559056 | 2 |
Creates a coolant channel ring using the CoolantChannelRingStraight parameteric shape and checks that a cadquery solid is created. | def test_creation(self):
assert self.test_shape.solid is not None
assert self.test_shape.volume() > 1000 | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def add_cable_ring(self, env, info={}, cable_idx=0):\n def rad_to_deg(rad):\n return (rad * 180.0) / np.pi\n\n def get_discretized_rotations(num_rotations):\n # counter-clockwise\n theta = i * (2 * np.pi) / num_rotations\n return (theta, rad_to_deg(theta))\... | [
"0.6032365",
"0.5329425",
"0.5172214",
"0.5099691",
"0.50813854",
"0.5008946",
"0.5005978",
"0.49561918",
"0.4910132",
"0.4908677",
"0.48693416",
"0.48510155",
"0.48496482",
"0.4801606",
"0.48015696",
"0.4749347",
"0.47295332",
"0.47240025",
"0.4691071",
"0.4684929",
"0.46806... | 0.42844978 | 99 |
Creates a CoolantChannelRingStraight shape and checks that the areas of its faces are correct. | def test_faces(self):
self.test_shape.workplane = "XY"
self.test_shape.rotation_axis = "Z"
assert self.test_shape.area == pytest.approx((((math.pi * (10**2)) * 2) + (math.pi * (10 * 2) * 100)) * 8)
assert len(self.test_shape.areas) == 24
assert self.test_shape.areas.count(pytes... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def add_cable_ring(self, env, info={}, cable_idx=0):\n def rad_to_deg(rad):\n return (rad * 180.0) / np.pi\n\n def get_discretized_rotations(num_rotations):\n # counter-clockwise\n theta = i * (2 * np.pi) / num_rotations\n return (theta, rad_to_deg(theta))\... | [
"0.54048467",
"0.537262",
"0.5357499",
"0.5338746",
"0.5328752",
"0.529666",
"0.51922953",
"0.51870656",
"0.51857233",
"0.5181824",
"0.5127006",
"0.512343",
"0.5072488",
"0.507105",
"0.5065166",
"0.50545657",
"0.5044749",
"0.501881",
"0.5014258",
"0.49945888",
"0.49945888",
... | 0.0 | -1 |
Creates CoolantChannelRingStraight shapes and checks that the volumes are correct. | def test_volume(self):
self.test_shape.workplane = "XY"
self.test_shape.rotation_axis = "Z"
assert self.test_shape.volume() == pytest.approx(math.pi * (10**2) * 100 * 8) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_creation(self):\n\n assert self.test_shape.solid is not None\n assert self.test_shape.volume() > 1000",
"def test_creation(self):\n\n assert self.test_shape.solid is not None\n assert self.test_shape.volume() > 1000",
"def add_cable_ring(self, env, info={}, cable_idx=0):\n ... | [
"0.5674478",
"0.5674478",
"0.5592306",
"0.55478907",
"0.54318386",
"0.541907",
"0.5385598",
"0.53693736",
"0.53376484",
"0.5288099",
"0.5281223",
"0.52626747",
"0.5222897",
"0.51526165",
"0.51446766",
"0.5129756",
"0.5091278",
"0.50819427",
"0.5051377",
"0.504616",
"0.5023189... | 0.0 | -1 |
Checks that the coolant channels are placed at the correct azimuthal placement angles for a given start angle. | def test_start_angle(self):
assert self.test_shape.azimuth_placement_angle == [
0,
45,
90,
135,
180,
225,
270,
315,
]
self.test_shape.start_angle = 10
assert self.test_shape.azimuth_placement... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def check_angle_of_arcs(self):\n\n if self.thin_arc_start_angle >= 3600:\n self.thin_arc_start_angle %= 360\n self.thin_arc_start_angle += 360\n\n elif self.thin_arc_start_angle <= -3600:\n self.thin_arc_start_angle %= 360\n self.thin_arc_start_angle -= 360... | [
"0.64040065",
"0.55662644",
"0.5453842",
"0.54343426",
"0.542246",
"0.5321511",
"0.52047867",
"0.5199475",
"0.51695144",
"0.5155091",
"0.5144264",
"0.5114534",
"0.50843585",
"0.505066",
"0.50357336",
"0.50191617",
"0.5004695",
"0.49946713",
"0.4977154",
"0.49758136",
"0.49680... | 0.610046 | 1 |
Test import dataset wine. | def test_import_wine():
X, y = wine_data()
assert(X.shape[1] == 12)
assert(len(y.unique().tolist()) == 3)
assert(X.shape[0] == y.shape[0]) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_import_data():\n\n file_path = os.path.join(CONST_ADVANTICSYS_DIR, CONST_ADVANTICSYS_TEST_1)\n\n # Bring df\n success, log, test_ingress_df = advanticsys_import(file_path)\n assert success, log\n assert isinstance(test_ingress_df, pd.DataFrame)\n\n # Test import function\n success, lo... | [
"0.6878423",
"0.6717447",
"0.66107994",
"0.6513562",
"0.64724684",
"0.6419172",
"0.635929",
"0.63393587",
"0.6322275",
"0.6305654",
"0.6271661",
"0.6262919",
"0.6250121",
"0.62494475",
"0.6245525",
"0.6239293",
"0.62058556",
"0.61902046",
"0.61705625",
"0.615137",
"0.6088381"... | 0.74175483 | 0 |
Constructor. Sets the parent, sets up the UI and fills the tree. | def __init__(self, iface=None):
parent = None if iface is None else iface.mainWindow()
super(DockWidget, self).__init__(parent)
# Set up the user interface from Designer.
# After setupUI you can access any designer object by doing
# self.<objectname>, and you can use autoconnect ... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def create(self, parent):\n self.widget = QtGui.QTreeView(parent)",
"def __init__(self, parent=None):\n super(Representative, self).__init__(parent)\n self.setupUi(self)",
"def __init__(self,parent, id = wx.ID_ANY, pos = (10,10), size=(-1,-1)):\n\n wx.TreeCtrl.__init__(self, parent,... | [
"0.76014423",
"0.7525523",
"0.7442736",
"0.7348248",
"0.7325853",
"0.7277504",
"0.72760564",
"0.7221381",
"0.7190728",
"0.7139197",
"0.71225977",
"0.709324",
"0.7070534",
"0.7013553",
"0.691987",
"0.6911241",
"0.69035274",
"0.6893549",
"0.6848428",
"0.68216026",
"0.6812221",
... | 0.0 | -1 |
Returns ranked accuracy given true classes and predicted probabilities. | def top_k_accuracy(y_true : np.ndarray, probs: np.ndarray, k: int) -> float:
# Top k sorted preds
sorted_probs = probs.argsort()[:,-k:]
# Does the truth intersect with any of the top k predictions?
matches = np.max(sorted_probs == y_true.reshape(-1, 1), axis=1)
return matches.mean() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def calc_accuracy(true, predicted):\n return sum([t==p for t,p in zip(true, predicted)]) / float(len(true))",
"def accuracy(preds, labels):\n correct = preds == labels\n return correct.sum().float() / correct.shape[0]",
"def accuracy(predicted, ground_truth):\n predicted_labels_decoded = np... | [
"0.7954947",
"0.78648776",
"0.7796339",
"0.7776252",
"0.77718586",
"0.7771421",
"0.7771421",
"0.775524",
"0.7739714",
"0.7696608",
"0.7682014",
"0.76794153",
"0.7577913",
"0.7562003",
"0.7551231",
"0.75275767",
"0.75275767",
"0.75218564",
"0.7516644",
"0.75076306",
"0.7505706... | 0.0 | -1 |
Builds a tree, starting at root, of matching subsequences between sorted_nodes1 and sorted_nodes2. The subsequences match if the order of the nodes is preserved and they satisfy are_equal_nodes. | def fill_tree(root, sorted_nodes1, sorted_nodes2):
for id1 in range(root.id1+1, len(sorted_nodes1)):
for id2 in range(root.id2+1, len(sorted_nodes2)):
if are_equal_nodes(sorted_nodes1[id1], sorted_nodes2[id2]):
child_node = TreeNode(id1, id2)
fill_tree(child_node,... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def find_longest_matches(sorted_nodes1, sorted_nodes2):\n root = TreeNode(-1,-1)\n fill_tree(root, sorted_nodes1, sorted_nodes2)\n match = find_treepaths(root, [])\n\n # Remove (-1, -1) superroot.\n if isinstance(match[0], list): # More than one match of the same length.\n res = []\n f... | [
"0.6480154",
"0.6017104",
"0.5900179",
"0.58926785",
"0.57914406",
"0.5785781",
"0.56803095",
"0.5670274",
"0.5616493",
"0.5585591",
"0.548172",
"0.5441299",
"0.5415218",
"0.54117894",
"0.5322896",
"0.53055215",
"0.53055215",
"0.52935976",
"0.5283271",
"0.5247669",
"0.5240782... | 0.7211512 | 0 |
Returns the longest paths through the tree starting at root. | def find_treepaths(root, treepaths):
treepaths.append(root)# possible that more than one match of the same length
if root.children:
path_children = max(root.children, key = lambda node: node.depth) # pick the deepest child tree(s)
if isinstance(path_children, TreeNode):
find_treepath... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def longest_path(game, player, cur_length=0, max_length=10):\n moves = game.get_legal_moves(player)\n\n # Break recursion if we reach a dead end or we're at the limit.\n if not moves or cur_length >= max_length:\n return cur_length\n # Otherwise search recursively.\n else:\n best_depth... | [
"0.70472926",
"0.66193223",
"0.64925385",
"0.6379252",
"0.6372987",
"0.6354955",
"0.6342008",
"0.63089573",
"0.62788874",
"0.62379885",
"0.6157672",
"0.61548233",
"0.6142876",
"0.60721266",
"0.6016198",
"0.59961236",
"0.5966782",
"0.59641474",
"0.5886199",
"0.58638775",
"0.58... | 0.5438467 | 73 |
Returns the longest common subsequences between sorted_nodes1 and sorted_nodes2. | def find_longest_matches(sorted_nodes1, sorted_nodes2):
root = TreeNode(-1,-1)
fill_tree(root, sorted_nodes1, sorted_nodes2)
match = find_treepaths(root, [])
# Remove (-1, -1) superroot.
if isinstance(match[0], list): # More than one match of the same length.
res = []
for m in match... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def longest_common_subsequence(seq1, seq2):\n mat = DPMatrix(seq1, seq2, match=1, mismatch=0, gap=0)\n mat.fill()\n\n lcs = []\n augSeq1, augSeq2 = mat.augmented_sequences()\n for c1, c2 in zip(augSeq1, augSeq2):\n if c1 == c2:\n lcs.append(c1)\n\n return ''.join(lcs)",
"def l... | [
"0.7247269",
"0.71503085",
"0.69920135",
"0.6895138",
"0.68178797",
"0.6648128",
"0.64169645",
"0.63929033",
"0.6190487",
"0.6148989",
"0.6120559",
"0.6112058",
"0.6086676",
"0.6060063",
"0.6056009",
"0.5992014",
"0.5970511",
"0.59483576",
"0.5925975",
"0.5925972",
"0.5920781... | 0.75042135 | 0 |
Converts matched pairs of indices in sorted_small_nodes and sorted_large_nodes into matched pairs of nodeids. | def get_matched_nodeids_from_orderids(sorted_small_nodes, sorted_large_nodes, matched_orderids):
orderid2nodeid_func = lambda order_pair: (sorted_small_nodes[order_pair[0]].nodeid, sorted_large_nodes[order_pair[1]].nodeid)
return list(map(orderid2nodeid_func, matched_orderids)) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_matching_nodeids(small_dmrs, large_dmrs, all_surface=False):\n sorted_small_nodes = sort_nodes(small_dmrs.nodes)\n sorted_large_nodes = sort_nodes(large_dmrs.nodes)\n\n longest_matches = find_longest_matches(sorted_small_nodes, sorted_large_nodes) # list (of lists) of tuples (id_from_sub, id)\n\n ... | [
"0.6820625",
"0.5716441",
"0.5706402",
"0.56754607",
"0.55908996",
"0.5546528",
"0.5427354",
"0.5134633",
"0.5119809",
"0.5119312",
"0.50765777",
"0.50579196",
"0.5057068",
"0.5023635",
"0.50086886",
"0.4989392",
"0.49750262",
"0.49497184",
"0.49187142",
"0.48737258",
"0.4856... | 0.7717208 | 0 |
Finds nodeids present in the aligned matched region of the large DMRS, but which have no equivalents in the small DMRS. | def find_extra_surface_nodeids(orderids, sorted_large_nodes):
extra_nodeids = []
first_overlap_orderid = orderids[0]
min_cfrom = sorted_nodes[first_overlap_orderid].cfrom
# Check if any earlier nodes also in the region.
while True:
prev_cfrom = sorted_nodes[first_overlap_orderid-1].cfrom
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_matching_nodeids(small_dmrs, large_dmrs, all_surface=False):\n sorted_small_nodes = sort_nodes(small_dmrs.nodes)\n sorted_large_nodes = sort_nodes(large_dmrs.nodes)\n\n longest_matches = find_longest_matches(sorted_small_nodes, sorted_large_nodes) # list (of lists) of tuples (id_from_sub, id)\n\n ... | [
"0.7025583",
"0.58557904",
"0.5646902",
"0.56260955",
"0.55979025",
"0.5596457",
"0.5506559",
"0.54735655",
"0.54688025",
"0.5428346",
"0.54266435",
"0.5401781",
"0.5376381",
"0.53503776",
"0.53159696",
"0.53106",
"0.5259019",
"0.52510506",
"0.52362823",
"0.52313286",
"0.5221... | 0.56096166 | 4 |
Returns a subgraph of dmrs containing only nodes with subgraph_nodeids and all the links between them. | def get_subgraph(dmrs, subgraph_nodeids):
links = []
for nodeid in subgraph_nodeids:
node_links = dmrs.get_out(nodeid)
for link in node_links:
if link.end in subgraph_nodeids:
links.append(link)
nodes = [dmrs[nodeid] for nodeid in subgraph_nodeids]
return Dict... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_subgraphs(graph):\n nodes_powerset = get_nodes_combinations(graph)\n #print(\"Doing\")\n #draw_graph(graph)\n subgraphs = []\n for nodes in nodes_powerset:\n subg = graph.subgraph(nodes)\n nodes = subg.nodes(data=True)\n if nx.is_weakly_connected(subg):\n subg... | [
"0.7035432",
"0.6588273",
"0.651714",
"0.6372824",
"0.6290915",
"0.6162915",
"0.5933553",
"0.59246063",
"0.59132445",
"0.5816567",
"0.57999897",
"0.57736963",
"0.57541233",
"0.5741261",
"0.566491",
"0.5662782",
"0.5647418",
"0.5560412",
"0.5558986",
"0.5549748",
"0.55334896",... | 0.819001 | 0 |
Finds matching pairs of nodeids between small_dmrs and large_dmrs. | def get_matching_nodeids(small_dmrs, large_dmrs, all_surface=False):
sorted_small_nodes = sort_nodes(small_dmrs.nodes)
sorted_large_nodes = sort_nodes(large_dmrs.nodes)
longest_matches = find_longest_matches(sorted_small_nodes, sorted_large_nodes) # list (of lists) of tuples (id_from_sub, id)
all_matc... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_matched_nodeids_from_orderids(sorted_small_nodes, sorted_large_nodes, matched_orderids):\n orderid2nodeid_func = lambda order_pair: (sorted_small_nodes[order_pair[0]].nodeid, sorted_large_nodes[order_pair[1]].nodeid)\n return list(map(orderid2nodeid_func, matched_orderids))",
"def get_matches(self,... | [
"0.7055238",
"0.5894939",
"0.55227906",
"0.5489085",
"0.54599357",
"0.5449781",
"0.5447405",
"0.5445119",
"0.5440812",
"0.53929174",
"0.53769183",
"0.537584",
"0.5372282",
"0.5365889",
"0.53626955",
"0.5340169",
"0.53266394",
"0.5322242",
"0.531484",
"0.53060037",
"0.5296792"... | 0.82478267 | 0 |
Check for equality, in everything but the last provenance. | def verify_slim_restart_equality(self, in_ts, out_ts):
assert in_ts.num_provenances + 1 == out_ts.num_provenances
in_tables = in_ts.dump_tables()
in_tables.sort()
out_tables = out_ts.dump_tables()
out_tables.sort()
self.assertTableCollectionsEqual(in_tables, out_tables, s... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def testEquality(self):\n pass",
"def test_equality(self):\n self.assertTrue(Record(1, 2) == Record(1, 2))\n self.assertFalse(Record(1, 2) == Record(1, 3))\n self.assertFalse(Record(1, 2) == Record(2, 2))\n self.assertFalse(Record(1, 2) == Record(3, 4))",
"def test_equal_on_e... | [
"0.7151801",
"0.67575616",
"0.6750969",
"0.6594036",
"0.65184104",
"0.64447683",
"0.64215165",
"0.6413873",
"0.63874745",
"0.6368648",
"0.636855",
"0.6347611",
"0.63152367",
"0.63029677",
"0.6300809",
"0.6295113",
"0.6253116",
"0.62390214",
"0.6235458",
"0.62001276",
"0.61816... | 0.0 | -1 |
Number of tree encounters when slope is (3,1) | def solve_part1(input):
def is_tree(cell):
return 1 if cell == "#" else 0
def get_cell(row, pos):
return row[pos % len(row)]
pos = 0
trees = 0
for row in input:
trees += is_tree(get_cell(row, pos))
pos += 3
return trees | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def leaf_count(t: Tree) -> int:\n if t.children == []:\n return 1\n else:\n return sum([leaf_count(child) for child in t.children])",
"def leaf_count(self) -> int:\n if self.children == []:\n return 1\n else:\n return sum([x.leaf_count() for x in self.child... | [
"0.6907491",
"0.68810225",
"0.6854434",
"0.6781808",
"0.6753598",
"0.66757894",
"0.66155106",
"0.6588846",
"0.6567529",
"0.6486102",
"0.64605945",
"0.64430356",
"0.6425145",
"0.6416989",
"0.63806796",
"0.63761276",
"0.6331753",
"0.6319245",
"0.63084203",
"0.6269724",
"0.62279... | 0.0 | -1 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.